puma 2.16.0 → 3.11.4

data/lib/puma/dsl.rb

@@ -1,23 +1,72 @@
 module Puma
   # The methods that are available for use inside the config file.
+  # These same methods are used in Puma cli and the rack handler
+  # internally.
   #
+  # Used manually (via CLI class):
+  #
+  #   config = Configuration.new({}) do |user_config|
+  #     user_config.port 3001
+  #   end
+  #   config.load
+  #
+  #   puts config.options[:binds]
+  #   "tcp://127.0.0.1:3001"
+  #
+  # Used to load file:
+  #
+  #   $ cat puma_config.rb
+  #     port 3002
+  #
+  #   config = Configuration.new(config_file: "puma_config.rb")
+  #   config.load
+  #
+  #   puts config.options[:binds]
+  #   # => "tcp://127.0.0.1:3002"
+  #
+  # Detailed docs can be found in `examples/config.rb`
   class DSL
     include ConfigDefault
 
-    def self.load(options, path)
-      new(options).tap do |obj|
-        obj._load_from(path)
+    def initialize(options, config)
+      @config  = config
+      @options = options
+
+      @plugins = []
+    end
+
+    def _load_from(path)
+      if path
+        @path = path
+        instance_eval(File.read(path), path, 1)
+      end
+    ensure
+      _offer_plugins
+    end
+
+    def _offer_plugins
+      @plugins.each do |o|
+        if o.respond_to? :config
+          @options.shift
+          o.config self
+        end
       end
 
-      options
+      @plugins.clear
     end
 
-    def initialize(options)
-      @options = options
+    def inject(&blk)
+      instance_eval(&blk)
     end
 
-    def _load_from(path)
-      instance_eval(File.read(path), path, 1) if path
+    def get(key,default=nil)
+      @options[key.to_sym] || default
+    end
+
+    # Load the named plugin for use by this configuration
+    #
+    def plugin(name)
+      @plugins << @config.load_plugin(name)
     end
 
     # Use +obj+ or +block+ as the Rack app. This allows a config file to
@@ -34,29 +83,76 @@ module Puma
     # 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
+    def activate_control_app(url="auto", opts={})
+      if url == "auto"
+        path = Configuration.temp_path
+        @options[:control_url] = "unix://#{path}"
+        @options[:control_url_temp] = path
+      else
+        @options[:control_url] = url
+      end
 
-      if opts
+      if opts[:no_token]
+        auth_token = :none
+      else
         auth_token = opts[:auth_token]
-        @options[:control_auth_token] = auth_token if auth_token
-
-        @options[:control_auth_token] = :none if opts[:no_token]
-        @options[:control_url_umask] = opts[:umask] if opts[:umask]
+        auth_token ||= Configuration.random_token
       end
+
+      @options[:control_auth_token] = auth_token
+      @options[:control_url_umask] = opts[:umask] if opts[:umask]
+    end
+
+    # Load additional configuration from a file
+    # Files get loaded later via Configuration#load
+    def load(file)
+      @options[:config_files] ||= []
+      @options[:config_files] << file
     end
 
-    # Bind the server to +url+. tcp:// and unix:// are the only accepted
-    # protocols.
+    # Adds a binding for the server to +url+. tcp://, unix://, and ssl:// are the only accepted
+    # protocols. Use query parameters within the url to specify options.
+    #
+    # @note multiple urls can be bound to, calling `bind` does not overwrite previous bindings.
+    #
+    # @example Explicitly the socket backlog depth (default is 1024)
+    #   bind('unix:///var/run/puma.sock?backlog=2048')
     #
+    # @example Set up ssl cert
+    #   bind('ssl://127.0.0.1:9292?key=key.key&cert=cert.pem')
+    #
+    # @example Prefer low-latency over higher throughput (via `Socket::TCP_NODELAY`)
+    #   bind('tcp://0.0.0.0:9292?low_latency=true')
+    #
+    # @example Set socket permissions
+    #   bind('unix:///var/run/puma.sock?umask=0111')
     def bind(url)
+      @options[:binds] ||= []
       @options[:binds] << url
     end
 
+    def clear_binds!
+      @options[:binds] = []
+    end
+
     # Define the TCP port to bind to. Use +bind+ for more advanced options.
     #
-    def port(port)
-      @options[:binds] << "tcp://#{Configuration::DefaultTCPHost}:#{port}"
+    def port(port, host=nil)
+      host ||= Configuration::DefaultTCPHost
+      bind "tcp://#{host}:#{port}"
+    end
+
+    # Define how long persistent connections can be idle before puma closes
+    # them
+    #
+    def persistent_timeout(seconds)
+      @options[:persistent_timeout] = Integer(seconds)
+    end
+
+    # Define how long the tcp socket stays open, if no data has been received
+    #
+    def first_data_timeout(seconds)
+      @options[:first_data_timeout] = Integer(seconds)
     end
 
     # Work around leaky apps that leave garbage in Thread locals
