puma 2.11.1 → 2.11.2

data/lib/puma/const.rb

@@ -28,7 +28,7 @@ module Puma
   # too taxing on performance.
   module Const
 
-    PUMA_VERSION = VERSION = "2.11.1".freeze
+    PUMA_VERSION = VERSION = "2.11.2".freeze
     CODE_NAME = "Intrepid Squirrel".freeze
 
     FAST_TRACK_KA_TIMEOUT = 0.2

data/lib/puma/dsl.rb

@@ -0,0 +1,280 @@
+module Puma
+  # The methods that are available for use inside the config file.
+  #
+  class DSL
+    include ConfigDefault
+
+    def self.load(options, path)
+      new(options).tap do |obj|
+        obj._load_from(path)
+      end
+
+      options
+    end
+
+    def initialize(options)
+      @options = options
+    end
+
+    def _load_from(path)
+      instance_eval(File.read(path), path, 1) if path
+    end
+
+    # Use +obj+ or +block+ as the Rack app. This allows a config file to
+    # be the app itself.
+    #
+    def app(obj=nil, &block)
+      obj ||= block
+
+      raise "Provide either a #call'able or a block" unless obj
+
+      @options[:app] = obj
+    end
+
+    # Start the Puma control rack app on +url+. This app can be communicated
+    # with to control the main server.
+    #
+    def activate_control_app(url="auto", opts=nil)
+      @options[:control_url] = url
+
+      if opts
+        auth_token = opts[:auth_token]
+        @options[:control_auth_token] = auth_token if auth_token
+
+        @options[:control_auth_token] = :none if opts[:no_token]
+      end
+    end
+
+    # Bind the server to +url+. tcp:// and unix:// are the only accepted
+    # protocols.
+    #
+    def bind(url)
+      @options[:binds] << url
+    end
+
+    # Define the TCP port to bind to. Use +bind+ for more advanced options.
+    #
+    def port(port)
+      @options[:binds] << "tcp://#{Configuration::DefaultTCPHost}:#{port}"
+    end
+
+    # Work around leaky apps that leave garbage in Thread locals
+    # across requests
+    #
+    def clean_thread_locals(which=true)
+      @options[:clean_thread_locals] = which
+    end
+
+    # Daemonize the server into the background. Highly suggest that
+    # this be combined with +pidfile+ and +stdout_redirect+.
+    def daemonize(which=true)
+      @options[:daemon] = which
+    end
+
+    # When shutting down, drain the accept socket of pending
+    # connections and proces them. This loops over the accept
+    # socket until there are no more read events and then stops
+    # looking and waits for the requests to finish.
+    def drain_on_shutdown(which=true)
+      @options[:drain_on_shutdown] = which
+    end
+
+    # Set the environment in which the Rack's app will run.
+    def environment(environment)
+      @options[:environment] = environment
+    end
+
+    # Code to run before doing a restart. This code should
+    # close logfiles, database connections, etc.
+    #
+    # This can be called multiple times to add code each time.
+    #
+    def on_restart(&block)
+      @options[:on_restart] << block
+    end
+
+    # Command to use to restart puma. This should be just how to
+    # load puma itself (ie. 'ruby -Ilib bin/puma'), not the arguments
+    # to puma, as those are the same as the original process.
+    #
+    def restart_command(cmd)
+      @options[:restart_cmd] = cmd
+    end
+
+    # Store the pid of the server in the file at +path+.
+    def pidfile(path)
+      @options[:pidfile] = path
+    end
+
+    # Disable request logging.
+    #
+    def quiet
+      @options[:quiet] = true
+    end
+
+    # Load +path+ as a rackup file.
+    #
+    def rackup(path)
+      @options[:rackup] = path.to_s
+    end
+
+    # Redirect STDOUT and STDERR to files specified.
+    def stdout_redirect(stdout=nil, stderr=nil, append=false)
+      @options[:redirect_stdout] = stdout
+      @options[:redirect_stderr] = stderr
+      @options[:redirect_append] = append
+    end
+
+    # Configure +min+ to be the minimum number of threads to use to answer
+    # requests and +max+ the maximum.
+    #
+    def threads(min, max)
+      min = Integer(min)
+      max = Integer(max)
+      if min > max
+        raise "The minimum (#{min}) number of threads must be less than the max (#{max})"
+      end
+
+      @options[:min_threads] = min
+      @options[:max_threads] = max
+    end
+
+    def ssl_bind(host, port, opts)
+      @options[:binds] << "ssl://#{host}:#{port}?cert=#{opts[:cert]}&key=#{opts[:key]}"
+    end
+
+    # Use +path+ as the file to store the server info state. This is
+    # used by pumactl to query and control the server.
+    #
+    def state_path(path)
+      @options[:state] = path.to_s
+    end
+
+    # *Cluster mode only* How many worker processes to run.
+    #
+    def workers(count)
+      @options[:workers] = count.to_i
+    end
+
+    # *Cluster mode only* Code to run immediately before a worker shuts
+    # down (after it has finished processing HTTP requests). These hooks
+    # can block if necessary to wait for background operations unknown
+    # to puma to finish before the process terminates.
+    #
+    # This can be called multiple times to add hooks.
+    #
+    def on_worker_shutdown(&block)
+      @options[:before_worker_shutdown] << block
+    end
+
+    # *Cluster mode only* Code to run when a worker boots to setup
+    # the process before booting the app.
+    #
+    # This can be called multiple times to add hooks.
+    #
+    def on_worker_boot(&block)
+      @options[:before_worker_boot] << block
+    end
+
+    # *Cluster mode only* Code to run when a master process is
+    # about to create the worker by forking itself.
+    #
+    # This can be called multiple times to add hooks.
+    #
+    def on_worker_fork(&block)
+      @options[:before_worker_fork] << block
+    end
+
+    # *Cluster mode only* Code to run when a worker boots to setup
+    # the process after booting the app.
+    #
+    # This can be called multiple times to add hooks.
+    #
+    def after_worker_boot(&block)
+      @options[:after_worker_boot] << block
+    end
+
+    # The directory to operate out of.
+    def directory(dir)
+      @options[:directory] = dir.to_s
+      @options[:worker_directory] = dir.to_s
+    end
+
+    # Run the app as a raw TCP app instead of an HTTP rack app
+    def tcp_mode
+      @options[:mode] = :tcp
+    end
+
+    # *Cluster mode only* Preload the application before starting
+    # the workers and setting up the listen ports. This conflicts
+    # with using the phased restart feature, you can't use both.
+    #
+    def preload_app!(answer=true)
+      @options[:preload_app] = answer
+    end
+
+    # Use +obj+ or +block+ as the low level error handler. This allows a config file to
+    # change the default error on the server.
+    #
+    def lowlevel_error_handler(obj=nil, &block)
+      obj ||= block
+      raise "Provide either a #call'able or a block" unless obj
+      @options[:lowlevel_error_handler] = obj
+    end
+
+    # This option is used to allow your app and its gems to be
+    # properly reloaded when not using preload.
+    #
+    # When set, if puma detects that it's been invoked in the
+    # context of Bundler, it will cleanup the environment and
+    # re-run itself outside the Bundler environment, but directly
+    # using the files that Bundler has setup.
+    #
+    # This means that puma is now decoupled from your Bundler
+    # context and when each worker loads, it will be loading a
+    # new Bundler context and thus can float around as the release
+    # dictates.
+    def prune_bundler(answer=true)
+      @options[:prune_bundler] = answer
+    end
+
+    # Additional text to display in process listing
+    def tag(string)
+      @options[:tag] = string
+    end
+
+    # *Cluster mode only* Set the timeout for workers
+    def worker_timeout(timeout)
+      @options[:worker_timeout] = timeout
+    end
+
+    # *Cluster mode only* Set the timeout for worker shutdown
+    def worker_shutdown_timeout(timeout)
+      @options[:worker_shutdown_timeout] = timeout
+    end
+
+    # When set to true (the default), workers accept all requests
+    # and queue them before passing them to the handlers.
+    # When set to false, each worker process accepts exactly as
+    # many requests as it is configured to simultaneously handle.
+    #
+    # Queueing requests generally improves performance. In some
+    # cases, such as a single threaded application, it may be
+    # better to ensure requests get balanced across workers.
+    #
+    # Note that setting this to false disables HTTP keepalive and
+    # slow clients will occupy a handler thread while the request
+    # is being sent. A reverse proxy, such as nginx, can handle
+    # slow clients and queue requests before they reach puma.
+    def queue_requests(answer=true)
+      @options[:queue_requests] = answer
+    end
+
+    # When a shutdown is requested, the backtraces of all the
+    # threads will be written to $stdout. This can help figure
+    # out why shutdown is hanging.
+    def shutdown_debug(val=true)
+      @options[:shutdown_debug] = val
+    end
+  end
+end

