puma 2.7.0 → 3.1.1

data/lib/puma/commonlogger.rb

@@ -0,0 +1,107 @@
+module Puma
+  # Rack::CommonLogger forwards every request to the given +app+, and
+  # logs a line in the
+  # {Apache common log format}[http://httpd.apache.org/docs/1.3/logs.html#common]
+  # to the +logger+.
+  #
+  # If +logger+ is nil, CommonLogger will fall back +rack.errors+, which is
+  # an instance of Rack::NullLogger.
+  #
+  # +logger+ can be any class, including the standard library Logger, and is
+  # expected to have either +write+ or +<<+ method, which accepts the CommonLogger::FORMAT.
+  # According to the SPEC, the error stream must also respond to +puts+
+  # (which takes a single argument that responds to +to_s+), and +flush+
+  # (which is called without arguments in order to make the error appear for
+  # sure)
+  class CommonLogger
+    # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
+    #
+    #   lilith.local - - [07/Aug/2006 23:58:02 -0400] "GET / HTTP/1.1" 500 -
+    #
+    #   %{%s - %s [%s] "%s %s%s %s" %d %s\n} %
+    FORMAT = %{%s - %s [%s] "%s %s%s %s" %d %s %0.4f\n}
+
+    def initialize(app, logger=nil)
+      @app = app
+      @logger = logger
+    end
+
+    def call(env)
+      began_at = Time.now
+      status, header, body = @app.call(env)
+      header = Util::HeaderHash.new(header)
+
+      # If we've been hijacked, then output a special line
+      if env['rack.hijack_io']
+        log_hijacking(env, 'HIJACK', header, began_at)
+      else
+        ary = env['rack.after_reply']
+        ary << lambda { log(env, status, header, began_at) }
+      end
+
+      [status, header, body]
+    end
+
+    HIJACK_FORMAT = %{%s - %s [%s] "%s %s%s %s" HIJACKED -1 %0.4f\n}
+
+    private
+
+    def log_hijacking(env, status, header, began_at)
+      now = Time.now
+
+      logger = @logger || env['rack.errors']
+      logger.write HIJACK_FORMAT % [
+        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
+        env["REMOTE_USER"] || "-",
+        now.strftime("%d/%b/%Y %H:%M:%S"),
+        env["REQUEST_METHOD"],
+        env["PATH_INFO"],
+        env["QUERY_STRING"].empty? ? "" : "?"+env["QUERY_STRING"],
+        env["HTTP_VERSION"],
+        now - began_at ]
+    end
+
+    PATH_INFO      = 'PATH_INFO'.freeze
+    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+    SCRIPT_NAME    = 'SCRIPT_NAME'.freeze
+    QUERY_STRING   = 'QUERY_STRING'.freeze
+    CACHE_CONTROL  = 'Cache-Control'.freeze
+    CONTENT_LENGTH = 'Content-Length'.freeze
+    CONTENT_TYPE   = 'Content-Type'.freeze
+
+    GET  = 'GET'.freeze
+    HEAD = 'HEAD'.freeze
+    
+
+    def log(env, status, header, began_at)
+      now = Time.now
+      length = extract_content_length(header)
+
+      msg = FORMAT % [
+        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
+        env["REMOTE_USER"] || "-",
+        now.strftime("%d/%b/%Y:%H:%M:%S %z"),
+        env[REQUEST_METHOD],
+        env[PATH_INFO],
+        env[QUERY_STRING].empty? ? "" : "?"+env[QUERY_STRING],
+        env["HTTP_VERSION"],
+        status.to_s[0..3],
+        length,
+        now - began_at ]
+
+      logger = @logger || env['rack.errors']
+      # Standard library logger doesn't support write but it supports << which actually
+      # calls to write on the log device without formatting
+      if logger.respond_to?(:write)
+        logger.write(msg)
+      else
+        logger << msg
+      end
+    end
+
+    def extract_content_length(headers)
+      value = headers[CONTENT_LENGTH] or return '-'
+      value.to_s == '0' ? '-' : value
+    end
+  end
+end

data/lib/puma/configuration.rb

@@ -1,59 +1,218 @@
+require 'puma/rack/builder'
+require 'puma/plugin'
+
 module Puma
 
-  # The CLI exports it's 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.
+  module ConfigDefault
+    DefaultRackup = "config.ru"
 
