rack 1.1.6 → 1.6.9

data/lib/rack/handler/cgi.rb

@@ -1,22 +1,22 @@
 require 'rack/content_length'
+require 'rack/rewindable_input'
 
 module Rack
   module Handler
     class CGI
       def self.run(app, options=nil)
+        $stdin.binmode
         serve app
       end
 
       def self.serve(app)
-        app = ContentLength.new(app)
-
         env = ENV.to_hash
         env.delete "HTTP_CONTENT_LENGTH"
 
         env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
 
-        env.update({"rack.version" => [1,1],
-                     "rack.input" => $stdin,
+        env.update({"rack.version" => Rack::VERSION,
+                     "rack.input" => Rack::RewindableInput.new($stdin),
                      "rack.errors" => $stderr,
 
                      "rack.multithread" => false,
@@ -26,7 +26,7 @@ module Rack
                      "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
                    })
 
-        env["QUERY_STRING"] ||= ""
+        env[QUERY_STRING]   ||= ""
         env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
         env["REQUEST_PATH"] ||= "/"
 
@@ -40,20 +40,20 @@ module Rack
       end
 
       def self.send_headers(status, headers)
-        STDOUT.print "Status: #{status}\r\n"
+        $stdout.print "Status: #{status}\r\n"
         headers.each { |k, vs|
           vs.split("\n").each { |v|
-            STDOUT.print "#{k}: #{v}\r\n"
+            $stdout.print "#{k}: #{v}\r\n"
           }
         }
-        STDOUT.print "\r\n"
-        STDOUT.flush
+        $stdout.print "\r\n"
+        $stdout.flush
       end
 
       def self.send_body(body)
         body.each { |part|
-          STDOUT.print part
-          STDOUT.flush
+          $stdout.print part
+          $stdout.flush
         }
       end
     end

data/lib/rack/handler/fastcgi.rb

@@ -19,16 +19,28 @@ module Rack
   module Handler
     class FastCGI
       def self.run(app, options={})
-        file = options[:File] and STDIN.reopen(UNIXServer.new(file))
-        port = options[:Port] and STDIN.reopen(TCPServer.new(port))
+        if options[:File]
+          STDIN.reopen(UNIXServer.new(options[:File]))
+        elsif options[:Port]
+          STDIN.reopen(TCPServer.new(options[:Host], options[:Port]))
+        end
         FCGI.each { |request|
           serve request, app
         }
       end
 
-      def self.serve(request, app)
-        app = Rack::ContentLength.new(app)
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+          "File=PATH" => "Creates a Domain socket at PATH instead of a TCP socket. Ignores Host and Port if set.",
+        }
+      end
 
+      def self.serve(request, app)
         env = request.env
         env.delete "HTTP_CONTENT_LENGTH"
 
@@ -36,7 +48,7 @@ module Rack
 
         rack_input = RewindableInput.new(request.in)
 
-        env.update({"rack.version" => [1,1],
+        env.update({"rack.version" => Rack::VERSION,
                      "rack.input" => rack_input,
                      "rack.errors" => request.err,
 
@@ -47,7 +59,7 @@ module Rack
                      "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
                    })
 
-        env["QUERY_STRING"] ||= ""
+        env[QUERY_STRING]   ||= ""
         env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
         env["REQUEST_PATH"] ||= "/"
         env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""

data/lib/rack/handler/lsws.rb

@@ -11,8 +11,6 @@ module Rack
         end
       end
       def self.serve(app)
-        app = Rack::ContentLength.new(app)
-
         env = ENV.to_hash
         env.delete "HTTP_CONTENT_LENGTH"
         env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"
@@ -20,7 +18,7 @@ module Rack
         rack_input = RewindableInput.new($stdin.read.to_s)
 
         env.update(
-          "rack.version" => [1,1],
+          "rack.version" => Rack::VERSION,
           "rack.input" => rack_input,
           "rack.errors" => $stderr,
           "rack.multithread" => false,
@@ -29,7 +27,7 @@ module Rack
           "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
         )
 
-        env["QUERY_STRING"] ||= ""
+        env[QUERY_STRING]   ||= ""
         env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
         env["REQUEST_PATH"] ||= "/"
         status, headers, body = app.call(env)

data/lib/rack/handler/mongrel.rb

@@ -7,8 +7,11 @@ module Rack
   module Handler
     class Mongrel < ::Mongrel::HttpHandler
       def self.run(app, options={})
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
         server = ::Mongrel::HttpServer.new(
-          options[:Host]           || '0.0.0.0',
+          options[:Host]           || default_host,
           options[:Port]           || 8080,
           options[:num_processors] || 950,
           options[:throttle]       || 0,
@@ -38,12 +41,25 @@ module Rack
         server.run.join
       end
 
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+          "Processors=N" => "Number of concurrent processors to accept (default: 950)",
+          "Timeout=N" => "Time before a request is dropped for inactivity (default: 60)",
+          "Throttle=N" => "Throttle time between socket.accept calls in hundredths of a second (default: 0)",
+        }
+      end
+
       def initialize(app)
-        @app = Rack::Chunked.new(Rack::ContentLength.new(app))
+        @app = app
       end
 
       def process(request, response)
-        env = {}.replace(request.params)
+        env = Hash[request.params]
         env.delete "HTTP_CONTENT_TYPE"
         env.delete "HTTP_CONTENT_LENGTH"
 
@@ -52,7 +68,7 @@ module Rack
         rack_input = request.body || StringIO.new('')
         rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
 
-        env.update({"rack.version" => [1,1],
+        env.update({"rack.version" => Rack::VERSION,
                      "rack.input" => rack_input,
                      "rack.errors" => $stderr,
 
@@ -60,9 +76,9 @@ module Rack
                      "rack.multiprocess" => false, # ???
                      "rack.run_once" => false,
 
-                     "rack.url_scheme" => "http",
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
                    })
-        env["QUERY_STRING"] ||= ""
+        env[QUERY_STRING] ||= ""
 
         status, headers, body = @app.call(env)
 

data/lib/rack/handler/scgi.rb

@@ -9,34 +9,42 @@ module Rack
       attr_accessor :app
 
       def self.run(app, options=nil)
+        options[:Socket] = UNIXServer.new(options[:File]) if options[:File]
         new(options.merge(:app=>app,
                           :host=>options[:Host],
                           :port=>options[:Port],
                           :socket=>options[:Socket])).listen
       end
 
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
+
       def initialize(settings = {})
-        @app = Rack::Chunked.new(Rack::ContentLength.new(settings[:app]))
-        @log = Object.new
-        def @log.info(*args); end
-        def @log.error(*args); end
+        @app = settings[:app]
         super(settings)
       end
 
       def process_request(request, input_body, socket)
-        env = {}.replace(request)
+        env = Hash[request]
         env.delete "HTTP_CONTENT_TYPE"
         env.delete "HTTP_CONTENT_LENGTH"
-        env["REQUEST_PATH"], env["QUERY_STRING"] = env["REQUEST_URI"].split('?', 2)
+        env["REQUEST_PATH"], env[QUERY_STRING] = env["REQUEST_URI"].split('?', 2)
         env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["PATH_INFO"] = env["REQUEST_PATH"]
+        env[PATH_INFO] = env["REQUEST_PATH"]
         env["QUERY_STRING"] ||= ""
         env["SCRIPT_NAME"] = ""
 
         rack_input = StringIO.new(input_body)
         rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
 
-        env.update({"rack.version" => [1,1],
+        env.update({"rack.version" => Rack::VERSION,
                      "rack.input" => rack_input,
                      "rack.errors" => $stderr,
                      "rack.multithread" => true,

data/lib/rack/handler/thin.rb

@@ -6,13 +6,28 @@ module Rack
   module Handler
     class Thin
       def self.run(app, options={})
-        app = Rack::Chunked.new(Rack::ContentLength.new(app))
-        server = ::Thin::Server.new(options[:Host] || '0.0.0.0',
-                                    options[:Port] || 8080,
-                                    app)
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        host = options.delete(:Host) || default_host
+        port = options.delete(:Port) || 8080
+        args = [host, port, app, options]
+        # Thin versions below 0.8.0 do not support additional options
+        args.pop if ::Thin::VERSION::MAJOR < 1 && ::Thin::VERSION::MINOR < 8
+        server = ::Thin::Server.new(*args)
         yield server if block_given?
         server.start
       end
+
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
     end
   end
 end

data/lib/rack/handler/webrick.rb

@@ -2,31 +2,67 @@ require 'webrick'
 require 'stringio'
 require 'rack/content_length'
 
+# This monkey patch allows for applications to perform their own chunking
+# through WEBrick::HTTPResponse iff rack is set to true.
+class WEBrick::HTTPResponse
+  attr_accessor :rack
+
+  alias _rack_setup_header setup_header
+  def setup_header
+    app_chunking = rack && @header['transfer-encoding'] == 'chunked'
+
+    @chunked = app_chunking if app_chunking
+
+    _rack_setup_header
+
+    @chunked = false if app_chunking
+  end
+end
+
 module Rack
   module Handler
     class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
       def self.run(app, options={})
-        options[:BindAddress] = options.delete(:Host) if options[:Host]
-        server = ::WEBrick::HTTPServer.new(options)
-        server.mount "/", Rack::Handler::WEBrick, app
-        trap(:INT) { server.shutdown }
-        yield server  if block_given?
-        server.start
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        options[:BindAddress] = options.delete(:Host) || default_host
+        options[:Port] ||= 8080
+        @server = ::WEBrick::HTTPServer.new(options)
+        @server.mount "/", Rack::Handler::WEBrick, app
+        yield @server  if block_given?
+        @server.start
+      end
+
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
+
+      def self.shutdown
+        @server.shutdown
+        @server = nil
       end
 
       def initialize(server, app)
         super server
-        @app = Rack::ContentLength.new(app)
+        @app = app
       end
 
       def service(req, res)
+        res.rack = true
         env = req.meta_vars
         env.delete_if { |k, v| v.nil? }
 
         rack_input = StringIO.new(req.body.to_s)
         rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
 
-        env.update({"rack.version" => [1,1],
+        env.update({"rack.version" => Rack::VERSION,
                      "rack.input" => rack_input,
                      "rack.errors" => $stderr,
 
@@ -34,32 +70,49 @@ module Rack
                      "rack.multiprocess" => false,
                      "rack.run_once" => false,
 
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http",
+
+                     "rack.hijack?" => true,
+                     "rack.hijack" => lambda { raise NotImplementedError, "only partial hijack is supported."},
+                     "rack.hijack_io" => nil,
                    })
 
         env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["QUERY_STRING"] ||= ""
-        env["REQUEST_PATH"] ||= "/"
-        unless env["PATH_INFO"] == ""
+        env[QUERY_STRING] ||= ""
+        unless env[PATH_INFO] == ""
           path, n = req.request_uri.path, env["SCRIPT_NAME"].length
-          env["PATH_INFO"] = path[n, path.length-n]
+          env[PATH_INFO] = path[n, path.length-n]
         end
+        env["REQUEST_PATH"] ||= [env["SCRIPT_NAME"], env[PATH_INFO]].join
 
         status, headers, body = @app.call(env)
         begin
           res.status = status.to_i
           headers.each { |k, vs|
+            next if k.downcase == "rack.hijack"
+
             if k.downcase == "set-cookie"
               res.cookies.concat vs.split("\n")
             else
-              vs.split("\n").each { |v|
-                res[k] = v
-              }
+              # Since WEBrick won't accept repeated headers,
+              # merge the values per RFC 1945 section 4.2.
+              res[k] = vs.split("\n").join(", ")
             end
           }
-          body.each { |part|
-            res.body << part
-          }
+
+          io_lambda = headers["rack.hijack"]
+          if io_lambda
+            rd, wr = IO.pipe
+            res.body = rd
+            res.chunked = true
+            io_lambda.call wr
+          elsif body.respond_to?(:to_path)
+            res.body = ::File.open(body.to_path, 'rb')
+          else
+            body.each { |part|
+              res.body << part
+            }
+          end
         ensure
           body.close  if body.respond_to? :close
         end

data/lib/rack/handler.rb

@@ -1,7 +1,7 @@
 module Rack
   # *Handlers* connect web servers with Rack.
   #
-  # Rack includes Handlers for Mongrel, WEBrick, FastCGI, CGI, SCGI
+  # Rack includes Handlers for Thin, WEBrick, FastCGI, CGI, SCGI
   # and LiteSpeed.
   #
   # Handlers usually are activated by calling <tt>MyHandler.run(myapp)</tt>.
@@ -12,14 +12,47 @@ module Rack
       return unless server
       server = server.to_s
 
+      unless @handlers.include? server
+        load_error = try_require('rack/handler', server)
+      end
+
       if klass = @handlers[server]
-        obj = Object
-        klass.split("::").each { |x| obj = obj.const_get(x) }
-        obj
+        klass.split("::").inject(Object) { |o, x| o.const_get(x) }
       else
-        try_require('rack/handler', server)
-        const_get(server)
+        _const_get(server, false)
       end
+
+    rescue NameError => name_error
+      raise load_error || name_error
+    end
+
+    begin
+      ::Object.const_get("Object", false)
+      def self._const_get(str, inherit = true)
+        const_get(str, inherit)
+      end
+    rescue
+      def self._const_get(str, inherit = true)
+        const_get(str)
+      end
+    end
+
+
+    # Select first available Rack handler given an `Array` of server names.
+    # Raises `LoadError` if no handler was found.
+    #
+    #   > pick ['thin', 'webrick']
+    #   => Rack::Handler::WEBrick
+    def self.pick(server_names)
+      server_names = Array(server_names)
+      server_names.each do |server_name|
+        begin
+          return get(server_name.to_s)
+        rescue LoadError, NameError
+        end
+      end
+
+      raise LoadError, "Couldn't find handler for: #{server_names.join(', ')}."
     end
 
     def self.default(options = {})
@@ -30,14 +63,12 @@ module Rack
         options.delete :Port
 
         Rack::Handler::FastCGI
-      elsif ENV.include?("REQUEST_METHOD")
+      elsif ENV.include?(REQUEST_METHOD)
         Rack::Handler::CGI
+      elsif ENV.include?("RACK_HANDLER")
+        self.get(ENV["RACK_HANDLER"])
       else
-        begin
-          Rack::Handler::Mongrel
-        rescue LoadError => e
-          Rack::Handler::WEBrick
-        end
+        pick ['thin', 'puma', 'webrick']
       end
     end
 
@@ -57,12 +88,14 @@ module Rack
         gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
 
       require(::File.join(prefix, file))
-    rescue LoadError
+      nil
+    rescue LoadError => error
+      error
     end
 
     def self.register(server, klass)
       @handlers ||= {}
-      @handlers[server] = klass
+      @handlers[server.to_s] = klass.to_s
     end
 
     autoload :CGI, "rack/handler/cgi"

data/lib/rack/head.rb

@@ -1,6 +1,10 @@
+require 'rack/body_proxy'
+
 module Rack
 
 class Head
+  # Rack::Head returns an empty body for all HEAD requests. It leaves
+  # all other requests unchanged.
   def initialize(app)
     @app = app
   end
@@ -8,8 +12,12 @@ class Head
   def call(env)
     status, headers, body = @app.call(env)
 
-    if env["REQUEST_METHOD"] == "HEAD"
-      [status, headers, []]
+    if env[REQUEST_METHOD] == HEAD
+      [
+        status, headers, Rack::BodyProxy.new([]) do
+          body.close if body.respond_to? :close
+        end
+      ]
     else
       [status, headers, body]
     end