data/lib/puma/server.rb

@@ -535,7 +535,7 @@ module Puma
         line_ending = LINE_END
         colon = COLON
 
-        if env[HTTP_VERSION] == HTTP_11
+        http_11 = if env[HTTP_VERSION] == HTTP_11
           allow_chunked = true
           keep_alive = env[HTTP_CONNECTION] != CLOSE
           include_keepalive_header = false
@@ -552,6 +552,7 @@ module Puma
 
             no_body ||= status < 200 || STATUS_WITH_NO_ENTITY_BODY[status]
           end
+          true
         else
           allow_chunked = false
           keep_alive = env[HTTP_CONNECTION] == KEEP_ALIVE
@@ -567,6 +568,7 @@ module Puma
 
             no_body ||= status < 200 || STATUS_WITH_NO_ENTITY_BODY[status]
           end
+          false
         end
 
         response_hijack = nil
@@ -593,6 +595,12 @@ module Puma
           end
         end
 
+        if include_keepalive_header
+          lines << CONNECTION_KEEP_ALIVE
+        elsif http_11 && !keep_alive
+          lines << CONNECTION_CLOSE
+        end
+
         if no_body
           if content_length and status != 204
             lines.append CONTENT_LENGTH_S, content_length.to_s, line_ending
@@ -603,12 +611,6 @@ module Puma
           return keep_alive
         end
 
