Class: Puma::Server
- Inherits:
-
Object
- Object
- Puma::Server
- Defined in:
- lib/puma/server.rb
Overview
The HTTP Server itself. Serves out a single Rack app.
This class is used by the ‘Puma::Single` and `Puma::Cluster` classes to generate one or more `Puma::Server` instances capable of handling requests. Each Puma process will contain one `Puma::Server` instance.
The ‘Puma::Server` instance pulls requests from the socket, adds them to a `Puma::Reactor` where they get eventually passed to a `Puma::ThreadPool`.
Each ‘Puma::Server` will have one reactor and one thread pool.
Constant Summary collapse
- THREAD_LOCAL_KEY =
:puma_server
- UNPACK_TCP_STATE_FROM_TCP_INFO =
"C".freeze
- STAT_METHODS =
List of methods invoked by #stats.
[:backlog, :running, :pool_capacity, :max_threads, :requests_count].freeze
Constants included from Request
Request::BODY_LEN_MAX, Request::CUSTOM_STAT, Request::IO_BODY_MAX, Request::IO_BUFFER_LEN_MAX, Request::SOCKET_WRITE_ERR_MSG
Constants included from Const
Const::BANNED_HEADER_KEY, Const::CGI_VER, Const::CHUNKED, Const::CHUNK_SIZE, Const::CLOSE, Const::CLOSE_CHUNKED, Const::CODE_NAME, Const::COLON, Const::CONNECTION_CLOSE, Const::CONNECTION_KEEP_ALIVE, Const::CONTENT_LENGTH, Const::CONTENT_LENGTH2, Const::CONTENT_LENGTH_S, Const::CONTINUE, Const::DQUOTE, Const::EARLY_HINTS, Const::ERROR_RESPONSE, Const::FAST_TRACK_KA_TIMEOUT, Const::GATEWAY_INTERFACE, Const::HALT_COMMAND, Const::HEAD, Const::HIJACK, Const::HIJACK_IO, Const::HIJACK_P, Const::HTTP, Const::HTTPS, Const::HTTPS_KEY, Const::HTTP_10_200, Const::HTTP_11, Const::HTTP_11_100, Const::HTTP_11_200, Const::HTTP_CONNECTION, Const::HTTP_EXPECT, Const::HTTP_HEADER_DELIMITER, Const::HTTP_HOST, Const::HTTP_VERSION, Const::HTTP_X_FORWARDED_FOR, Const::HTTP_X_FORWARDED_PROTO, Const::HTTP_X_FORWARDED_SCHEME, Const::HTTP_X_FORWARDED_SSL, Const::IANA_HTTP_METHODS, Const::ILLEGAL_HEADER_KEY_REGEX, Const::ILLEGAL_HEADER_VALUE_REGEX, Const::KEEP_ALIVE, Const::LINE_END, Const::LOCALHOST, Const::LOCALHOST_IPV4, Const::LOCALHOST_IPV6, Const::MAX_BODY, Const::MAX_HEADER, Const::NEWLINE, Const::PATH_INFO, Const::PORT_443, Const::PORT_80, Const::PROXY_PROTOCOL_V1_REGEX, Const::PUMA_CONFIG, Const::PUMA_PEERCERT, Const::PUMA_SERVER_STRING, Const::PUMA_SOCKET, Const::PUMA_TMP_BASE, Const::PUMA_VERSION, Const::QUERY_STRING, Const::RACK_AFTER_REPLY, Const::RACK_INPUT, Const::RACK_URL_SCHEME, Const::REMOTE_ADDR, Const::REQUEST_METHOD, Const::REQUEST_PATH, Const::REQUEST_URI, Const::RESTART_COMMAND, Const::SERVER_NAME, Const::SERVER_PORT, Const::SERVER_PROTOCOL, Const::SERVER_SOFTWARE, Const::STOP_COMMAND, Const::SUPPORTED_HTTP_METHODS, Const::TRANSFER_ENCODING, Const::TRANSFER_ENCODING2, Const::TRANSFER_ENCODING_CHUNKED, Const::UNSPECIFIED_IPV4, Const::UNSPECIFIED_IPV6, Const::WRITE_TIMEOUT
Class Attribute Summary collapse
- .current ⇒ Object readonly
Instance Attribute Summary collapse
-
#app ⇒ Object
Returns the value of attribute app.
- #auto_trim_time ⇒ Object readonly
- #backlog ⇒ Object readonly
-
#binder ⇒ Object
Returns the value of attribute binder.
- #connected_ports ⇒ Object readonly
- #early_hints ⇒ Object readonly
-
#events ⇒ Object
readonly
Returns the value of attribute events.
- #first_data_timeout ⇒ Object readonly
-
#idle_timeout_reached ⇒ Object
readonly
Returns the value of attribute idle_timeout_reached.
- #leak_stack_on_error ⇒ Object readonly
-
#log_writer ⇒ Object
readonly
Returns the value of attribute log_writer.
-
#max_threads ⇒ Object
readonly
for #stats.
-
#min_threads ⇒ Object
readonly
for #stats.
- #persistent_timeout ⇒ Object readonly
-
#pool_capacity ⇒ Object
readonly
This number represents the number of requests that the server is capable of taking right now.
- #reaping_time ⇒ Object readonly
- #requests_count ⇒ Object readonly
- #running ⇒ Object readonly
-
#stats ⇒ Object
readonly
Returns a hash of stats about the running server for reporting purposes.
-
#thread ⇒ Object
readonly
Returns the value of attribute thread.
Class Method Summary collapse
-
.closed_socket_supported? ⇒ Boolean
:nodoc:.
-
.tcp_cork_supported? ⇒ Boolean
:nodoc:.
Instance Method Summary collapse
- #add_ssl_listener(host, port, ctx, optimize_for_latency = true, backlog = 1024) ⇒ Object
- #add_tcp_listener(host, port, optimize_for_latency = true, backlog = 1024) ⇒ Object
- #add_unix_listener(path, umask = nil, mode = nil, backlog = 1024) ⇒ Object
- #begin_restart(sync = false) ⇒ Object
-
#client_error(e, client, requests = 1) ⇒ Object
Handle various error types thrown by Client I/O operations.
- #closed_socket?(socket) ⇒ Boolean
-
#cork_socket(socket) ⇒ Object
6 == Socket::IPPROTO_TCP 3 == TCP_CORK 1/0 == turn on/off.
-
#graceful_shutdown ⇒ Object
Wait for all outstanding requests to finish.
- #halt(sync = false) ⇒ Object
-
#handle_check ⇒ Object
:nodoc:.
- #handle_servers ⇒ Object
- #inherit_binder(bind) ⇒ Object
-
#initialize(app, events = nil, options = {}) ⇒ Server
constructor
Create a server for the rack app
app
. -
#lowlevel_error(e, env, status = 500) ⇒ Object
A fallback rack response if @app raises as exception.
-
#process_client(client) ⇒ Object
Given a connection on
client
, handle the incoming requests, or queue the connection in the Reactor if no request is available. -
#reactor_wakeup(client) ⇒ Object
This method is called from the Reactor thread when a queued Client receives data, times out, or when the Reactor is shutting down.
-
#run(background = true, thread_name: 'srv') ⇒ Object
Runs the server.
- #shutting_down? ⇒ Boolean
-
#stop(sync = false) ⇒ Object
Stops the acceptor thread and then causes the worker threads to finish off the request queue before finally exiting.
- #uncork_socket(socket) ⇒ Object
-
#with_force_shutdown(client, &block) ⇒ Object
Triggers a client timeout if the thread-pool shuts down during execution of the provided block.
Methods included from Request
#default_server_port, #handle_request, #prepare_response
Constructor Details
#initialize(app, events = nil, options = {}) ⇒ Server
Several instance variables exist so they are available for testing, and have default values set via fetch
. Normally the values are set via ‘::Puma::Configuration.puma_default_options`.
The ‘events` parameter is set to nil, and set to `Events.new` in code. Often `options` needs to be passed, but `events` does not. Using nil allows calling code to not require events.rb.
Create a server for the rack app app
.
log_writer
is a Puma::LogWriter object used to log info and error messages.
events
is a Puma::Events object used to notify application status events.
Server#run returns a thread that you can join on to wait for the server to do its work.
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 |
# File 'lib/puma/server.rb', line 69 def initialize(app, events = nil, = {}) @app = app @events = events || Events.new @check, @notify = nil @status = :stop @thread = nil @thread_pool = nil @options = if .is_a?(UserFileDefaultOptions) else UserFileDefaultOptions.new(, Configuration::DEFAULTS) end @log_writer = @options.fetch :log_writer, LogWriter.stdio @early_hints = @options[:early_hints] @first_data_timeout = @options[:first_data_timeout] @persistent_timeout = @options[:persistent_timeout] @idle_timeout = @options[:idle_timeout] @min_threads = @options[:min_threads] @max_threads = @options[:max_threads] @queue_requests = @options[:queue_requests] @max_fast_inline = @options[:max_fast_inline] @io_selector_backend = @options[:io_selector_backend] @http_content_length_limit = @options[:http_content_length_limit] # make this a hash, since we prefer `key?` over `include?` @supported_http_methods = if @options[:supported_http_methods] == :any :any else if (ary = @options[:supported_http_methods]) ary else SUPPORTED_HTTP_METHODS end.sort.product([nil]).to_h.freeze end temp = !!(@options[:environment] =~ /\A(development|test)\z/) @leak_stack_on_error = @options[:environment] ? temp : true @binder = Binder.new(log_writer) ENV['RACK_ENV'] ||= "development" @mode = :http @precheck_closing = true @requests_count = 0 @idle_timeout_reached = false end |
Class Attribute Details
.current ⇒ Object (readonly)
131 132 133 |
# File 'lib/puma/server.rb', line 131 def current Thread.current[THREAD_LOCAL_KEY] end |
Instance Attribute Details
#app ⇒ Object
Returns the value of attribute app.
47 48 49 |
# File 'lib/puma/server.rb', line 47 def app @app end |
#auto_trim_time ⇒ Object (readonly)
the following may be deprecated in the future
43 44 45 |
# File 'lib/puma/server.rb', line 43 def auto_trim_time @auto_trim_time end |
#backlog ⇒ Object (readonly)
209 210 211 |
# File 'lib/puma/server.rb', line 209 def backlog @thread_pool&.backlog end |
#binder ⇒ Object
Returns the value of attribute binder.
48 49 50 |
# File 'lib/puma/server.rb', line 48 def binder @binder end |
#connected_ports ⇒ Object (readonly)
660 661 662 |
# File 'lib/puma/server.rb', line 660 def connected_ports @binder.connected_ports end |
#early_hints ⇒ Object (readonly)
the following may be deprecated in the future
43 44 45 |
# File 'lib/puma/server.rb', line 43 def early_hints @early_hints end |
#events ⇒ Object (readonly)
Returns the value of attribute events.
37 38 39 |
# File 'lib/puma/server.rb', line 37 def events @events end |
#first_data_timeout ⇒ Object (readonly)
the following may be deprecated in the future
43 44 45 |
# File 'lib/puma/server.rb', line 43 def first_data_timeout @first_data_timeout end |
#idle_timeout_reached ⇒ Object (readonly)
Returns the value of attribute idle_timeout_reached.
40 41 42 |
# File 'lib/puma/server.rb', line 40 def idle_timeout_reached @idle_timeout_reached end |
#leak_stack_on_error ⇒ Object (readonly)
the following may be deprecated in the future
43 44 45 |
# File 'lib/puma/server.rb', line 43 def leak_stack_on_error @leak_stack_on_error end |
#log_writer ⇒ Object (readonly)
Returns the value of attribute log_writer.
36 37 38 |
# File 'lib/puma/server.rb', line 36 def log_writer @log_writer end |
#max_threads ⇒ Object (readonly)
for #stats
38 39 40 |
# File 'lib/puma/server.rb', line 38 def max_threads @max_threads end |
#min_threads ⇒ Object (readonly)
for #stats
38 39 40 |
# File 'lib/puma/server.rb', line 38 def min_threads @min_threads end |
#persistent_timeout ⇒ Object (readonly)
the following may be deprecated in the future
43 44 45 |
# File 'lib/puma/server.rb', line 43 def persistent_timeout @persistent_timeout end |
#pool_capacity ⇒ Object (readonly)
This number represents the number of requests that the server is capable of taking right now.
For example if the number is 5 then it means there are 5 threads sitting idle ready to take a request. If one request comes in, then the value would be 4 until it finishes processing.
227 228 229 |
# File 'lib/puma/server.rb', line 227 def pool_capacity @thread_pool&.pool_capacity end |
#reaping_time ⇒ Object (readonly)
the following may be deprecated in the future
43 44 45 |
# File 'lib/puma/server.rb', line 43 def reaping_time @reaping_time end |
#requests_count ⇒ Object (readonly)
39 40 41 |
# File 'lib/puma/server.rb', line 39 def requests_count @requests_count end |
#running ⇒ Object (readonly)
214 215 216 |
# File 'lib/puma/server.rb', line 214 def running @thread_pool&.spawned end |
#stats ⇒ Object (readonly)
Returns a hash of stats about the running server for reporting purposes.
638 639 640 |
# File 'lib/puma/server.rb', line 638 def stats STAT_METHODS.map {|name| [name, send(name) || 0]}.to_h end |
#thread ⇒ Object (readonly)
Returns the value of attribute thread.
35 36 37 |
# File 'lib/puma/server.rb', line 35 def thread @thread end |
Class Method Details
.closed_socket_supported? ⇒ Boolean
:nodoc:
143 144 145 |
# File 'lib/puma/server.rb', line 143 def closed_socket_supported? Socket.const_defined?(:TCP_INFO) && Socket.const_defined?(:IPPROTO_TCP) end |
.tcp_cork_supported? ⇒ Boolean
:nodoc:
137 138 139 |
# File 'lib/puma/server.rb', line 137 def tcp_cork_supported? Socket.const_defined?(:TCP_CORK) && Socket.const_defined?(:IPPROTO_TCP) end |
Instance Method Details
#add_ssl_listener(host, port, ctx, optimize_for_latency = true, backlog = 1024) ⇒ Object
650 651 652 653 |
# File 'lib/puma/server.rb', line 650 def add_ssl_listener(host, port, ctx, optimize_for_latency = true, backlog = 1024) @binder.add_ssl_listener host, port, ctx, optimize_for_latency, backlog end |
#add_tcp_listener(host, port, optimize_for_latency = true, backlog = 1024) ⇒ Object
646 647 648 |
# File 'lib/puma/server.rb', line 646 def add_tcp_listener(host, port, optimize_for_latency = true, backlog = 1024) @binder.add_tcp_listener host, port, optimize_for_latency, backlog end |
#add_unix_listener(path, umask = nil, mode = nil, backlog = 1024) ⇒ Object
655 656 657 |
# File 'lib/puma/server.rb', line 655 def add_unix_listener(path, umask = nil, mode = nil, backlog = 1024) @binder.add_unix_listener path, umask, mode, backlog end |
#begin_restart(sync = false) ⇒ Object
622 623 624 625 |
# File 'lib/puma/server.rb', line 622 def begin_restart(sync=false) notify_safely(RESTART_COMMAND) @thread.join if @thread && sync end |
#client_error(e, client, requests = 1) ⇒ Object
Handle various error types thrown by Client I/O operations.
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 |
# File 'lib/puma/server.rb', line 515 def client_error(e, client, requests = 1) # Swallow, do not log return if [ConnectionError, EOFError].include?(e.class) case e when MiniSSL::SSLError lowlevel_error(e, client.env) @log_writer.ssl_error e, client.io when HttpParserError response_to_error(client, requests, e, 400) @log_writer.parse_error e, client when HttpParserError501 response_to_error(client, requests, e, 501) @log_writer.parse_error e, client else response_to_error(client, requests, e, 500) @log_writer.unknown_error e, nil, "Read" end end |
#closed_socket?(socket) ⇒ Boolean
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 |
# File 'lib/puma/server.rb', line 186 def closed_socket?(socket) skt = socket.to_io return false unless skt.kind_of?(TCPSocket) && @precheck_closing begin tcp_info = skt.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_INFO) rescue IOError, SystemCallError Puma::Util.purge_interrupt_queue @precheck_closing = false false else state = tcp_info.unpack(UNPACK_TCP_STATE_FROM_TCP_INFO)[0] # TIME_WAIT: 6, CLOSE: 7, CLOSE_WAIT: 8, LAST_ACK: 9, CLOSING: 11 (state >= 6 && state <= 9) || state == 11 end end |
#cork_socket(socket) ⇒ Object
6 == Socket::IPPROTO_TCP 3 == TCP_CORK 1/0 == turn on/off
158 159 160 161 162 163 164 165 |
# File 'lib/puma/server.rb', line 158 def cork_socket(socket) skt = socket.to_io begin skt.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_CORK, 1) if skt.kind_of? TCPSocket rescue IOError, SystemCallError Puma::Util.purge_interrupt_queue end end |
#graceful_shutdown ⇒ Object
Wait for all outstanding requests to finish.
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 |
# File 'lib/puma/server.rb', line 565 def graceful_shutdown if @options[:shutdown_debug] threads = Thread.list total = threads.size pid = Process.pid $stdout.syswrite "#{pid}: === Begin thread backtrace dump ===\n" threads.each_with_index do |t,i| $stdout.syswrite "#{pid}: Thread #{i+1}/#{total}: #{t.inspect}\n" $stdout.syswrite "#{pid}: #{t.backtrace.join("\n#{pid}: ")}\n\n" end $stdout.syswrite "#{pid}: === End thread backtrace dump ===\n" end if @status != :restart @binder.close end if @thread_pool if timeout = @options[:force_shutdown_after] @thread_pool.shutdown timeout.to_f else @thread_pool.shutdown end end end |
#halt(sync = false) ⇒ Object
617 618 619 620 |
# File 'lib/puma/server.rb', line 617 def halt(sync=false) notify_safely(HALT_COMMAND) @thread.join if @thread && sync end |
#handle_check ⇒ Object
:nodoc:
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 |
# File 'lib/puma/server.rb', line 397 def handle_check cmd = @check.read(1) case cmd when STOP_COMMAND @status = :stop return true when HALT_COMMAND @status = :halt return true when RESTART_COMMAND @status = :restart return true end false end |
#handle_servers ⇒ Object
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 |
# File 'lib/puma/server.rb', line 311 def handle_servers begin check = @check sockets = [check] + @binder.ios pool = @thread_pool queue_requests = @queue_requests drain = @options[:drain_on_shutdown] ? 0 : nil addr_send_name, addr_value = case @options[:remote_address] when :value [:peerip=, @options[:remote_address_value]] when :header [:remote_addr_header=, @options[:remote_address_header]] when :proxy_protocol [:expect_proxy_proto=, @options[:remote_address_proxy_protocol]] else [nil, nil] end while @status == :run || (drain && shutting_down?) begin ios = IO.select sockets, nil, nil, (shutting_down? ? 0 : @idle_timeout) unless ios unless shutting_down? @idle_timeout_reached = true @status = :stop end break end ios.first.each do |sock| if sock == check break if handle_check else pool.wait_until_not_full pool.wait_for_less_busy_worker(@options[:wait_for_less_busy_worker]) io = begin sock.accept_nonblock rescue IO::WaitReadable next end drain += 1 if shutting_down? pool << Client.new(io, @binder.env(sock)).tap { |c| c.listener = sock c.http_content_length_limit = @http_content_length_limit c.send(addr_send_name, addr_value) if addr_value } end end rescue IOError, Errno::EBADF # In the case that any of the sockets are unexpectedly close. raise rescue StandardError => e @log_writer.unknown_error e, nil, "Listen loop" end end @log_writer.debug "Drained #{drain} additional connections." if drain @events.fire :state, @status if queue_requests @queue_requests = false @reactor.shutdown end graceful_shutdown if @status == :stop || @status == :restart rescue Exception => e @log_writer.unknown_error e, nil, "Exception handling servers" ensure # Errno::EBADF is infrequently raised [@check, @notify].each do |io| begin io.close unless io.closed? rescue Errno::EBADF end end @notify = nil @check = nil end @events.fire :state, :done end |
#inherit_binder(bind) ⇒ Object
125 126 127 |
# File 'lib/puma/server.rb', line 125 def inherit_binder(bind) @binder = bind end |
#lowlevel_error(e, env, status = 500) ⇒ Object
A fallback rack response if @app raises as exception.
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 |
# File 'lib/puma/server.rb', line 537 def lowlevel_error(e, env, status=500) if handler = @options[:lowlevel_error_handler] if handler.arity == 1 return handler.call(e) elsif handler.arity == 2 return handler.call(e, env) else return handler.call(e, env, status) end end if @leak_stack_on_error backtrace = e.backtrace.nil? ? '<no backtrace available>' : e.backtrace.join("\n") [status, {}, ["Puma caught this error: #{e.} (#{e.class})\n#{backtrace}"]] else [status, {}, [""]] end end |
#process_client(client) ⇒ Object
Given a connection on client
, handle the incoming requests, or queue the connection in the Reactor if no request is available.
This method is called from a ThreadPool worker thread.
This method supports HTTP Keep-Alive so it may, depending on if the client indicates that it supports keep alive, wait for another request before returning.
Return true if one or more requests were processed.
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 |
# File 'lib/puma/server.rb', line 425 def process_client(client) # Advertise this server into the thread Thread.current[THREAD_LOCAL_KEY] = self clean_thread_locals = @options[:clean_thread_locals] close_socket = true requests = 0 begin if @queue_requests && !client.eagerly_finish client.set_timeout(@first_data_timeout) if @reactor.add client close_socket = false return false end end with_force_shutdown(client) do client.finish(@first_data_timeout) end while true @requests_count += 1 case handle_request(client, requests + 1) when false break when :async close_socket = false break when true ThreadPool.clean_thread_locals if clean_thread_locals requests += 1 # As an optimization, try to read the next request from the # socket for a short time before returning to the reactor. fast_check = @status == :run # Always pass the client back to the reactor after a reasonable # number of inline requests if there are other requests pending. fast_check = false if requests >= @max_fast_inline && @thread_pool.backlog > 0 next_request_ready = with_force_shutdown(client) do client.reset(fast_check) end unless next_request_ready break unless @queue_requests client.set_timeout @persistent_timeout if @reactor.add client close_socket = false break end end end end true rescue StandardError => e client_error(e, client, requests) # The ensure tries to close +client+ down requests > 0 ensure client.io_buffer.reset begin client.close if close_socket rescue IOError, SystemCallError Puma::Util.purge_interrupt_queue # Already closed rescue StandardError => e @log_writer.unknown_error e, nil, "Client" end end end |
#reactor_wakeup(client) ⇒ Object
This method is called from the Reactor thread when a queued Client receives data, times out, or when the Reactor is shutting down.
It is responsible for ensuring that a request has been completely received before it starts to be processed by the ThreadPool. This may be known as read buffering. If read buffering is not done, and no other read buffering is performed (such as by an application server such as nginx) then the application would be subject to a slow client attack.
For a graphical representation of how the request buffer works see [architecture.md](github.com/puma/puma/blob/master/docs/architecture.md#connection-pipeline).
The method checks to see if it has the full header and body with the ‘Puma::Client#try_to_finish` method. If the full request has been sent, then the request is passed to the ThreadPool (`@thread_pool << client`) so that a “worker thread” can pick up the request and begin to execute application logic. The Client is then removed from the reactor (return `true`).
If a client object times out, a 408 response is written, its connection is closed, and the object is removed from the reactor (return ‘true`).
If the Reactor is shutting down, all Clients are either timed out or passed to the ThreadPool, depending on their current state (#can_close?).
Otherwise, if the full request is not ready then the client will remain in the reactor (return ‘false`). When the client sends more data to the socket the `Puma::Client` object will wake up and again be checked to see if it’s ready to be passed to the thread pool.
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 |
# File 'lib/puma/server.rb', line 295 def reactor_wakeup(client) shutdown = !@queue_requests if client.try_to_finish || (shutdown && !client.can_close?) @thread_pool << client elsif shutdown || client.timeout == 0 client.timeout! else client.set_timeout(@first_data_timeout) false end rescue StandardError => e client_error(e, client) client.close true end |
#run(background = true, thread_name: 'srv') ⇒ Object
Runs the server.
If background
is true (the default) then a thread is spun up in the background to handle requests. Otherwise requests are handled synchronously.
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 |
# File 'lib/puma/server.rb', line 237 def run(background=true, thread_name: 'srv') BasicSocket.do_not_reverse_lookup = true @events.fire :state, :booting @status = :run @thread_pool = ThreadPool.new(thread_name, @options) { |client| process_client client } if @queue_requests @reactor = Reactor.new(@io_selector_backend) { |c| reactor_wakeup c } @reactor.run end @thread_pool.auto_reap! if @options[:reaping_time] @thread_pool.auto_trim! if @options[:auto_trim_time] @check, @notify = Puma::Util.pipe unless @notify @events.fire :state, :running if background @thread = Thread.new do Puma.set_thread_name thread_name handle_servers end return @thread else handle_servers end end |
#shutting_down? ⇒ Boolean
627 628 629 |
# File 'lib/puma/server.rb', line 627 def shutting_down? @status == :stop || @status == :restart end |
#stop(sync = false) ⇒ Object
Stops the acceptor thread and then causes the worker threads to finish off the request queue before finally exiting.
612 613 614 615 |
# File 'lib/puma/server.rb', line 612 def stop(sync=false) notify_safely(STOP_COMMAND) @thread.join if @thread && sync end |
#uncork_socket(socket) ⇒ Object
167 168 169 170 171 172 173 174 |
# File 'lib/puma/server.rb', line 167 def uncork_socket(socket) skt = socket.to_io begin skt.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_CORK, 0) if skt.kind_of? TCPSocket rescue IOError, SystemCallError Puma::Util.purge_interrupt_queue end end |
#with_force_shutdown(client, &block) ⇒ Object
Triggers a client timeout if the thread-pool shuts down during execution of the provided block.
506 507 508 509 510 |
# File 'lib/puma/server.rb', line 506 def with_force_shutdown(client, &block) @thread_pool.with_force_shutdown(&block) rescue ThreadPool::ForceShutdown client.timeout! end |