rack 1.1.6 → 1.6.9

data/lib/rack/sendfile.rb

@@ -1,9 +1,7 @@
 require 'rack/file'
+require 'rack/body_proxy'
 
 module Rack
-  class File #:nodoc:
-    alias :to_path :path
-  end
 
   # = Sendfile
   #
@@ -11,7 +9,7 @@ module Rack
   # served from a file and replaces it with a server specific X-Sendfile
   # header. The web server is then responsible for writing the file contents
   # to the client. This can dramatically reduce the amount of work required
-  # by the Ruby backend and takes advantage of the web servers optimized file
+  # by the Ruby backend and takes advantage of the web server's optimized file
   # delivery code.
   #
   # In order to take advantage of this middleware, the response body must
@@ -25,33 +23,33 @@ module Rack
   #
   # Nginx supports the X-Accel-Redirect header. This is similar to X-Sendfile
   # but requires parts of the filesystem to be mapped into a private URL
-  # hierarachy.
+  # hierarchy.
   #
   # The following example shows the Nginx configuration required to create
   # a private "/files/" area, enable X-Accel-Redirect, and pass the special
   # X-Sendfile-Type and X-Accel-Mapping headers to the backend:
   #
-  #   location /files/ {
+  #   location ~ /files/(.*) {
   #     internal;
-  #     alias /var/www/;
+  #     alias /var/www/$1;
   #   }
   #
   #   location / {
-  #     proxy_redirect     false;
+  #     proxy_redirect     off;
   #
   #     proxy_set_header   Host                $host;
   #     proxy_set_header   X-Real-IP           $remote_addr;
   #     proxy_set_header   X-Forwarded-For     $proxy_add_x_forwarded_for;
   #
-  #     proxy_set_header   X-Sendfile-Type     X-Accel-Redirect
-  #     proxy_set_header   X-Accel-Mapping     /files/=/var/www/;
+  #     proxy_set_header   X-Sendfile-Type     X-Accel-Redirect;
+  #     proxy_set_header   X-Accel-Mapping     /var/www/=/files/;
   #
   #     proxy_pass         http://127.0.0.1:8080/;
   #   }
   #
-  # Note that the X-Sendfile-Type header must be set exactly as shown above. The
-  # X-Accel-Mapping header should specify the name of the private URL pattern,
-  # followed by an equals sign (=), followed by the location on the file system
+  # Note that the X-Sendfile-Type header must be set exactly as shown above.
+  # The X-Accel-Mapping header should specify the location on the file system,
+  # followed by an equals sign (=), followed name of the private URL pattern
   # that it maps to. The middleware performs a simple substitution on the
   # resulting path.
   #
@@ -84,7 +82,7 @@ module Rack
   #
   # X-Sendfile is supported under Apache 2.x using a separate module:
   #
-  # http://tn123.ath.cx/mod_xsendfile/
+  # https://tn123.org/mod_xsendfile/
   #
   # Once the module is compiled and installed, you can enable it using
   # XSendFile config directive:
@@ -92,13 +90,23 @@ module Rack
   #   RequestHeader Set X-Sendfile-Type X-Sendfile
   #   ProxyPassReverse / http://localhost:8001/
   #   XSendFile on
+  #
+  # === Mapping parameter
+  #
+  # The third parameter allows for an overriding extension of the
+  # X-Accel-Mapping header. Mappings should be provided in tuples of internal to
+  # external. The internal values may contain regular expression syntax, they
+  # will be matched with case indifference.
 
   class Sendfile
     F = ::File
 
-    def initialize(app, variation=nil)
+    def initialize(app, variation=nil, mappings=[])
       @app = app
       @variation = variation