-  class << self
-    attr_accessor :cli_config
+    DefaultTCPHost = "0.0.0.0"
+    DefaultTCPPort = 9292
+    DefaultWorkerTimeout = 60
+    DefaultWorkerShutdownTimeout = 30
+  end
+
+  class LeveledOptions
+    def initialize(default={})
+      @cur = {}
+      @set = [@cur]
+      @defaults = default.dup
+    end
+
+    def initialize_copy(other)
+      @set = @set.map { |o| o.dup }
+      @cur = @set.last
+    end
+
+    def shift
+      @cur = {}
+      @set << @cur
+    end
+
+    def [](key)
+      @set.each do |o|
+        if o.key? key
+          return o[key]
+        end
+      end
+
+      v = @defaults[key]
+      if v.respond_to? :call
+        v.call
+      else
+        v
+      end
+    end
+
+    def fetch(key, default=nil)
+      val = self[key]
+      return val if val
+      default
+    end
+
+    attr_reader :cur
+
+    def all_of(key)
+      all = []
+
+      @set.each do |o|
+        if v = o[key]
+          if v.kind_of? Array
+            all += v
+          else
+            all << v
+          end
+        end
+      end
+
+      all
+    end
+
+    def []=(key, val)
+      @cur[key] = val
+    end
+
+    def key?(key)
+      @set.each do |o|
+        if o.key? key
+          return true
+        end
+      end
+
+      @default.key? key
+    end
+
+    def merge!(o)
+      o.each do |k,v|
+        @cur[k]= v
+      end
+    end
+
+    def flatten
+      options = {}
+
+      @set.each do |o|
+        o.each do |k,v|
+          options[k] ||= v
+        end
+      end
+
+      options
+    end
+
+    def explain
+      indent = ""
+
+      @set.each do |o|
+        o.keys.sort.each do |k|
+          puts "#{indent}#{k}: #{o[k].inspect}"
+        end
+
+        indent = "  #{indent}"
+      end
+    end
+
+    def force_defaults
+      @defaults.each do |k,v|
+        if v.respond_to? :call
+          @defaults[k] = v.call
+        end
+      end
+    end
   end
 
   class Configuration
-    DefaultRackup = "config.ru"
+    include ConfigDefault
 
-    DefaultTCPHost = "0.0.0.0"
-    DefaultTCPPort = 9292
+    def self.from_file(path)
+      cfg = new
 
-    def initialize(options)
-      @options = options
-      @options[:mode] ||= :http
-      @options[:binds] ||= []
-      @options[:on_restart] ||= []
-      @options[:worker_boot] ||= []
+      DSL.new(cfg.options, cfg)._load_from path
+
+      return cfg
     end
 
-    attr_reader :options
+    def initialize(options={}, &blk)
+      @options = LeveledOptions.new(default_options)
+      @plugins = PluginLoader.new
+
+      # options.each do |k,v|
+        # @options[k] = v
+      # end
+
+      if blk
+        configure(&blk)
+      end
+    end
+
+    attr_reader :options, :plugins
+
+    def configure(&blk)
+      @options.shift
+      DSL.new(@options, self)._run(&blk)
+    end
 
     def initialize_copy(other)
+      @conf = nil
+      @cli_options = nil
       @options = @options.dup
     end
 
+    def flatten
+      dup.flatten!
+    end
+
+    def flatten!
+      @options = @options.flatten
+      self
+    end
+
+    def default_options
+      {
+        :min_threads => 0,
+        :max_threads => 16,
+        :log_requests => false,
+        :debug => false,
+        :binds => ["tcp://#{DefaultTCPHost}:#{DefaultTCPPort}"],
+        :workers => 0,
+        :daemon => false,
+        :mode => :http,
+        :worker_timeout => DefaultWorkerTimeout,
+        :worker_boot_timeout => DefaultWorkerTimeout,
+        :worker_shutdown_timeout => DefaultWorkerShutdownTimeout,
+        :remote_address => :socket,
+        :tag => method(:infer_tag),
+        :environment => lambda { ENV['RACK_ENV'] || "development" },
+        :rackup => DefaultRackup,
+        :logger => STDOUT
+      }
+    end
+
     def load
-      if path = @options[:config_file]
-        DSL.new(@options)._load_from path
-      end
+      files = @options.all_of(:config_files)
 
-      # Rakeup default option support
-      if host = @options[:Host]
-        port = @options[:Port] || DefaultTCPPort
+      if files.empty?
+        imp = %W(config/puma/#{@options[:environment]}.rb config/puma.rb).find { |f|
+          File.exist?(f)
+        }
 
-        @options[:binds] << "tcp://#{host}:#{port}"
+        files << imp
+      elsif files == ["-"]
+        files = []
       end
 
-      if @options[:binds].empty?
-        @options[:binds] << "tcp://#{DefaultTCPHost}:#{DefaultTCPPort}"
-      end
+      files.each do |f|
+        @options.shift
 
-      if @options[:control_url] == "auto"
-        path = Configuration.temp_path
-        @options[:control_url] = "unix://#{path}"
-        @options[:control_url_temp] = path
+        DSL.load @options, self, f
       end
+    end
 
