rack 1.0.1 → 2.2.21

data/lib/rack/handler/webrick.rb

@@ -1,67 +1,125 @@
+# frozen_string_literal: true
+
 require 'webrick'
 require 'stringio'
-require 'rack/content_length'
+
+# This monkey patch allows for applications to perform their own chunking
+# through WEBrick::HTTPResponse if 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
+      def self.run(app, **options)
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : nil
+
+        if !options[:BindAddress] || options[:Host]
+          options[:BindAddress] = options.delete(:Host) || default_host
+        end
+        options[:Port] ||= 8080
+        if options[:SSLEnable]
+          require 'webrick/https'
+        end
+
+        @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
+        if @server
+          @server.shutdown
+          @server = nil
+        end
       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,0],
-                     "rack.input" => rack_input,
-                     "rack.errors" => $stderr,
-
-                     "rack.multithread" => true,
-                     "rack.multiprocess" => false,
-                     "rack.run_once" => false,
-
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
-                   })
-
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["QUERY_STRING"] ||= ""
-        env["REQUEST_PATH"] ||= "/"
-        if env["PATH_INFO"] == ""
-          env.delete "PATH_INFO"
-        else
-          path, n = req.request_uri.path, env["SCRIPT_NAME"].length
-          env["PATH_INFO"] = path[n, path.length-n]
+        rack_input.set_encoding(Encoding::BINARY)
+
+        env.update(
+          RACK_VERSION      => Rack::VERSION,
+          RACK_INPUT        => rack_input,
+          RACK_ERRORS       => $stderr,
+          RACK_MULTITHREAD  => true,
+          RACK_MULTIPROCESS => false,
+          RACK_RUNONCE      => false,
+          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http",
+          RACK_IS_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] ||= ""
+        unless env[PATH_INFO] == ""
+          path, n = req.request_uri.path, env[SCRIPT_NAME].length
+          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
+          io_lambda = nil
           headers.each { |k, vs|
-            if k.downcase == "set-cookie"
+            if k == RACK_HIJACK
+              io_lambda = vs
+            elsif 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
-          }
+
+          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,9 @@
+# frozen_string_literal: true
+
 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,13 +14,50 @@ 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
+        const_get(klass)
+      else
+        const_get(server, false)
+      end
+
+    rescue NameError => name_error
+      raise load_error || name_error
+    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
+
+    SERVER_NAMES = %w(puma thin falcon webrick).freeze
+    private_constant :SERVER_NAMES
+
+    def self.default
+      # Guess.
+      if ENV.include?("PHP_FCGI_CHILDREN")
+        Rack::Handler::FastCGI
+      elsif ENV.include?(REQUEST_METHOD)
+        Rack::Handler::CGI
+      elsif ENV.include?("RACK_HANDLER")
+        self.get(ENV["RACK_HANDLER"])
       else
-        try_require('rack/handler', server)
-        const_get(server)
+        pick SERVER_NAMES
       end
     end
 
@@ -38,19 +77,18 @@ 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"
     autoload :FastCGI, "rack/handler/fastcgi"
-    autoload :Mongrel, "rack/handler/mongrel"
-    autoload :EventedMongrel, "rack/handler/evented_mongrel"
-    autoload :SwiftipliedMongrel, "rack/handler/swiftiplied_mongrel"
     autoload :WEBrick, "rack/handler/webrick"
     autoload :LSWS, "rack/handler/lsws"
     autoload :SCGI, "rack/handler/scgi"
@@ -58,9 +96,6 @@ module Rack
 
     register 'cgi', 'Rack::Handler::CGI'
     register 'fastcgi', 'Rack::Handler::FastCGI'
-    register 'mongrel', 'Rack::Handler::Mongrel'
-    register 'emongrel', 'Rack::Handler::EventedMongrel'
-    register 'smongrel', 'Rack::Handler::SwiftipliedMongrel'
     register 'webrick', 'Rack::Handler::WEBrick'
     register 'lsws', 'Rack::Handler::LSWS'
     register 'scgi', 'Rack::Handler::SCGI'

data/lib/rack/head.rb

@@ -1,19 +1,25 @@
-module Rack
+# frozen_string_literal: true
 
-class Head
-  def initialize(app)
-    @app = app
-  end
+module Rack
+  # Rack::Head returns an empty body for all HEAD requests. It leaves
+  # all other requests unchanged.
+  class Head
+    def initialize(app)
+      @app = app
+    end
 
-  def call(env)
-    status, headers, body = @app.call(env)
+    def call(env)
+      status, headers, body = @app.call(env)
 
-    if env["REQUEST_METHOD"] == "HEAD"
-      [status, headers, []]
-    else
-      [status, headers, body]
+      if env[REQUEST_METHOD] == HEAD
+        [
+          status, headers, Rack::BodyProxy.new([]) do
+            body.close if body.respond_to? :close
+          end
+        ]
+      else
+        [status, headers, body]
+      end
     end
   end
 end
-
-end