+      @mappings = mappings.map do |internal, external|
+        [/^#{internal}/i, external]
+      end
     end
 
     def call(env)
@@ -108,35 +116,45 @@ module Rack
         when 'X-Accel-Redirect'
           path = F.expand_path(body.to_path)
           if url = map_accel_path(env, path)
+            headers[CONTENT_LENGTH] = '0'
             headers[type] = url
-            body = []
+            obody = body
+            body = Rack::BodyProxy.new([]) do
+              obody.close if obody.respond_to?(:close)
+            end
           else
-            env['rack.errors'] << "X-Accel-Mapping header missing"
+            env['rack.errors'].puts "X-Accel-Mapping header missing"
           end
         when 'X-Sendfile', 'X-Lighttpd-Send-File'
           path = F.expand_path(body.to_path)
+          headers[CONTENT_LENGTH] = '0'
           headers[type] = path
-          body = []
+          obody = body
+          body = Rack::BodyProxy.new([]) do
+            obody.close if obody.respond_to?(:close)
+          end
         when '', nil
         else
-          env['rack.errors'] << "Unknown x-sendfile variation: '#{variation}'.\n"
+          env['rack.errors'].puts "Unknown x-sendfile variation: '#{type}'.\n"
         end
       end
       [status, headers, body]
     end
 
     private
-      def variation(env)
-        @variation ||
-          env['sendfile.type'] ||
-          env['HTTP_X_SENDFILE_TYPE']
-      end
+    def variation(env)
+      @variation ||
+        env['sendfile.type'] ||
+        env['HTTP_X_SENDFILE_TYPE']
+    end
 
-      def map_accel_path(env, file)
-        if mapping = env['HTTP_X_ACCEL_MAPPING']
-          internal, external = mapping.split('=', 2).map{ |p| p.strip }
-          file.sub(/^#{internal}/i, external)
-        end
+    def map_accel_path(env, path)
+      if mapping = @mappings.find { |internal,_| internal =~ path }
+        path.sub(*mapping)
+      elsif mapping = env['HTTP_X_ACCEL_MAPPING']
+        internal, external = mapping.split('=', 2).map{ |p| p.strip }
+        path.sub(/^#{internal}/i, external)
       end
+    end
   end
 end

data/lib/rack/server.rb

@@ -1,7 +1,11 @@
 require 'optparse'
+require 'fileutils'
+
 
 module Rack
+
   class Server
+
     class Options
       def parse!(args)
         options = {}
@@ -17,16 +21,23 @@ module Rack
             lineno += 1
           }
 
+          opts.on("-b", "--builder BUILDER_LINE", "evaluate a BUILDER_LINE of code as a builder script") { |line|
+            options[:builder] = line
+          }
+
           opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
             options[:debug] = true
           }
           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|
-            options[:include] = path.split(":")
+            (options[:include] ||= []).concat(path.split(":"))
           }
 
           opts.on("-r", "--require LIBRARY",
@@ -36,11 +47,11 @@ module Rack
 
           opts.separator ""
           opts.separator "Rack options:"
-          opts.on("-s", "--server SERVER", "serve using SERVER (webrick/mongrel)") { |s|
+          opts.on("-s", "--server SERVER", "serve using SERVER (thin/puma/webrick/mongrel)") { |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
           }
 
@@ -48,6 +59,12 @@ module Rack
             options[:Port] = port
           }
 
+          opts.on("-O", "--option NAME[=VALUE]", "pass VALUE to the server as option NAME. If no VALUE, sets it to true. Run '#{$0} -s SERVER -h' to get a list of options for SERVER") { |name|
+            name, value = name.split('=', 2)
+            value = true if value.nil?
+            options[name.to_sym] = value
+          }
+
           opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development)") { |e|
             options[:environment] = e
           }
@@ -56,37 +73,118 @@ module Rack
             options[:daemonize] = d ? true : false
           }
 
