puma 2.11.1-java → 2.11.2-java

data/lib/puma/cluster.rb

@@ -104,6 +104,7 @@ module Puma
 
       diff.times do
         idx = next_worker_index
+        @options[:before_worker_fork].each { |h| h.call(idx) }
 
         pid = fork { worker(idx, master) }
         @cli.debug "Spawned worker: #{pid}"

data/lib/puma/configuration.rb

@@ -1,21 +1,16 @@
 module Puma
 
-  # The CLI exports its Configuration object here to allow
-  # apps to pick it up. An app needs to use it conditionally though
-  # since it is not set if the app is launched via another
-  # mechanism than the CLI class.
-
-  class << self
-    attr_accessor :cli_config
-  end
-
-  class Configuration
+  module ConfigDefault
     DefaultRackup = "config.ru"
 
     DefaultTCPHost = "0.0.0.0"
     DefaultTCPPort = 9292
     DefaultWorkerTimeout = 60
     DefaultWorkerShutdownTimeout = 30
+  end
+
+  class Configuration
+    include ConfigDefault
 
     def initialize(options)
       @options = options
@@ -24,6 +19,7 @@ module Puma
       @options[:on_restart] ||= []
       @options[:before_worker_shutdown] ||= []
       @options[:before_worker_boot] ||= []
+      @options[:before_worker_fork] ||= []
       @options[:after_worker_boot] ||= []
       @options[:worker_timeout] ||= DefaultWorkerTimeout
       @options[:worker_shutdown_timeout] ||= DefaultWorkerShutdownTimeout
@@ -36,38 +32,11 @@ module Puma
     end
 
     def load
-      if path = @options[:config_file]
-        DSL.new(@options)._load_from path
-      end
-
-      # Rakeup default option support
-      if host = @options[:Host]
-        port = @options[:Port] || DefaultTCPPort
-
-        @options[:binds] << "tcp://#{host}:#{port}"
-      end
-
-      if @options[:binds].empty?
-        @options[:binds] << "tcp://#{DefaultTCPHost}:#{DefaultTCPPort}"
-      end
+      DSL.load(@options, @options[:config_file])
 
-      if @options[:control_url] == "auto"
-        path = Configuration.temp_path
-        @options[:control_url] = "unix://#{path}"
-        @options[:control_url_temp] = path
-      end
-
-      unless @options[:control_auth_token]
-        setup_random_token
-      end
-
-      unless @options[:tag]
-        @options[:tag] = infer_tag
-      end
-    end
-
-    def infer_tag
-      File.basename Dir.getwd
+      setup_binds
+      setup_control
+      @options[:tag] ||= infer_tag
     end
 
     # Injects the Configuration object into the env
@@ -97,68 +66,21 @@ module Puma
     # the rackup file, and set @app.
     #
     def app
-      app = @options[:app]
-
-      unless app
-        unless File.exist?(rackup)
-          raise "Missing rackup file '#{rackup}'"
-        end
-
-        app, options = Rack::Builder.parse_file rackup
-        @options.merge! options
-
-        config_ru_binds = []
-
-        options.each do |key,val|
-          if key.to_s[0,4] == "bind"
-            config_ru_binds << val
-          end
-        end
-
-        @options[:binds] = config_ru_binds unless config_ru_binds.empty?
-      end
+      found = options[:app] || load_rackup
 
       if @options[:mode] == :tcp
         require 'puma/tcp_logger'
 
         logger = @options[:logger] || STDOUT
-        return TCPLogger.new(logger, app, @options[:quiet])
+        return TCPLogger.new(logger, found, @options[:quiet])
       end
 
       if !@options[:quiet] and @options[:environment] == "development"
         logger = @options[:logger] || STDOUT
-        app = Rack::CommonLogger.new(app, logger)
+        found = Rack::CommonLogger.new(found, logger)
       end
 