@@ -73,7 +169,7 @@ module Puma
     end
 
     # When shutting down, drain the accept socket of pending
-    # connections and proces them. This loops over the accept
+    # connections and process 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)
@@ -85,12 +181,33 @@ module Puma
       @options[:environment] = environment
     end
 
+    # How long to wait for threads to stop when shutting them
+    # down. Defaults to :forever. Specifying :immediately will cause
+    # Puma to kill the threads immediately.  Otherwise the value
+    # is the number of seconds to wait.
+    #
+    # Puma always waits a few seconds after killing a thread for it to try
+    # to finish up it's work, even in :immediately mode.
+    def force_shutdown_after(val=:forever)
+      i = case val
+          when :forever
+            -1
+          when :immediately
+            0
+          else
+            Integer(val)
+          end
+
+      @options[:force_shutdown_after] = i
+    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] ||= []
       @options[:on_restart] << block
     end
 
@@ -99,18 +216,30 @@ module Puma
     # to puma, as those are the same as the original process.
     #
     def restart_command(cmd)
-      @options[:restart_cmd] = cmd
+      @options[:restart_cmd] = cmd.to_s
     end
 
     # Store the pid of the server in the file at +path+.
     def pidfile(path)
-      @options[:pidfile] = path
+      @options[:pidfile] = path.to_s
     end
 
     # Disable request logging.
     #
-    def quiet
-      @options[:quiet] = true
+    def quiet(which=true)
+      @options[:log_requests] = !which
+    end
+
+    # Enable request logging
+    #
+    def log_requests(which=true)
+      @options[:log_requests] = which
+    end
+
+    # Show debugging info
+    #
+    def debug
+      @options[:debug] = true
     end
 
     # Load +path+ as a rackup file.
@@ -119,6 +248,16 @@ module Puma
       @options[:rackup] = path.to_s
     end
 
+    # Run Puma in TCP mode
+    #
+    def tcp_mode!
+      @options[:mode] = :tcp
+    end
+
+    def early_hints(answer=true)
+      @options[:early_hints] = answer
+    end
+
     # Redirect STDOUT and STDERR to files specified.
     def stdout_redirect(stdout=nil, stderr=nil, append=false)
       @options[:redirect_stdout] = stdout
@@ -136,16 +275,22 @@ module Puma
         raise "The minimum (#{min}) number of threads must be less than or equal to the max (#{max})"
       end
 
+      if max < 1
+        raise "The maximum number of threads (#{max}) must be greater than 0"
+      end
+
       @options[:min_threads] = min
       @options[:max_threads] = max
     end
 
     def ssl_bind(host, port, opts)
+      verify = opts.fetch(:verify_mode, 'none')
+
       if defined?(JRUBY_VERSION)
         keystore_additions = "keystore=#{opts[:keystore]}&keystore-pass=#{opts[:keystore_pass]}"
-        @options[:binds] << "ssl://#{host}:#{port}?cert=#{opts[:cert]}&key=#{opts[:key]}&#{keystore_additions}"
+        bind "ssl://#{host}:#{port}?cert=#{opts[:cert]}&key=#{opts[:key]}&#{keystore_additions}&verify_mode=#{verify}"
       else
-        @options[:binds] << "ssl://#{host}:#{port}?cert=#{opts[:cert]}&key=#{opts[:key]}"
+        bind "ssl://#{host}:#{port}?cert=#{opts[:cert]}&key=#{opts[:key]}&verify_mode=#{verify}"
       end
     end
 
@@ -172,9 +317,20 @@ module Puma
     # This can be called multiple times to add hooks.
     #
     def before_fork(&block)
+      @options[:before_fork] ||= []
       @options[:before_fork] << block
     end
 
+    # *Cluster mode only* Code to run in a worker when it 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] ||= []
+      @options[:before_worker_boot] << block
+    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
@@ -183,40 +339,41 @@ module Puma
     # This can be called multiple times to add hooks.
     #
     def on_worker_shutdown(&block)
+      @options[:before_worker_shutdown] ||= []
       @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
+    # *Cluster mode only* Code to run in the master when it 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] ||= []
       @options[:before_worker_fork] << block
     end
 
-    # *Cluster mode only* Code to run when a worker boots to setup
-    # the process after booting the app.
+    # *Cluster mode only* Code to run in the master after it starts
+    # a worker.
     #
     # This can be called multiple times to add hooks.
     #
-    def after_worker_boot(&block)
-      @options[:after_worker_boot] << block
+    def after_worker_fork(&block)
+      @options[:after_worker_fork] ||= []
+      @options[:after_worker_fork] = block
     end
 
+    alias_method :after_worker_boot, :after_worker_fork
+
     # The directory to operate out of.
     def directory(dir)
       @options[:directory] = dir.to_s
-      @options[:worker_directory] = dir.to_s
+    end
+
+    # DEPRECATED: The directory to operate out of.
+    def worker_directory(dir)
+      $stderr.puts "worker_directory is deprecated. Please use `directory`"
+      directory dir
     end
 
     # Run the app as a raw TCP app instead of an HTTP rack app