-          opts.on("-P", "--pid FILE", "file to store PID (default: rack.pid)") { |f|
-            options[:pid] = ::File.expand_path(f, Dir.pwd)
+          opts.on("-P", "--pid FILE", "file to store PID") { |f|
+            options[:pid] = ::File.expand_path(f)
           }
 
           opts.separator ""
           opts.separator "Common options:"
 
-          opts.on_tail("-h", "--help", "Show this message") do
+          opts.on_tail("-h", "-?", "--help", "Show this message") do
             puts opts
+            puts handler_opts(options)
+
             exit
           end
 
           opts.on_tail("--version", "Show version") do
-            puts "Rack #{Rack.version}"
+            puts "Rack #{Rack.version} (Release: #{Rack.release})"
             exit
           end
         end
-        opt_parser.parse! args
+
+        begin
+          opt_parser.parse! args
+        rescue OptionParser::InvalidOption => e
+          warn e.message
+          abort opt_parser.to_s
+        end
+
         options[:config] = args.last if args.last
         options
       end
-    end
 
-    def self.start
-      new.start
+      def handler_opts(options)
+        begin
+          info = []
+          server = Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
+          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.
+              info << "  -O %-21s %s" % [name, description]
+              has_options = true
+            end
+            return "" if !has_options
+          end
+          info.join("\n")
+        rescue NameError
+          return "Warning: Could not find handler specified (#{options[:server] || 'default'}) to determine handler-specific options"
+        end
+      end
     end
 
-    attr_accessor :options
+    # Start a new rack server (like running rackup). This will parse ARGV and
+    # provide standard ARGV rackup options, defaulting to load 'config.ru'.
+    #
+    # Providing an options hash will prevent ARGV parsing and will not include
+    # any default options.
+    #
+    # This method can be used to very easily launch a CGI application, for
+    # example:
+    #
+    #  Rack::Server.start(
+    #    :app => lambda do |e|
+    #      [200, {'Content-Type' => 'text/html'}, ['hello world']]
+    #    end,
+    #    :server => 'cgi'
+    #  )
+    #
+    # Further options available here are documented on Rack::Server#initialize
+    def self.start(options = nil)
+      new(options).start
+    end
 
+    attr_writer :options
+
+    # Options may include:
+    # * :app
+    #     a rack application to run (overrides :config)
+    # * :config
+    #     a rackup configuration file path to load (.ru)
+    # * :environment
+    #     this selects the middleware that will be wrapped around
+    #     your application. Default options available are:
+    #       - development: CommonLogger, ShowExceptions, and Lint
+    #       - deployment: CommonLogger
+    #       - none: no extra middleware
+    #     note: when the server is a cgi server, CommonLogger is not included.
+    # * :server
+    #     choose a specific Rack::Handler, e.g. cgi, fcgi, webrick
+    # * :daemonize
+    #     if true, the server will daemonize itself (fork, detach, etc)
+    # * :pid
+    #     path to write a pid file after daemonize
+    # * :Host
+    #     the host address to bind to (used by supporting Rack::Handler)
+    # * :Port
+    #     the port to bind to (used by supporting Rack::Handler)
+    # * :AccessLog
+    #     webrick access log options (or supporting Rack::Handler)
+    # * :debug
+    #     turn on debug output ($DEBUG = true)
+    # * :warn
+    #     turn on warnings ($-w = true)
+    # * :include
+    #     add given paths to $LOAD_PATH
+    # * :require
+    #     require the given libraries
     def initialize(options = nil)
       @options = options
+      @app = options[:app] if options && options[:app]
     end
 
     def options
@@ -94,80 +192,130 @@ module Rack
     end
 
     def default_options
+      environment  = ENV['RACK_ENV'] || 'development'
+      default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
       {
-        :environment => "development",
+        :environment => environment,
         :pid         => nil,
         :Port        => 9292,
-        :Host        => "0.0.0.0",
+        :Host        => default_host,
         :AccessLog   => [],
-        :config      => ::File.expand_path("config.ru", Dir.pwd)
+        :config      => "config.ru"
       }
     end
 
     def app
-      @app ||= begin
-        if !::File.exist? options[:config]
-          abort "configuration #{options[:config]} not found"
-        end
+      @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
+    end
 
-        app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
-        self.options.merge! options
-        app
+    class << self
+      def logging_middleware
+        lambda { |server|
+          server.server.name =~ /CGI/ || server.options[:quiet] ? nil : [Rack::CommonLogger, $stderr]
+        }
       end
-    end
 
-    def self.middleware
-      @middleware ||= begin
+      def default_middleware_by_environment
         m = Hash.new {|h,k| h[k] = []}
-        m["deployment"].concat  [lambda {|server| server.server =~ /CGI/ ? nil : [Rack::CommonLogger, $stderr] }]
-        m["development"].concat m["deployment"] + [[Rack::ShowExceptions], [Rack::Lint]]
+        m["deployment"] = [
+          [Rack::ContentLength],
+          [Rack::Chunked],
+          logging_middleware,
+          [Rack::TempfileReaper]
+        ]
+        m["development"] = [
+          [Rack::ContentLength],
+          [Rack::Chunked],
+          logging_middleware,
+          [Rack::ShowExceptions],
+          [Rack::Lint],
+          [Rack::TempfileReaper]
+        ]
+
         m
       end
+
+      def middleware
+        default_middleware_by_environment
+      end
     end
 
     def middleware
       self.class.middleware
     end
 
-    def start
-      if options[:debug]
-        $DEBUG = true
-        require 'pp'
-        p options[:server]
-        pp wrapped_app
-        pp app
-      end
-
+    def start &blk
       if options[:warn]
         $-w = true
       end
 
       if includes = options[:include]
-        $LOAD_PATH.unshift *includes
+        $LOAD_PATH.unshift(*includes)
       end
 
       if library = options[:require]
         require library
       end
 
+      if options[:debug]
+        $DEBUG = true
+        require 'pp'
+        p options[:server]
+        pp wrapped_app
+        pp app
+      end
+
+      check_pid! if options[:pid]
+
+      # Touch the wrapped app, so that the config.ru is loaded before
+      # daemonization (i.e. before chdir, etc).
+      wrapped_app
+
       daemonize_app if options[:daemonize]
+
       write_pid if options[:pid]
-      server.run wrapped_app, options
+
+      trap(:INT) do
+        if server.respond_to?(:shutdown)
+          server.shutdown
+        else
+          exit
+        end
+      end
+
+      server.run wrapped_app, options, &blk
     end
 
     def server
-      @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default
+      @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
     end
 
     private
+      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)
+        self.options.merge! options
+        app
+      end
+
+      def build_app_from_string
+        Rack::Builder.new_from_string(self.options[:builder])
+      end
+
       def parse_options(args)
         options = default_options
 
         # Don't evaluate CGI ISINDEX parameters.
