2011-09-27 14:07:56 -04:00
|
|
|
require 'rubygems'
|
2011-09-18 16:02:34 -04:00
|
|
|
require 'rack'
|
2011-09-27 13:53:45 -04:00
|
|
|
require 'stringio'
|
2011-09-27 12:23:03 -04:00
|
|
|
|
2011-09-22 22:24:43 -04:00
|
|
|
require 'puma/thread_pool'
|
2011-09-27 12:23:03 -04:00
|
|
|
require 'puma/const'
|
2011-09-27 16:52:50 -04:00
|
|
|
require 'puma/events'
|
2011-12-01 17:33:34 -05:00
|
|
|
require 'puma/null_io'
|
2011-09-27 12:23:03 -04:00
|
|
|
|
2011-10-02 12:33:48 -04:00
|
|
|
require 'puma_http11'
|
2011-09-27 12:23:03 -04:00
|
|
|
|
|
|
|
require 'socket'
|
2011-09-18 16:02:34 -04:00
|
|
|
|
2011-09-22 22:24:43 -04:00
|
|
|
module Puma
|
2011-12-01 18:23:14 -05:00
|
|
|
|
|
|
|
# The HTTP Server itself. Serves out a single Rack app.
|
2011-09-18 16:02:34 -04:00
|
|
|
class Server
|
|
|
|
|
2011-09-22 22:24:43 -04:00
|
|
|
include Puma::Const
|
2011-09-18 16:02:34 -04:00
|
|
|
|
2011-09-27 17:33:17 -04:00
|
|
|
attr_reader :thread
|
|
|
|
attr_reader :events
|
2011-09-23 01:14:39 -04:00
|
|
|
attr_accessor :app
|
|
|
|
|
2011-09-27 17:33:17 -04:00
|
|
|
attr_accessor :min_threads
|
|
|
|
attr_accessor :max_threads
|
2011-10-05 00:11:10 -04:00
|
|
|
attr_accessor :persistent_timeout
|
2011-12-05 13:07:01 -05:00
|
|
|
attr_accessor :auto_trim_time
|
2011-09-23 01:14:39 -04:00
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# Create a server for the rack app +app+.
|
|
|
|
#
|
|
|
|
# +events+ is an object which will be called when certain error events occur
|
|
|
|
# to be handled. See Puma::Events for the list of current methods to implement.
|
2011-09-18 16:02:34 -04:00
|
|
|
#
|
2011-12-01 18:23:14 -05:00
|
|
|
# Server#run returns a thread that you can join on to wait for the server
|
|
|
|
# to do it's work.
|
2011-09-18 16:02:34 -04:00
|
|
|
#
|
2011-09-27 17:33:17 -04:00
|
|
|
def initialize(app, events=Events::DEFAULT)
|
|
|
|
@app = app
|
|
|
|
@events = events
|
2011-09-18 16:02:34 -04:00
|
|
|
|
|
|
|
@check, @notify = IO.pipe
|
2011-09-27 13:53:45 -04:00
|
|
|
@ios = [@check]
|
|
|
|
|
2011-12-05 12:01:19 -05:00
|
|
|
@status = :stop
|
2011-09-23 01:14:39 -04:00
|
|
|
|
2011-09-27 17:33:17 -04:00
|
|
|
@min_threads = 0
|
|
|
|
@max_threads = 16
|
2011-12-05 13:07:01 -05:00
|
|
|
@auto_trim_time = 1
|
2011-09-24 03:26:17 -04:00
|
|
|
|
2011-09-27 17:33:17 -04:00
|
|
|
@thread = nil
|
|
|
|
@thread_pool = nil
|
2011-09-27 14:29:20 -04:00
|
|
|
|
2011-10-05 00:11:10 -04:00
|
|
|
@persistent_timeout = PERSISTENT_TIMEOUT
|
|
|
|
|
2011-09-27 14:29:20 -04:00
|
|
|
@proto_env = {
|
|
|
|
"rack.version".freeze => Rack::VERSION,
|
2011-09-27 16:52:50 -04:00
|
|
|
"rack.errors".freeze => events.stderr,
|
2011-09-27 14:29:20 -04:00
|
|
|
"rack.multithread".freeze => true,
|
|
|
|
"rack.multiprocess".freeze => false,
|
|
|
|
"rack.run_once".freeze => true,
|
|
|
|
"SCRIPT_NAME".freeze => "",
|
|
|
|
"CONTENT_TYPE".freeze => "",
|
|
|
|
"QUERY_STRING".freeze => "",
|
|
|
|
SERVER_PROTOCOL => HTTP_11,
|
|
|
|
SERVER_SOFTWARE => PUMA_VERSION,
|
|
|
|
GATEWAY_INTERFACE => CGI_VER
|
|
|
|
}
|
2011-09-18 16:02:34 -04:00
|
|
|
end
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# On Linux, use TCP_CORK to better control how the TCP stack
|
|
|
|
# packetizes our stream. This improves both latency and throughput.
|
|
|
|
#
|
2011-12-01 14:40:30 -05:00
|
|
|
if RUBY_PLATFORM =~ /linux/
|
|
|
|
# 6 == Socket::IPPROTO_TCP
|
|
|
|
# 3 == TCP_CORK
|
|
|
|
# 1/0 == turn on/off
|
|
|
|
def cork_socket(socket)
|
2011-12-01 16:08:53 -05:00
|
|
|
socket.setsockopt(6, 3, 1) if socket.kind_of? TCPSocket
|
2011-12-01 14:40:30 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def uncork_socket(socket)
|
2011-12-01 16:08:53 -05:00
|
|
|
socket.setsockopt(6, 3, 0) if socket.kind_of? TCPSocket
|
2011-12-01 14:40:30 -05:00
|
|
|
end
|
|
|
|
else
|
|
|
|
def cork_socket(socket)
|
|
|
|
end
|
|
|
|
|
|
|
|
def uncork_socket(socket)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# Tell the server to listen on host +host+, port +port+.
|
|
|
|
# If optimize_for_latency is true (the default) then clients connecting
|
|
|
|
# will be optimized for latency over throughput.
|
|
|
|
#
|
2011-12-01 00:30:12 -05:00
|
|
|
def add_tcp_listener(host, port, optimize_for_latency=true)
|
|
|
|
s = TCPServer.new(host, port)
|
|
|
|
if optimize_for_latency
|
|
|
|
s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
|
|
|
|
end
|
|
|
|
@ios << s
|
2011-09-27 13:53:45 -04:00
|
|
|
end
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# Tell the server to listen on +path+ as a UNIX domain socket.
|
|
|
|
#
|
2011-09-27 13:53:45 -04:00
|
|
|
def add_unix_listener(path)
|
|
|
|
@ios << UNIXServer.new(path)
|
|
|
|
end
|
|
|
|
|
2011-12-05 14:15:44 -05:00
|
|
|
def backlog
|
|
|
|
@thread_pool and @thread_pool.backlog
|
|
|
|
end
|
|
|
|
|
|
|
|
def running
|
|
|
|
@thread_pool and @thread_pool.spawned
|
|
|
|
end
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# Runs the server. It returns the thread used so you can join it.
|
|
|
|
# The thread is always available via #thread to be join'd
|
|
|
|
#
|
2011-09-24 03:19:22 -04:00
|
|
|
def run
|
|
|
|
BasicSocket.do_not_reverse_lookup = true
|
|
|
|
|
2011-12-05 12:01:19 -05:00
|
|
|
@status = :run
|
2011-09-27 17:33:17 -04:00
|
|
|
|
|
|
|
@thread_pool = ThreadPool.new(@min_threads, @max_threads) do |client|
|
|
|
|
process_client(client)
|
|
|
|
end
|
|
|
|
|
2011-12-05 13:07:01 -05:00
|
|
|
if @auto_trim_time
|
|
|
|
@thread_pool.auto_trim!(@auto_trim_time)
|
|
|
|
end
|
|
|
|
|
2011-09-27 17:33:17 -04:00
|
|
|
@thread = Thread.new do
|
2011-09-24 03:19:22 -04:00
|
|
|
begin
|
|
|
|
check = @check
|
2011-09-27 13:53:45 -04:00
|
|
|
sockets = @ios
|
2011-09-24 03:19:22 -04:00
|
|
|
pool = @thread_pool
|
|
|
|
|
2011-12-05 12:01:19 -05:00
|
|
|
while @status == :run
|
2011-09-24 03:19:22 -04:00
|
|
|
begin
|
|
|
|
ios = IO.select sockets
|
|
|
|
ios.first.each do |sock|
|
|
|
|
if sock == check
|
|
|
|
break if handle_check
|
|
|
|
else
|
2011-09-27 13:53:45 -04:00
|
|
|
pool << sock.accept
|
2011-09-24 03:19:22 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
rescue Errno::ECONNABORTED
|
|
|
|
# client closed the socket even before accept
|
|
|
|
client.close rescue nil
|
|
|
|
rescue Object => e
|
2011-09-27 16:52:50 -04:00
|
|
|
@events.unknown_error self, env, e, "Listen loop"
|
2011-09-24 03:19:22 -04:00
|
|
|
end
|
|
|
|
end
|
2011-12-05 12:01:19 -05:00
|
|
|
|
|
|
|
graceful_shutdown if @status == :stop
|
2011-09-24 03:19:22 -04:00
|
|
|
ensure
|
2011-09-27 13:53:45 -04:00
|
|
|
@ios.each { |i| i.close }
|
2011-09-18 16:02:34 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2011-09-27 17:33:17 -04:00
|
|
|
return @thread
|
2011-09-24 03:19:22 -04:00
|
|
|
end
|
2011-09-18 16:02:34 -04:00
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# :nodoc:
|
2011-09-24 03:19:22 -04:00
|
|
|
def handle_check
|
|
|
|
cmd = @check.read(1)
|
|
|
|
|
|
|
|
case cmd
|
|
|
|
when STOP_COMMAND
|
2011-12-05 12:01:19 -05:00
|
|
|
@status = :stop
|
|
|
|
return true
|
|
|
|
when HALT_COMMAND
|
|
|
|
@status = :halt
|
2011-09-24 03:19:22 -04:00
|
|
|
return true
|
|
|
|
end
|
|
|
|
|
|
|
|
return false
|
2011-09-18 16:02:34 -04:00
|
|
|
end
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# Given a connection on +client+, handle the incoming requests.
|
|
|
|
#
|
|
|
|
# This method support HTTP Keep-Alive so it may, depending on if the client
|
|
|
|
# indicates that it supports keep alive, wait for another request before
|
|
|
|
# returning.
|
|
|
|
#
|
2011-09-18 16:02:34 -04:00
|
|
|
def process_client(client)
|
2011-12-01 16:32:21 -05:00
|
|
|
parser = HttpParser.new
|
|
|
|
|
2011-09-18 16:02:34 -04:00
|
|
|
begin
|
2011-09-30 11:30:37 -04:00
|
|
|
while true
|
2011-12-01 16:32:21 -05:00
|
|
|
parser.reset
|
|
|
|
|
2011-09-30 11:30:37 -04:00
|
|
|
env = @proto_env.dup
|
|
|
|
data = client.readpartial(CHUNK_SIZE)
|
|
|
|
nparsed = 0
|
|
|
|
|
|
|
|
# Assumption: nparsed will always be less since data will get filled
|
|
|
|
# with more after each parsing. If it doesn't get more then there was
|
|
|
|
# a problem with the read operation on the client socket.
|
|
|
|
# Effect is to stop processing when the socket can't fill the buffer
|
|
|
|
# for further parsing.
|
|
|
|
while nparsed < data.length
|
|
|
|
nparsed = parser.execute(env, data, nparsed)
|
|
|
|
|
|
|
|
if parser.finished?
|
2011-11-22 13:45:58 -05:00
|
|
|
cl = env[CONTENT_LENGTH]
|
|
|
|
|
|
|
|
return unless handle_request(env, client, parser.body, cl)
|
|
|
|
|
|
|
|
nparsed += parser.body.size if cl
|
2011-10-05 00:11:10 -04:00
|
|
|
|
2011-10-18 01:47:35 -04:00
|
|
|
if data.size > nparsed
|
|
|
|
data.slice!(0, nparsed)
|
2011-12-01 17:48:14 -05:00
|
|
|
parser.reset
|
2011-10-18 01:47:35 -04:00
|
|
|
env = @proto_env.dup
|
|
|
|
nparsed = 0
|
|
|
|
else
|
|
|
|
unless IO.select([client], nil, nil, @persistent_timeout)
|
|
|
|
raise EOFError, "Timed out persistent connection"
|
|
|
|
end
|
2011-10-05 00:11:10 -04:00
|
|
|
end
|
2011-09-30 11:30:37 -04:00
|
|
|
else
|
|
|
|
# Parser is not done, queue up more data to read and continue parsing
|
|
|
|
chunk = client.readpartial(CHUNK_SIZE)
|
|
|
|
return if !chunk or chunk.length == 0 # read failed, stop processing
|
|
|
|
|
|
|
|
data << chunk
|
|
|
|
if data.length >= MAX_HEADER
|
|
|
|
raise HttpParserError,
|
|
|
|
"HEADER is longer than allowed, aborting client early."
|
|
|
|
end
|
2011-09-18 16:02:34 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2011-12-01 18:23:14 -05:00
|
|
|
|
|
|
|
# The client disconnected while we were reading data
|
2011-09-27 16:52:50 -04:00
|
|
|
rescue EOFError, SystemCallError
|
2011-12-01 18:23:14 -05:00
|
|
|
# Swallow them. The ensure tries to close +client+ down
|
2011-09-18 16:02:34 -04:00
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# The client doesn't know HTTP well
|
2011-09-18 16:02:34 -04:00
|
|
|
rescue HttpParserError => e
|
2011-09-27 16:52:50 -04:00
|
|
|
@events.parse_error self, env, e
|
2011-09-18 16:02:34 -04:00
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# Server error
|
2011-09-27 16:52:50 -04:00
|
|
|
rescue StandardError => e
|
|
|
|
@events.unknown_error self, env, e, "Read"
|
2011-09-18 16:02:34 -04:00
|
|
|
|
|
|
|
ensure
|
|
|
|
begin
|
|
|
|
client.close
|
2011-09-27 16:52:50 -04:00
|
|
|
rescue IOError, SystemCallError
|
2011-09-18 16:02:34 -04:00
|
|
|
# Already closed
|
2011-09-27 16:52:50 -04:00
|
|
|
rescue StandardError => e
|
|
|
|
@events.unknown_error self, env, e, "Client"
|
2011-09-18 16:02:34 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# Given a Hash +env+ for the request read from +client+, add
|
|
|
|
# and fixup keys to comply with Rack's env guidelines.
|
|
|
|
#
|
2011-09-27 14:29:20 -04:00
|
|
|
def normalize_env(env, client)
|
|
|
|
if host = env[HTTP_HOST]
|
2011-09-24 03:19:22 -04:00
|
|
|
if colon = host.index(":")
|
2011-09-27 14:29:20 -04:00
|
|
|
env[SERVER_NAME] = host[0, colon]
|
|
|
|
env[SERVER_PORT] = host[colon+1, host.size]
|
2011-09-24 03:19:22 -04:00
|
|
|
else
|
2011-09-27 14:29:20 -04:00
|
|
|
env[SERVER_NAME] = host
|
|
|
|
env[SERVER_PORT] = PORT_80
|
2011-09-18 16:02:34 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2011-09-27 14:29:20 -04:00
|
|
|
unless env[REQUEST_PATH]
|
2011-09-24 03:19:22 -04:00
|
|
|
# it might be a dumbass full host request header
|
2011-09-27 14:29:20 -04:00
|
|
|
uri = URI.parse(env[REQUEST_URI])
|
|
|
|
env[REQUEST_PATH] = uri.path
|
2011-09-24 02:26:13 -04:00
|
|
|
|
2011-09-27 14:29:20 -04:00
|
|
|
raise "No REQUEST PATH" unless env[REQUEST_PATH]
|
2011-09-24 02:26:13 -04:00
|
|
|
end
|
|
|
|
|
2011-10-14 15:15:35 -04:00
|
|
|
env[PATH_INFO] = env[REQUEST_PATH]
|
|
|
|
|
2011-09-24 03:19:22 -04:00
|
|
|
# From http://www.ietf.org/rfc/rfc3875 :
|
|
|
|
# "Script authors should be aware that the REMOTE_ADDR and
|
|
|
|
# REMOTE_HOST meta-variables (see sections 4.1.8 and 4.1.9)
|
|
|
|
# may not identify the ultimate source of the request.
|
|
|
|
# They identify the client for the immediate request to the
|
|
|
|
# server; that client may be a proxy, gateway, or other
|
|
|
|
# intermediary acting on behalf of the actual source client."
|
|
|
|
#
|
2011-09-27 14:29:20 -04:00
|
|
|
env[REMOTE_ADDR] = client.peeraddr.last
|
2011-09-24 02:26:13 -04:00
|
|
|
end
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# The object used for a request with no body. All requests with
|
|
|
|
# no body share this one object since it has no state.
|
2011-12-01 17:33:34 -05:00
|
|
|
EmptyBody = NullIO.new
|
2011-11-22 20:04:19 -05:00
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# Given the request +env+ from +client+ and a partial request body
|
|
|
|
# in +body+, finish reading the body if there is one and invoke
|
|
|
|
# the rack app. Then construct the response and write it back to
|
|
|
|
# +client+
|
|
|
|
#
|
|
|
|
# +cl+ is the previously fetched Content-Length header if there
|
|
|
|
# was one. This is an optimization to keep from having to look
|
|
|
|
# it up again.
|
|
|
|
#
|
2011-11-22 13:45:58 -05:00
|
|
|
def handle_request(env, client, body, cl)
|
2011-09-27 14:29:20 -04:00
|
|
|
normalize_env env, client
|
2011-09-24 02:26:13 -04:00
|
|
|
|
2011-11-22 14:47:50 -05:00
|
|
|
if cl
|
|
|
|
body = read_body env, client, body, cl
|
|
|
|
return false unless body
|
|
|
|
else
|
2011-12-01 17:33:34 -05:00
|
|
|
body = EmptyBody
|
2011-11-22 14:47:50 -05:00
|
|
|
end
|
2011-09-24 02:26:13 -04:00
|
|
|
|
2011-12-01 17:16:18 -05:00
|
|
|
env[RACK_INPUT] = body
|
|
|
|
env[RACK_URL_SCHEME] = env[HTTPS_KEY] ? HTTPS : HTTP
|
2011-09-18 16:02:34 -04:00
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# A rack extension. If the app writes #call'ables to this
|
|
|
|
# array, we will invoke them when the request is done.
|
|
|
|
#
|
2011-12-01 17:16:18 -05:00
|
|
|
after_reply = env[RACK_AFTER_REPLY] = []
|
2011-10-21 00:44:34 -04:00
|
|
|
|
2011-09-27 14:29:20 -04:00
|
|
|
begin
|
2011-09-24 03:26:17 -04:00
|
|
|
begin
|
|
|
|
status, headers, res_body = @app.call(env)
|
|
|
|
rescue => e
|
|
|
|
status, headers, res_body = lowlevel_error(e)
|
|
|
|
end
|
2011-09-18 16:02:34 -04:00
|
|
|
|
2011-09-30 11:30:37 -04:00
|
|
|
content_length = nil
|
|
|
|
|
2011-10-18 02:12:56 -04:00
|
|
|
if res_body.kind_of? Array and res_body.size == 1
|
2011-09-30 11:30:37 -04:00
|
|
|
content_length = res_body[0].size
|
|
|
|
end
|
|
|
|
|
2011-12-01 14:40:30 -05:00
|
|
|
cork_socket client
|
|
|
|
|
2011-12-01 17:16:18 -05:00
|
|
|
if env[HTTP_VERSION] == HTTP_11
|
|
|
|
allow_chunked = true
|
|
|
|
keep_alive = env[HTTP_CONNECTION] != CLOSE
|
|
|
|
include_keepalive_header = false
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# An optimization. The most common response is 200, so we can
|
|
|
|
# reply with the proper 200 status without having to compute
|
|
|
|
# the response header.
|
|
|
|
#
|
2011-12-01 17:16:18 -05:00
|
|
|
if status == 200
|
|
|
|
client.write HTTP_11_200
|
|
|
|
else
|
|
|
|
client.write "HTTP/1.1 "
|
|
|
|
client.write status.to_s
|
|
|
|
client.write " "
|
|
|
|
client.write HTTP_STATUS_CODES[status]
|
|
|
|
client.write "\r\n"
|
|
|
|
end
|
|
|
|
else
|
|
|
|
allow_chunked = false
|
|
|
|
keep_alive = env[HTTP_CONNECTION] == KEEP_ALIVE
|
|
|
|
include_keepalive_header = keep_alive
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# Same optimization as above for HTTP/1.1
|
|
|
|
#
|
2011-12-01 17:16:18 -05:00
|
|
|
if status == 200
|
|
|
|
client.write HTTP_10_200
|
|
|
|
else
|
|
|
|
client.write "HTTP/1.1 "
|
|
|
|
client.write status.to_s
|
|
|
|
client.write " "
|
|
|
|
client.write HTTP_STATUS_CODES[status]
|
|
|
|
client.write "\r\n"
|
|
|
|
end
|
|
|
|
end
|
2011-09-30 11:30:37 -04:00
|
|
|
|
2011-12-01 17:16:18 -05:00
|
|
|
colon = COLON
|
|
|
|
line_ending = LINE_END
|
2011-09-18 16:02:34 -04:00
|
|
|
|
2011-09-24 02:26:13 -04:00
|
|
|
headers.each do |k, vs|
|
2011-10-23 02:06:27 -04:00
|
|
|
case k
|
2011-12-01 17:16:18 -05:00
|
|
|
when CONTENT_LENGTH2
|
2011-10-17 16:56:45 -04:00
|
|
|
content_length = vs
|
|
|
|
next
|
2011-12-01 17:16:18 -05:00
|
|
|
when TRANSFER_ENCODING
|
2011-10-23 02:06:27 -04:00
|
|
|
allow_chunked = false
|
|
|
|
content_length = nil
|
2011-10-17 16:56:45 -04:00
|
|
|
end
|
|
|
|
|
2011-12-01 17:16:18 -05:00
|
|
|
vs.split(NEWLINE).each do |v|
|
2011-09-18 16:02:34 -04:00
|
|
|
client.write k
|
|
|
|
client.write colon
|
|
|
|
client.write v
|
|
|
|
client.write line_ending
|
2011-09-24 02:26:13 -04:00
|
|
|
end
|
|
|
|
end
|
2011-09-18 16:02:34 -04:00
|
|
|
|
2011-11-30 18:07:23 -05:00
|
|
|
if include_keepalive_header
|
2011-12-01 17:16:18 -05:00
|
|
|
client.write CONNECTION_KEEP_ALIVE
|
2011-11-30 18:07:23 -05:00
|
|
|
elsif !keep_alive
|
2011-12-01 17:16:18 -05:00
|
|
|
client.write CONNECTION_CLOSE
|
2011-11-30 18:07:23 -05:00
|
|
|
end
|
2011-10-17 16:56:45 -04:00
|
|
|
|
|
|
|
if content_length
|
2011-12-01 17:16:18 -05:00
|
|
|
client.write CONTENT_LENGTH_S
|
|
|
|
client.write content_length.to_s
|
|
|
|
client.write line_ending
|
|
|
|
chunked = false
|
2011-10-18 02:08:09 -04:00
|
|
|
elsif allow_chunked
|
2011-12-01 17:16:18 -05:00
|
|
|
client.write TRANSFER_ENCODING_CHUNKED
|
2011-10-17 16:56:45 -04:00
|
|
|
chunked = true
|
|
|
|
end
|
|
|
|
|
2011-09-18 16:02:34 -04:00
|
|
|
client.write line_ending
|
|
|
|
|
2011-10-18 02:12:56 -04:00
|
|
|
res_body.each do |part|
|
2011-09-30 11:30:37 -04:00
|
|
|
if chunked
|
2011-10-18 02:12:56 -04:00
|
|
|
client.write part.size.to_s(16)
|
2011-09-30 11:30:37 -04:00
|
|
|
client.write line_ending
|
2011-10-18 02:12:56 -04:00
|
|
|
client.write part
|
2011-09-30 11:30:37 -04:00
|
|
|
client.write line_ending
|
|
|
|
else
|
2011-10-18 02:12:56 -04:00
|
|
|
client.write part
|
2011-09-30 11:30:37 -04:00
|
|
|
end
|
|
|
|
|
2011-09-18 16:02:34 -04:00
|
|
|
client.flush
|
|
|
|
end
|
2011-09-30 11:30:37 -04:00
|
|
|
|
|
|
|
if chunked
|
2011-12-01 17:16:18 -05:00
|
|
|
client.write CLOSE_CHUNKED
|
2011-09-30 11:30:37 -04:00
|
|
|
client.flush
|
|
|
|
end
|
|
|
|
|
2011-09-18 16:02:34 -04:00
|
|
|
ensure
|
2011-12-01 14:40:30 -05:00
|
|
|
uncork_socket client
|
|
|
|
|
2011-09-24 02:26:13 -04:00
|
|
|
body.close
|
|
|
|
res_body.close if res_body.respond_to? :close
|
2011-10-21 00:44:34 -04:00
|
|
|
|
|
|
|
after_reply.each { |o| o.call }
|
2011-09-18 16:02:34 -04:00
|
|
|
end
|
2011-09-30 11:30:37 -04:00
|
|
|
|
|
|
|
return keep_alive
|
2011-09-18 16:02:34 -04:00
|
|
|
end
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# Given the requset +env+ from +client+ and the partial body +body+
|
|
|
|
# plus a potential Content-Length value +cl+, finish reading
|
|
|
|
# the body and return it.
|
|
|
|
#
|
|
|
|
# If the body is larger than MAX_BODY, a Tempfile object is used
|
|
|
|
# for the body, otherwise a StringIO is used.
|
|
|
|
#
|
2011-11-22 13:45:58 -05:00
|
|
|
def read_body(env, client, body, cl)
|
|
|
|
content_length = cl.to_i
|
2011-09-24 03:19:22 -04:00
|
|
|
|
|
|
|
remain = content_length - body.size
|
|
|
|
|
|
|
|
return StringIO.new(body) if remain <= 0
|
|
|
|
|
|
|
|
# Use a Tempfile if there is a lot of data left
|
|
|
|
if remain > MAX_BODY
|
|
|
|
stream = Tempfile.new(Const::PUMA_TMP_BASE)
|
|
|
|
stream.binmode
|
|
|
|
else
|
|
|
|
stream = StringIO.new
|
|
|
|
end
|
|
|
|
|
|
|
|
stream.write body
|
|
|
|
|
|
|
|
# Read an odd sized chunk so we can read even sized ones
|
|
|
|
# after this
|
|
|
|
chunk = client.readpartial(remain % CHUNK_SIZE)
|
|
|
|
|
|
|
|
# No chunk means a closed socket
|
|
|
|
unless chunk
|
|
|
|
stream.close
|
|
|
|
return nil
|
|
|
|
end
|
|
|
|
|
|
|
|
remain -= stream.write(chunk)
|
|
|
|
|
|
|
|
# Raed the rest of the chunks
|
|
|
|
while remain > 0
|
|
|
|
chunk = client.readpartial(CHUNK_SIZE)
|
|
|
|
unless chunk
|
|
|
|
stream.close
|
|
|
|
return nil
|
|
|
|
end
|
|
|
|
|
|
|
|
remain -= stream.write(chunk)
|
|
|
|
end
|
|
|
|
|
|
|
|
stream.rewind
|
|
|
|
|
|
|
|
return stream
|
|
|
|
end
|
|
|
|
|
2011-12-01 18:23:14 -05:00
|
|
|
# A fallback rack response if +@app+ raises as exception.
|
|
|
|
#
|
2011-09-24 03:26:17 -04:00
|
|
|
def lowlevel_error(e)
|
|
|
|
[500, {}, ["No application configured"]]
|
|
|
|
end
|
|
|
|
|
2011-09-24 03:19:22 -04:00
|
|
|
# Wait for all outstanding requests to finish.
|
2011-12-01 18:23:14 -05:00
|
|
|
#
|
2011-09-24 03:19:22 -04:00
|
|
|
def graceful_shutdown
|
2011-09-27 17:33:17 -04:00
|
|
|
@thread_pool.shutdown if @thread_pool
|
2011-09-24 03:19:22 -04:00
|
|
|
end
|
2011-09-23 01:14:39 -04:00
|
|
|
|
|
|
|
# Stops the acceptor thread and then causes the worker threads to finish
|
|
|
|
# off the request queue before finally exiting.
|
2011-12-01 18:23:14 -05:00
|
|
|
#
|
2011-09-23 01:14:39 -04:00
|
|
|
def stop(sync=false)
|
|
|
|
@notify << STOP_COMMAND
|
|
|
|
|
2011-09-27 17:33:17 -04:00
|
|
|
@thread.join if @thread && sync
|
2011-09-23 01:14:39 -04:00
|
|
|
end
|
2011-12-05 12:01:19 -05:00
|
|
|
|
|
|
|
def halt(sync=false)
|
|
|
|
@notify << HALT_COMMAND
|
|
|
|
|
|
|
|
@thread.join if @thread && sync
|
|
|
|
end
|
2011-09-18 16:02:34 -04:00
|
|
|
end
|
|
|
|
end
|