@@ -259,7 +416,7 @@ module Puma
 
     # Additional text to display in process listing
     def tag(string)
-      @options[:tag] = string
+      @options[:tag] = string.to_s
     end
 
     # *Cluster mode only* Set the timeout for workers in seconds
@@ -267,17 +424,17 @@ module Puma
     # that have not checked in within the given +timeout+.
     # This mitigates hung processes. Default value is 60 seconds.
     def worker_timeout(timeout)
-      @options[:worker_timeout] = timeout
+      @options[:worker_timeout] = Integer(timeout)
     end
 
     # *Cluster mode only* Set the timeout for workers to boot
     def worker_boot_timeout(timeout)
-      @options[:worker_boot_timeout] = timeout
+      @options[:worker_boot_timeout] = Integer(timeout)
     end
 
     # *Cluster mode only* Set the timeout for worker shutdown
     def worker_shutdown_timeout(timeout)
-      @options[:worker_shutdown_timeout] = timeout
+      @options[:worker_shutdown_timeout] = Integer(timeout)
     end
 
     # When set to true (the default), workers accept all requests
@@ -344,5 +501,6 @@ module Puma
         raise "Invalid value for set_remote_address - #{val}"
       end
     end
+
   end
 end

data/lib/puma/events.rb

@@ -1,4 +1,5 @@
 require 'puma/const'
+require "puma/null_io"
 require 'stringio'
 
 module Puma
@@ -34,8 +35,6 @@ module Puma
 
       @debug = ENV.key? 'PUMA_DEBUG'
 
-      @on_booted = []
-
       @hooks = Hash.new { |h,k| h[k] = [] }
     end
 
@@ -48,7 +47,7 @@ module Puma
       @hooks[hook].each { |t| t.call(*args) }
     end
 
-    # Register a callbock for a given hook
+    # Register a callback for a given hook
     #
     def register(hook, obj=nil, &blk)
       if obj and blk
@@ -92,8 +91,7 @@ module Puma
     # parsing exception.
     #
     def parse_error(server, env, error)
-      @stderr.puts "#{Time.now}: HTTP parse error, malformed request (#{env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR]}): #{error.inspect}"
-      @stderr.puts "#{Time.now}: ENV: #{env.inspect}\n---\n"
+      @stderr.puts "#{Time.now}: HTTP parse error, malformed request (#{env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR]}): #{error.inspect}\n---\n"
     end
 
     # An SSL error has occurred.
@@ -106,24 +104,30 @@ module Puma
     end
 
     # An unknown error has occurred.
-    # +server+ is the Server object, +env+ the request, +error+ an exception
-    # object, and +kind+ some additional info.
+    # +server+ is the Server object, +error+ an exception object,
+    # +kind+ some additional info, and +env+ the request.
     #
-    def unknown_error(server, error, kind="Unknown")
+    def unknown_error(server, error, kind="Unknown", env=nil)
       if error.respond_to? :render
         error.render "#{Time.now}: #{kind} error", @stderr
       else
-        @stderr.puts "#{Time.now}: #{kind} error: #{error.inspect}"
-        @stderr.puts error.backtrace.join("\n")
+        if env
+          string_block = [ "#{Time.now}: #{kind} error handling request { #{env['REQUEST_METHOD']} #{env['PATH_INFO']} }" ]
+          string_block << error.inspect
+        else
+          string_block = [ "#{Time.now}: #{kind} error: #{error.inspect}" ]
+        end
+        string_block << error.backtrace
+        @stderr.puts string_block.join("\n")
       end
     end
 
-    def on_booted(&b)
-      @on_booted << b
+    def on_booted(&block)
+      register(:on_booted, &block)
     end
 
     def fire_on_booted!
-      @on_booted.each { |b| b.call }
+      fire(:on_booted)
     end
 
     DEFAULT = new(STDOUT, STDERR)
@@ -138,5 +142,10 @@ module Puma
     def self.stdio
       Events.new $stdout, $stderr
     end
+
+    def self.null
+      n = NullIO.new
+      Events.new n, n
+    end
   end
 end

data/lib/puma/io_buffer.rb

@@ -1,6 +1,6 @@
 require 'puma/detect'
 
-if Puma::IS_JRUBY
+if Puma.jruby?
   require 'puma/java_io_buffer'
 else
   require 'puma/puma_http11'

data/lib/puma/jruby_restart.rb

@@ -61,7 +61,7 @@ module Puma
     end
 
     def self.daemon_start(dir, argv)
-      ENV['PUMA_DAEMON_RESTART'] = Process.pid.to_s
+      ENV[RestartKey] = Process.pid.to_s
 
       if k = ENV['PUMA_JRUBY_DAEMON_OPTS']
         ENV['JRUBY_OPTS'] = k
@@ -80,4 +80,3 @@ module Puma
     end
   end
 end
-