-      return ConfigMiddleware.new(self, app)
-    end
-
-    def setup_random_token
-      begin
-        require 'openssl'
-      rescue LoadError
-      end
-
-      count = 16
-
-      bytes = nil
-
-      if defined? OpenSSL::Random
-        bytes = OpenSSL::Random.random_bytes(count)
-      elsif File.exist?("/dev/urandom")
-        File.open("/dev/urandom") do |f|
-          bytes = f.read(count)
-        end
-      end
-
-      if bytes
-        token = ""
-        bytes.each_byte { |b| token << b.to_s(16) }
-      else
-        token = (0..count).to_a.map { rand(255).to_s(16) }.join
-      end
-
-      @options[:control_auth_token] = token
+      ConfigMiddleware.new(self, found)
     end
 
     def self.temp_path
@@ -168,265 +90,77 @@ module Puma
       "#{Dir.tmpdir}/puma-status-#{t}-#{$$}"
     end
 
-    # The methods that are available for use inside the config file.
-    #
-    class DSL
-      def initialize(options)
-        @options = options
-      end
-
-      def _load_from(path)
-        instance_eval File.read(path), path, 1
-      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
+    private
 
-        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
-          if tok = opts[:auth_token]
-            @options[:control_auth_token] = tok
-          end
-
-          if opts[:no_token]
-            @options[:control_auth_token] = :none
-          end
-        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)
-        o = [
-          "cert=#{opts[:cert]}",
-          "key=#{opts[:key]}"
-        ]
+    def infer_tag
+      File.basename(Dir.getwd)
+    end
 
-        @options[:binds] << "ssl://#{host}:#{port}?#{o.join('&')}"
-      end
+    def load_rackup
+      raise "Missing rackup file '#{rackup}'" unless File.exist?(rackup)
 
-      # 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
+      rack_app, rack_options = Rack::Builder.parse_file(rackup)
+      @options.merge!(rack_options)
 
-      # *Cluster mode only* How many worker processes to run.
-      #
-      def workers(count)
-        @options[:workers] = count.to_i
+      config_ru_binds = rack_options.each_with_object([]) do |(k, v), b|
+        b << v if k.start_with?('bind')
       end
+      @options[:binds] = config_ru_binds unless config_ru_binds.empty?
 
-      # *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
+      rack_app
+    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
+    def setup_binds
+      # Rakeup default option support
+      host = @options[:Host]
+      if host
+        port = @options[:Port] || DefaultTCPPort
+        @options[:binds] << "tcp://#{host}:#{port}"
       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
+      if @options[:binds].empty?
+        @options[:binds] << "tcp://#{DefaultTCPHost}:#{DefaultTCPPort}"
       end
 
-      # The directory to operate out of.
-      def directory(dir)
-        @options[:directory] = dir.to_s
-        @options[:worker_directory] = dir.to_s
-      end
+      @options[:binds].uniq!
+    end
 
-      # Run the app as a raw TCP app instead of an HTTP rack app
-      def tcp_mode
-        @options[:mode] = :tcp
+    def setup_control
+      if @options[:control_url] == 'auto'
+        path = Configuration.temp_path
+        @options[:control_url] = "unix://#{path}"
+        @options[:control_url_temp] = path
       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
+      setup_random_token unless @options[:control_auth_token]
+    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
+    def setup_random_token
+      begin
+        require 'openssl'
+      rescue LoadError
       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
+      count = 16
 
-      # Additional text to display in process listing
-      def tag(string)
-        @options[:tag] = string
-      end
+      bytes = nil
 
-      # *Cluster mode only* Set the timeout for workers
-      def worker_timeout(timeout)
-        @options[:worker_timeout] = timeout
+      if defined? OpenSSL::Random
+        bytes = OpenSSL::Random.random_bytes(count)
+      elsif File.exist?("/dev/urandom")
+        File.open('/dev/urandom') { |f| bytes = f.read(count) }
       end
 
-      # *Cluster mode only* Set the timeout for worker shutdown
-      def worker_shutdown_timeout(timeout)
-        @options[:worker_shutdown_timeout] = timeout
+      if bytes
+        token = ""
+        bytes.each_byte { |b| token << b.to_s(16) }
+      else
+        token = (0..count).to_a.map { rand(255).to_s(16) }.join
       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
+      @options[:control_auth_token] = token
     end
   end
 end
+
+require 'puma/dsl'