-      unless @options[:control_auth_token]
-        setup_random_token
-      end
+    # Call once all configuration (included from rackup files)
+    # is loaded to flesh out any defaults
+    def clamp
+      @options.shift
+      @options.force_defaults
     end
 
     # Injects the Configuration object into the env
@@ -72,75 +231,45 @@ module Puma
     # Indicate if there is a properly configured app
     #
     def app_configured?
-      @options[:app] || File.exists?(rackup)
+      @options[:app] || File.exist?(rackup)
     end
 
     def rackup
-      @options[:rackup] || DefaultRackup
+      @options[:rackup]
     end
 
-    # Load the specified rackup file, pull an options from
+    # Load the specified rackup file, pull options from
     # the rackup file, and set @app.
     #
     def app
-      app = @options[:app]
-
-      unless app
-        unless File.exists?(rackup)
-          raise "Missing rackup file '#{rackup}'"
-        end
-
-        app, options = Rack::Builder.parse_file rackup
-        @options.merge! options
-
-        options.each do |key,val|
-          if key.to_s[0,4] == "bind"
-            @options[:binds] << val
-          end
-        end
-      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])
+        logger = @options[:logger]
+        return TCPLogger.new(logger, found, @options[:log_requests])
       end
 
-      if !@options[:quiet] and @options[:environment] == "development"
-        logger = @options[:logger] || STDOUT
-        app = Rack::CommonLogger.new(app, logger)
+      if @options[:log_requests]
+        logger = @options[:logger]
+        found = CommonLogger.new(found, logger)
       end
 
-      return ConfigMiddleware.new(self, app)
+      ConfigMiddleware.new(self, found)
     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.exists?("/dev/urandom")
-        File.open("/dev/urandom") do |f|
-          bytes = f.read(count)
-        end
-      end
+    # Return which environment we're running in
+    def environment
+      @options[:environment]
+    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
+    def load_plugin(name)
+      @plugins.create name
+    end
 
-      @options[:control_auth_token] = token
+    def run_hooks(key, arg)
+      @options.all_of(key).each { |b| b.call arg }
     end
 
     def self.temp_path
@@ -150,181 +279,79 @@ 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
+    def infer_tag
+      File.basename(Dir.getwd)
+    end
 
-          if opts[:no_token]
-            @options[:control_auth_token] = :none
-          end
+    # Load and use the normal Rack builder if we can, otherwise
+    # fallback to our minimal version.
+    def rack_builder
+      # Load bundler now if we can so that we can pickup rack from
+      # a Gemfile
+      if ENV.key? 'PUMA_BUNDLER_PRUNED'
+        begin
+          require 'bundler/setup'
+        rescue LoadError
         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
-
-      # 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
+      begin
+        require 'rack'
+        require 'rack/builder'
+      rescue LoadError
+        # ok, use builtin version
+        return Puma::Rack::Builder
+      else
+        return ::Rack::Builder
       end
+    end
 
-      # Store the pid of the server in the file at +path+.
-      def pidfile(path)
-        @options[:pidfile] = path
-      end
+    def load_rackup
+      raise "Missing rackup file '#{rackup}'" unless File.exist?(rackup)
 
-      # Disable request logging.
-      #
-      def quiet
-        @options[:quiet] = true
-      end
+      @options.shift
 
-      # Load +path+ as a rackup file.
-      #
-      def rackup(path)
-        @options[:rackup] = path.to_s
-      end
+      rack_app, rack_options = rack_builder.parse_file(rackup)
+      @options.merge!(rack_options)
 
-      # 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
+      config_ru_binds = []
+      rack_options.each do |k, v|
+        config_ru_binds << v if k.to_s.start_with?("bind")
       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
+      @options[:binds] = config_ru_binds unless config_ru_binds.empty?
 
-      def ssl_bind(host, port, opts)
-        o = [
-          "cert=#{opts[:cert]}",
-          "key=#{opts[:key]}"
-        ]
-
-        @options[:binds] << "ssl://#{host}:#{port}?#{o.join('&')}"
-      end
+      rack_app
+    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
+    def self.random_token
+      begin
+        require 'openssl'
+      rescue LoadError
       end
 
-      # *Cluster mode only* How many worker processes to run.
-      #
-      def workers(count)
-        @options[:workers] = count.to_i
-      end
+      count = 16
 
-      # *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[:worker_boot] << block
-      end
+      bytes = nil
 
-      # The directory to operate out of.
-      def directory(dir)
-        @options[:directory] = dir.to_s
-        @options[:worker_directory] = dir.to_s
+      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
 
-      # Run the app as a raw TCP app instead of an HTTP rack app
-      def tcp_mode
-        @options[:mode] = :tcp
+      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
 
-      # *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
+      return token
     end
   end
 end
+
+require 'puma/dsl'