-        # http://hoohoo.ncsa.uiuc.edu/cgi/cl.html
-        args.clear if ENV.include?("REQUEST_METHOD")
+        # http://www.meb.uni-bonn.de/docs/cgi/cl.html
+        args.clear if ENV.include?(REQUEST_METHOD)
 
-        options.merge! opt_parser.parse! args
+        options.merge! opt_parser.parse!(args)
+        options[:config] = ::File.expand_path(options[:config])
+        ENV["RACK_ENV"] = options[:environment]
         options
       end
 
@@ -179,8 +327,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
@@ -195,7 +343,6 @@ module Rack
           Process.setsid
           exit if fork
           Dir.chdir "/"
-          ::File.umask 0000
           STDIN.reopen "/dev/null"
           STDOUT.reopen "/dev/null", "a"
           STDERR.reopen "/dev/null", "a"
@@ -205,8 +352,37 @@ module Rack
       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!
+        case pidfile_process_status
+        when :running, :not_owned
+          $stderr.puts "A server is already running. Check #{options[:pid]}."
+          exit(1)
+        when :dead
+          ::File.delete(options[:pid])
+        end
+      end
+
+      def pidfile_process_status
+        return :exited unless ::File.exist?(options[:pid])
+
+        pid = ::File.read(options[:pid]).to_i
+        return :dead if pid == 0
+
+        Process.kill(0, pid)
+        :running
+      rescue Errno::ESRCH
+        :dead
+      rescue Errno::EPERM
+        :not_owned
+      end
+
   end
+
 end