-        if include_keepalive_header
-          lines << CONNECTION_KEEP_ALIVE
-        elsif !keep_alive
-          lines << CONNECTION_CLOSE
-        end
-
         unless response_hijack
           if content_length
             lines.append CONTENT_LENGTH_S, content_length.to_s, line_ending
@@ -738,6 +740,21 @@ module Puma
     # Wait for all outstanding requests to finish.
     #
     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 @options[:drain_on_shutdown]
         count = 0
 

data/puma.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan Phoenix"]
   s.date = `git log --pretty="%ai" -n 1`.split(" ").first
-  s.description = "Puma is a simple, fast, threaded, and highly concurrent HTTP 1.1 server for Ruby/Rack applications. Puma is intended for use in both development and production environments. In order to get the best throughput, it is highly recommended that you use a  Ruby implementation with real threads like Rubinius or JRuby."
+  s.description = "Puma is a simple, fast, threaded, and highly concurrent HTTP 1.1 server for Ruby/Rack applications. Puma is intended for use in both development and production environments. In order to get the best throughput, it is highly recommended that you use a Ruby implementation with real threads like Rubinius or JRuby."
   s.email = ["evan@phx.io"]
   s.executables = ["puma", "pumactl"]
   s.extensions = ["ext/puma_http11/extconf.rb"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puma
 version: !ruby/object:Gem::Version
-  version: 2.11.1
+  version: 2.11.2
 platform: ruby
 authors:
 - Evan Phoenix
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -138,6 +138,7 @@ files:
 - lib/puma/daemon_ext.rb
 - lib/puma/delegation.rb
 - lib/puma/detect.rb
+- lib/puma/dsl.rb
 - lib/puma/events.rb
 - lib/puma/io_buffer.rb
 - lib/puma/java_io_buffer.rb
@@ -155,24 +156,6 @@ files:
 - lib/puma/util.rb
 - lib/rack/handler/puma.rb
 - puma.gemspec
-- test/test_app_status.rb
-- test/test_cli.rb
-- test/test_config.rb
-- test/test_http10.rb
-- test/test_http11.rb
-- test/test_integration.rb
-- test/test_iobuffer.rb
-- test/test_minissl.rb
-- test/test_null_io.rb
-- test/test_persistent.rb
-- test/test_puma_server.rb
-- test/test_puma_server_ssl.rb
-- test/test_rack_handler.rb
-- test/test_rack_server.rb
-- test/test_tcp_rack.rb
-- test/test_thread_pool.rb
-- test/test_unix_socket.rb
-- test/test_ws.rb
 - tools/jungle/README.md
 - tools/jungle/init.d/README.md
 - tools/jungle/init.d/puma
@@ -208,22 +191,4 @@ signing_key:
 specification_version: 4
 summary: Puma is a simple, fast, threaded, and highly concurrent HTTP 1.1 server for
   Ruby/Rack applications
-test_files:
-- test/test_app_status.rb
-- test/test_cli.rb
-- test/test_config.rb
-- test/test_http10.rb
-- test/test_http11.rb
-- test/test_integration.rb
-- test/test_iobuffer.rb
-- test/test_minissl.rb
-- test/test_null_io.rb
-- test/test_persistent.rb
-- test/test_puma_server.rb
-- test/test_puma_server_ssl.rb
-- test/test_rack_handler.rb
-- test/test_rack_server.rb
-- test/test_tcp_rack.rb
-- test/test_thread_pool.rb
-- test/test_unix_socket.rb
-- test/test_ws.rb
+test_files: []

data/test/test_app_status.rb

@@ -1,92 +0,0 @@
-require 'test/unit'
-require 'rack'
-require 'puma/app/status'
-
-class TestAppStatus < Test::Unit::TestCase
-  class FakeServer
-    def initialize
-      @status = :running
-      @backlog = 0
-      @running = 0
-    end
-
-    attr_reader :status
-    attr_accessor :backlog, :running
-
-    def stop
-      @status = :stop
-    end
-
-    def halt
-      @status = :halt
-    end
-
-    def stats
-      "{}"
-    end
-  end
-
-  def setup
-    @server = FakeServer.new
-    @app = Puma::App::Status.new(@server)
-    @app.auth_token = nil
-  end
-
-  def lint(uri)
-    app = Rack::Lint.new @app
-    mock_env = Rack::MockRequest.env_for uri
-    app.call mock_env
-  end
-
-  def test_bad_token
-    @app.auth_token = "abcdef"
-
-    status, _, _ = lint('/whatever')
-
-    assert_equal 403, status
-  end
-
-  def test_good_token
-    @app.auth_token = "abcdef"
-
-    status, _, _ = lint('/whatever?token=abcdef')
-
-    assert_equal 404, status
-  end
-
-  def test_unsupported
-    status, _, _ = lint('/not-real')
-
-    assert_equal 404, status
-  end
-
-  def test_stop
-    status, _ , app = lint('/stop')
-
-    assert_equal :stop, @server.status
-    assert_equal 200, status
-    assert_equal ['{ "status": "ok" }'], app.enum_for.to_a
-  end
-
-  def test_halt
-    status, _ , app = lint('/halt')
-
-    assert_equal :halt, @server.status
-    assert_equal 200, status
-    assert_equal ['{ "status": "ok" }'], app.enum_for.to_a
-  end
-
-  def test_stats
-    @server.backlog = 1
-    @server.running = 9
-    status, _ , app = lint('/stats')
-
-    assert_equal 200, status
-    assert_equal ['{}'], app.enum_for.to_a
-  end
-
-  def test_alternate_location
-    status, _ , _ = lint('__alternatE_location_/stats')
-    assert_equal 200, status
-  end
-end