rack 1.4.7 → 2.1.4

data/lib/rack/server.rb

@@ -1,7 +1,15 @@
+# frozen_string_literal: true
+
 require 'optparse'
+require 'fileutils'
+
+require_relative 'core_ext/regexp'
 
 module Rack
+
   class Server
+    using ::Rack::RegexpExtensions
+
     class Options
       def parse!(args)
         options = {}
@@ -23,6 +31,9 @@ module Rack
           opts.on("-w", "--warn", "turn warnings on for your script") {
             options[:warn] = true
           }
+          opts.on("-q", "--quiet", "turn off logging") {
+            options[:quiet] = true
+          }
 
           opts.on("-I", "--include PATH",
                   "specify $LOAD_PATH (may be used more than once)") { |path|
@@ -36,11 +47,15 @@ module Rack
 
           opts.separator ""
           opts.separator "Rack options:"
-          opts.on("-s", "--server SERVER", "serve using SERVER (webrick/mongrel)") { |s|
+          opts.on("-b", "--builder BUILDER_LINE", "evaluate a BUILDER_LINE of code as a builder script") { |line|
+            options[:builder] = line
+          }
+
+          opts.on("-s", "--server SERVER", "serve using SERVER (thin/puma/webrick)") { |s|
             options[:server] = s
           }
 
-          opts.on("-o", "--host HOST", "listen on HOST (default: 0.0.0.0)") { |host|
+          opts.on("-o", "--host HOST", "listen on HOST (default: localhost)") { |host|
             options[:Host] = host
           }
 
@@ -62,10 +77,28 @@ module Rack
             options[:daemonize] = d ? true : false
           }
 
-          opts.on("-P", "--pid FILE", "file to store PID (default: rack.pid)") { |f|
+          opts.on("-P", "--pid FILE", "file to store PID") { |f|
             options[:pid] = ::File.expand_path(f)
           }
 
+          opts.separator ""
+          opts.separator "Profiling options:"
+
+          opts.on("--heap HEAPFILE", "Build the application, then dump the heap to HEAPFILE") do |e|
+            options[:heapfile] = e
+          end
+
+          opts.on("--profile PROFILE", "Dump CPU or Memory profile to PROFILE (defaults to a tempfile)") do |e|
+            options[:profile_file] = e
+          end
+
+          opts.on("--profile-mode MODE", "Profile mode (cpu|wall|object)") do |e|
+            { cpu: true, wall: true, object: true }.fetch(e.to_sym) do
+              raise OptionParser::InvalidOption, "unknown profile mode: #{e}"
+            end
+            options[:profile_mode] = e.to_sym
+          end
+
           opts.separator ""
           opts.separator "Common options:"
 
@@ -89,21 +122,21 @@ module Rack
           abort opt_parser.to_s
         end
 
-        options[:config] = args.last if args.last
+        options[:config] = args.last if args.last && !args.last.empty?
         options
       end
 
       def handler_opts(options)
         begin
           info = []
-          server = Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
+          server = Rack::Handler.get(options[:server]) || Rack::Handler.default
           if server && server.respond_to?(:valid_options)
             info << ""
             info << "Server-specific options for #{server.name}:"
 
             has_options = false
             server.valid_options.each do |name, description|
-              next if name.to_s.match(/^(Host|Port)[^a-zA-Z]/) # ignore handler's host and port options, we do our own.
+              next if /^(Host|Port)[^a-zA-Z]/.match?(name.to_s) # ignore handler's host and port options, we do our own.
               info << "  -O %-21s %s" % [name, description]
               has_options = true
             end
@@ -141,7 +174,9 @@ module Rack
 
     # Options may include:
     # * :app
-    #     a rack application to run (overrides :config)
+    #     a rack application to run (overrides :config and :builder)
+    # * :builder
+    #     a string to evaluate a Rack::Builder from
     # * :config
     #     a rackup configuration file path to load (.ru)
     # * :environment
@@ -162,7 +197,7 @@ module Rack
     # * :Port
     #     the port to bind to (used by supporting Rack::Handler)
     # * :AccessLog
-    #     webrick acess log options (or supporting Rack::Handler)
+    #     webrick access log options (or supporting Rack::Handler)
     # * :debug
     #     turn on debug output ($DEBUG = true)
     # * :warn
@@ -171,55 +206,79 @@ module Rack
     #     add given paths to $LOAD_PATH
     # * :require
     #     require the given libraries
+    #
+    # Additional options for profiling app initialization include:
+    # * :heapfile
+    #     location for ObjectSpace.dump_all to write the output to
+    # * :profile_file
+    #     location for CPU/Memory (StackProf) profile output (defaults to a tempfile)
+    # * :profile_mode
+    #     StackProf profile mode (cpu|wall|object)
     def initialize(options = nil)
-      @options = options
-      @app = options[:app] if options && options[:app]
+      @ignore_options = []
+
+      if options
+        @use_default_options = false
+        @options = options
+        @app = options[:app] if options[:app]
+      else
+        argv = defined?(SPEC_ARGV) ? SPEC_ARGV : ARGV
+        @use_default_options = true
+        @options = parse_options(argv)
+      end
     end
 
     def options
-      @options ||= parse_options(ARGV)
+      merged_options = @use_default_options ? default_options.merge(@options) : @options
+      merged_options.reject { |k, v| @ignore_options.include?(k) }
     end
 
     def default_options
+      environment  = ENV['RACK_ENV'] || 'development'
+      default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
       {
-        :environment => ENV['RACK_ENV'] || "development",
-        :pid         => nil,
-        :Port        => 9292,
-        :Host        => "0.0.0.0",
-        :AccessLog   => [],
-        :config      => "config.ru"
+        environment: environment,
+        pid: nil,
+        Port: 9292,
+        Host: default_host,
+        AccessLog: [],
+        config: "config.ru"
       }
     end
 
     def app
-      @app ||= begin
-        if !::File.exist? options[:config]
-          abort "configuration #{options[:config]} not found"
-        end
-
-        app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
-        self.options.merge! options
-        app
-      end
+      @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
     end
 
-    def self.logging_middleware
-      lambda { |server|
-        server.server.name =~ /CGI/ ? nil : [Rack::CommonLogger, $stderr]
-      }
-    end
+    class << self
+      def logging_middleware
+        lambda { |server|
+          /CGI/.match?(server.server.name) || server.options[:quiet] ? nil : [Rack::CommonLogger, $stderr]
+        }
+      end
 
-    def self.middleware
-      @middleware ||= begin
-        m = Hash.new {|h,k| h[k] = []}
-        m["deployment"].concat [
+      def default_middleware_by_environment
+        m = Hash.new {|h, k| h[k] = []}
+        m["deployment"] = [
+          [Rack::ContentLength],
+          logging_middleware,
+          [Rack::TempfileReaper]
+        ]
+        m["development"] = [
           [Rack::ContentLength],
-          [Rack::Chunked],
-          logging_middleware
+          logging_middleware,
+          [Rack::ShowExceptions],
+          [Rack::Lint],
+          [Rack::TempfileReaper]
         ]
-        m["development"].concat m["deployment"] + [[Rack::ShowExceptions], [Rack::Lint]]
+
         m
       end
+
+      def middleware
+        default_middleware_by_environment
+      end
     end
 
     def middleware
@@ -251,7 +310,9 @@ module Rack
 
       # Touch the wrapped app, so that the config.ru is loaded before
       # daemonization (i.e. before chdir, etc).
-      wrapped_app
+      handle_profiling(options[:heapfile], options[:profile_mode], options[:profile_file]) do
+        wrapped_app
+      end
 
       daemonize_app if options[:daemonize]
 
@@ -269,21 +330,80 @@ module Rack
     end
 
     def server
-      @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
+      @_server ||= Rack::Handler.get(options[:server])
+
+      unless @_server
+        @_server = Rack::Handler.default
+
+        # We already speak FastCGI
+        @ignore_options = [:File, :Port] if @_server.to_s == 'Rack::Handler::FastCGI'
+      end
+
+      @_server
     end
 
     private
-      def parse_options(args)
-        options = default_options
+      def build_app_and_options_from_config
+        if !::File.exist? options[:config]
+          abort "configuration #{options[:config]} not found"
+        end
+
+        app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
+        @options.merge!(options) { |key, old, new| old }
+        app
+      end
 
+      def handle_profiling(heapfile, profile_mode, filename)
+        if heapfile
+          require "objspace"
+          ObjectSpace.trace_object_allocations_start
+          yield
+          GC.start
+          ::File.open(heapfile, "w") { |f| ObjectSpace.dump_all(output: f) }
+          exit
+        end
+
+        if profile_mode
+          require "stackprof"
+          require "tempfile"
+
+          make_profile_name(filename) do |filename|
+            ::File.open(filename, "w") do |f|
+              StackProf.run(mode: profile_mode, out: f) do
+                yield
+              end
+              puts "Profile written to: #{filename}"
+            end
+          end
+          exit
+        end
+
+        yield
+      end
+
+      def make_profile_name(filename)
+        if filename
+          yield filename
+        else
+          ::Dir::Tmpname.create("profile.dump") do |tmpname, _, _|
+            yield tmpname
+          end
+        end
+      end
+
+      def build_app_from_string
+        Rack::Builder.new_from_string(self.options[:builder])
+      end
+
+      def parse_options(args)
         # Don't evaluate CGI ISINDEX parameters.
         # http://www.meb.uni-bonn.de/docs/cgi/cl.html
-        args.clear if ENV.include?("REQUEST_METHOD")
+        args.clear if ENV.include?(REQUEST_METHOD)
 
-        options.merge! opt_parser.parse!(args)
-        options[:config] = ::File.expand_path(options[:config])
+        @options = opt_parser.parse!(args)
+        @options[:config] = ::File.expand_path(options[:config])
         ENV["RACK_ENV"] = options[:environment]
-        options
+        @options
       end
 
       def opt_parser
@@ -294,8 +414,8 @@ module Rack
         middleware[options[:environment]].reverse_each do |middleware|
           middleware = middleware.call(self) if middleware.respond_to?(:call)
           next unless middleware
-          klass = middleware.shift
-          app = klass.new(app, *middleware)
+          klass, *args = middleware
+          app = klass.new(app, *args)
         end
         app
       end
@@ -305,22 +425,15 @@ module Rack
       end
 
       def daemonize_app
-        if RUBY_VERSION < "1.9"
-          exit if fork
-          Process.setsid
-          exit if fork
-          Dir.chdir "/"
-          STDIN.reopen "/dev/null"
-          STDOUT.reopen "/dev/null", "a"
-          STDERR.reopen "/dev/null", "a"
-        else
-          Process.daemon
-        end
+        Process.daemon
       end
 
       def write_pid
-        ::File.open(options[:pid], 'w'){ |f| f.write("#{Process.pid}") }
-        at_exit { ::File.delete(options[:pid]) if ::File.exist?(options[:pid]) }
+        ::File.open(options[:pid], ::File::CREAT | ::File::EXCL | ::File::WRONLY ){ |f| f.write("#{Process.pid}") }
+        at_exit { ::FileUtils.rm_f(options[:pid]) }
+      rescue Errno::EEXIST
+        check_pid!
+        retry
       end
 
       def check_pid!
@@ -348,4 +461,5 @@ module Rack
       end
 
   end
+
 end