rainbows 2.1.0 → 3.0.0

data/lib/rainbows/event_machine/response_pipe.rb

@@ -5,8 +5,8 @@ module Rainbows::EventMachine::ResponsePipe
   # so a single buffer for all clients will work safely
   BUF = ''
 
-  def initialize(client, alive, body)
-    @client, @alive, @body = client, alive, body
+  def initialize(client)
+    @client = client
   end
 
   def notify_readable
@@ -22,7 +22,6 @@ module Rainbows::EventMachine::ResponsePipe
   end
 
   def unbind
-    @body.close if @body.respond_to?(:close)
     @client.next!
     @io.close unless @io.closed?
   end

data/lib/rainbows/fiber/base.rb

@@ -19,7 +19,7 @@ module Rainbows::Fiber::Base
   # will cause it.
   def schedule(&block)
     begin
-      G.tick
+      Rainbows.tick
       t = schedule_sleepers
       ret = select(RD.compact.concat(LISTENERS), WR.compact, nil, t)
     rescue Errno::EINTR
@@ -56,16 +56,16 @@ module Rainbows::Fiber::Base
   end
 
   def process(client)
-    G.cur += 1
-    process_client(client)
+    Rainbows.cur += 1
+    client.process_loop
   ensure
-    G.cur -= 1
+    Rainbows.cur -= 1
     ZZ.delete(client.f)
   end
 
   def self.setup(klass, app)
     require 'rainbows/fiber/body'
-    klass.__send__(:include, Rainbows::Fiber::Body)
+    Rainbows::Client.__send__(:include, Rainbows::Fiber::Body)
     self.const_set(:APP, app)
   end
 end

data/lib/rainbows/fiber/body.rb

@@ -5,20 +5,15 @@
 # this is meant to be included _after_ Rainbows::Response::Body
 module Rainbows::Fiber::Body # :nodoc:
 
-  # TODO non-blocking splice(2) under Linux
-  ALIASES = {
-    :write_body_stream => :write_body_each
-  }
-
   # the sendfile 1.0.0+ gem includes IO#sendfile_nonblock
   if IO.method_defined?(:sendfile_nonblock)
-    def write_body_file(client, body, range)
-      sock, n, body = client.to_io, nil, body_to_io(body)
+    def write_body_file(body, range)
+      sock, n, body = to_io, nil, body_to_io(body)
       offset, count = range ? range : [ 0, body.stat.size ]
       begin
         offset += (n = sock.sendfile_nonblock(body, offset, count))
       rescue Errno::EAGAIN
-        client.kgio_wait_writable
+        kgio_wait_writable
         retry
       rescue EOFError
         break
@@ -26,13 +21,9 @@ module Rainbows::Fiber::Body # :nodoc:
       ensure
         close_if_private(body)
     end
-  else
-    ALIASES[:write_body] = :write_body_each
   end
 
   def self.included(klass)
-    ALIASES.each do |new_method, orig_method|
-      klass.__send__(:alias_method, new_method, orig_method)
-    end
+    klass.__send__ :alias_method, :write_body_stream, :write_body_each
   end
 end

data/lib/rainbows/fiber/coolio/heartbeat.rb

@@ -1,12 +1,10 @@
 # -*- encoding: binary -*-
 # :enddoc:
 class Rainbows::Fiber::Coolio::Heartbeat < Coolio::TimerWatcher
-  G = Rainbows::G
-
   # ZZ gets populated by read_expire in rainbows/fiber/io/methods
   ZZ = Rainbows::Fiber::ZZ
   def on_timer
-    exit if (! G.tick && G.cur <= 0)
+    exit if (! Rainbows.tick && Rainbows.cur <= 0)
     now = Time.now
     fibs = []
     ZZ.delete_if { |fib, time| now >= time ? fibs << fib : ! fib.alive? }

data/lib/rainbows/fiber/coolio/server.rb

@@ -1,9 +1,6 @@
 # -*- encoding: binary -*-
 # :enddoc:
 class Rainbows::Fiber::Coolio::Server < Coolio::IOWatcher
-  G = Rainbows::G
-  include Rainbows::ProcessClient
-
   def to_io
     @io
   end
@@ -19,14 +16,14 @@ class Rainbows::Fiber::Coolio::Server < Coolio::IOWatcher
   end
 
   def on_readable
-    return if G.cur >= MAX
+    return if Rainbows.cur >= MAX
     c = @io.kgio_tryaccept and Fiber.new { process(c) }.resume
   end
 
   def process(io)
-    G.cur += 1
-    process_client(io)
+    Rainbows.cur += 1
+    io.process_loop
   ensure
-    G.cur -= 1
+    Rainbows.cur -= 1
   end
 end

data/lib/rainbows/fiber_pool.rb

@@ -34,6 +34,6 @@ module Rainbows::FiberPool
       end
     rescue => e
       Rainbows::Error.listen_loop(e)
-    end while G.alive || G.cur > 0
+    end while Rainbows.cur_alive
   end
 end

data/lib/rainbows/fiber_spawn.rb

@@ -17,12 +17,12 @@ module Rainbows::FiberSpawn
 
     begin
       schedule do |l|
-        break if G.cur >= limit
+        break if Rainbows.cur >= limit
         io = l.kgio_tryaccept or next
         Fiber.new { process(io) }.resume
       end
     rescue => e
       Rainbows::Error.listen_loop(e)
-    end while G.alive || G.cur > 0
+    end while Rainbows.cur_alive
   end
 end

data/lib/rainbows/http_parser.rb

@@ -0,0 +1,12 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# avoid modifying Unicorn::HttpParser
+class Rainbows::HttpParser < Unicorn::HttpParser
+  def self.quit
+    alias_method :next?, :never!
+  end
+
+  def never!
+    false
+  end
+end

data/lib/rainbows/http_server.rb

@@ -2,14 +2,12 @@
 # :enddoc:
 
 class Rainbows::HttpServer < Unicorn::HttpServer
-  G = Rainbows::G
-
   def self.setup(block)
-    G.server.instance_eval(&block)
+    Rainbows.server.instance_eval(&block)
   end
 
   def initialize(app, options)
-    G.server = self
+    Rainbows.server = self
     @logger = Unicorn::Configurator::DEFAULTS[:logger]
     rv = super(app, options)
     defined?(@use) or use(:Base)
@@ -21,7 +19,7 @@ class Rainbows::HttpServer < Unicorn::HttpServer
     Unicorn::Util.reopen_logs
     logger.info "worker=#{worker_nr} done reopening logs"
     rescue
-      G.quit! # let the master reopen and refork us
+      Rainbows.quit! # let the master reopen and refork us
   end
 
   # Add one second to the timeout since our fchmod heartbeat is less
@@ -36,7 +34,7 @@ class Rainbows::HttpServer < Unicorn::HttpServer
 
   def load_config!
     use :Base
-    G.kato = 5
+    Rainbows.keepalive_timeout = 5
     Rainbows.max_bytes = 1024 * 1024
     @worker_connections = nil
     super
@@ -91,7 +89,7 @@ class Rainbows::HttpServer < Unicorn::HttpServer
   def keepalive_timeout(nr)
     (Integer === nr && nr >= 0) or
       raise ArgumentError, "keepalive_timeout must be a non-negative Integer"
-    G.kato = nr
+    Rainbows.keepalive_timeout = nr
   end
 
   def keepalive_requests(nr)

data/lib/rainbows/max_body.rb

@@ -52,7 +52,7 @@ class Rainbows::MaxBody
   # if it's reconfigured
   def self.setup # :nodoc:
     Rainbows.max_bytes or return
-    case Rainbows::G.server.use
+    case Rainbows.server.use
     when :Rev, :Coolio, :EventMachine, :NeverBlock,
          :RevThreadSpawn, :RevThreadPool,
          :CoolioThreadSpawn, :CoolioThreadPool
@@ -60,7 +60,7 @@ class Rainbows::MaxBody
     end
 
     # force ourselves to the outermost middleware layer
-    Rainbows::G.server.app = self.new(Rainbows::G.server.app)
+    Rainbows.server.app = self.new(Rainbows.server.app)
   end
 
   # Rack response returned when there's an error

data/lib/rainbows/never_block/core.rb

@@ -8,7 +8,7 @@ module Rainbows::NeverBlock::Core
     base = o[:backend].to_s.gsub!(/([a-z])([A-Z])/, '\1_\2').downcase!
     require "rainbows/never_block/#{base}"
     client_class = Rainbows::NeverBlock::Client
-    client_class.superclass.const_set(:APP, Rainbows::G.server.app)
+    client_class.superclass.const_set(:APP, Rainbows.server.app)
     client_class.const_set(:POOL, pool)
     logger.info "NeverBlock/#{o[:backend]} pool_size=#{o[:pool_size]}"
   end

data/lib/rainbows/process_client.rb

@@ -1,55 +1,41 @@
 # -*- encoding: binary -*-
-# :enddoc:
-require 'rainbows/rack_input'
 module Rainbows::ProcessClient
-  G = Rainbows::G
   include Rainbows::Response
-  HttpParser = Unicorn::HttpParser
   include Rainbows::RackInput
   include Rainbows::Const
 
-  # once a client is accepted, it is processed in its entirety here
-  # in 3 easy steps: read request, call app, write app response
-  # this is used by synchronous concurrency models
-  #   Base, ThreadSpawn, ThreadPool
-  def process_client(client) # :nodoc:
-    hp = HttpParser.new
-    client.kgio_read!(16384, buf = hp.buf)
-    remote_addr = client.kgio_addr
-    alive = false
+  def process_loop
+    @hp = hp = Rainbows::HttpParser.new
+    kgio_read!(16384, buf = hp.buf) or return
 
     begin # loop
       until env = hp.parse
-        client.timed_read(buf2 ||= "") or return
+        timed_read(buf2 ||= "") or return
         buf << buf2
       end
 
-      set_input(env, hp, client)
-      env[REMOTE_ADDR] = remote_addr
-      status, headers, body = APP.call(env.update(RACK_DEFAULTS))
+      set_input(env, hp)
+      env[REMOTE_ADDR] = kgio_addr
+      status, headers, body = APP.call(env.merge!(RACK_DEFAULTS))
 
       if 100 == status.to_i
-        client.write(EXPECT_100_RESPONSE)
+        write(EXPECT_100_RESPONSE)
         env.delete(HTTP_EXPECT)
         status, headers, body = APP.call(env)
       end
-
-      if hp.headers?
-        headers = HH.new(headers)
-        range = make_range!(env, status, headers) and status = range.shift
-        alive = hp.next? && G.alive
-        headers[CONNECTION] = alive ? KEEP_ALIVE : CLOSE
-        client.write(response_header(status, headers))
-      end
-      write_body(client, body, range)
+      write_response(status, headers, body, alive = @hp.next?)
     end while alive
   # if we get any error, try to write something back to the client
   # assuming we haven't closed the socket, but don't get hung up
   # if the socket is already closed or broken.  We'll always ensure
   # the socket is closed at the end of this function
   rescue => e
-    Rainbows::Error.write(client, e)
+    handle_error(e)
   ensure
-    client.close unless client.closed?
+    close unless closed?
+  end
+
+  def handle_error(e)
+    Rainbows::Error.write(self, e)
   end
 end

data/lib/rainbows/queue_pool.rb

@@ -6,8 +6,6 @@ require 'thread'
 # This is NOT used for the ThreadPool class, since that class does not
 # need a userspace Queue.
 class Rainbows::QueuePool < Struct.new(:queue, :threads)
-  G = Rainbows::G
-
   def initialize(size = 20, &block)
     q = Queue.new
     self.threads = (1..size).map do
@@ -23,7 +21,7 @@ class Rainbows::QueuePool < Struct.new(:queue, :threads)
   def quit!
     threads.each { |_| queue << nil }
     threads.delete_if do |t|
-      G.tick
+      Rainbows.tick
       t.alive? ? t.join(0.01) : true
     end until threads.empty?
   end

data/lib/rainbows/rack_input.rb

@@ -10,8 +10,8 @@ module Rainbows::RackInput
     const_set(:IC, Unicorn::HttpRequest.input_class)
   end
 
-  def set_input(env, hp, client)
-    env[RACK_INPUT] = 0 == hp.content_length ? NULL_IO : IC.new(client, hp)
-    env[CLIENT_IO] = client
+  def set_input(env, hp)
+    env[RACK_INPUT] = 0 == hp.content_length ? NULL_IO : IC.new(self, hp)
+    env[CLIENT_IO] = self
   end
 end

data/lib/rainbows/response.rb

@@ -1,59 +1,185 @@
 # -*- encoding: binary -*-
 # :enddoc:
-require 'time' # for Time#httpdate
-
 module Rainbows::Response
-  autoload :Body, 'rainbows/response/body'
-  autoload :Range, 'rainbows/response/range'
+  include Unicorn::HttpResponse
+  Close = "close"
+  KeepAlive = "keep-alive"
+  Content_Length = "Content-Length".freeze
+  Transfer_Encoding = "Transfer-Encoding".freeze
 
-  CODES = Unicorn::HttpResponse::CODES
-  CRLF = "\r\n"
+  # private file class for IO objects opened by Rainbows! itself (and not
+  # the app or middleware)
+  class F < File; end
 
-  # freeze headers we may set as hash keys for a small speedup
-  CONNECTION = "Connection".freeze
-  CLOSE = "close"
-  KEEP_ALIVE = "keep-alive"
-  HH = Rack::Utils::HeaderHash
+  # called after forking
+  def self.setup(klass)
+    Kgio.accept_class = Rainbows::Client
+    0 == Rainbows.keepalive_timeout and
+      Rainbows::HttpParser.keepalive_requests = 0
+  end
 
-  def response_header(status, headers)
+  def write_headers(status, headers, alive)
+    @hp.headers? or return
     status = CODES[status.to_i] || status
-    rv = "HTTP/1.1 #{status}\r\n" \
-         "Date: #{Time.now.httpdate}\r\n" \
-         "Status: #{status}\r\n"
+    buf = "HTTP/1.1 #{status}\r\n" \
+          "Date: #{httpdate}\r\n" \
+          "Status: #{status}\r\n" \
+          "Connection: #{alive ? KeepAlive : Close}\r\n"
     headers.each do |key, value|
-      next if %r{\A(?:X-Rainbows-|Date\z|Status\z)}i =~ key
+      next if %r{\A(?:X-Rainbows-|Date\z|Connection\z)}i =~ key
       if value =~ /\n/
         # avoiding blank, key-only cookies with /\n+/
-        rv << value.split(/\n+/).map! { |v| "#{key}: #{v}\r\n" }.join('')
+        buf << value.split(/\n+/).map! { |v| "#{key}: #{v}\r\n" }.join
       else
-        rv << "#{key}: #{value}\r\n"
+        buf << "#{key}: #{value}\r\n"
       end
     end
-    rv << CRLF
+    write(buf << CRLF)
   end
 
-  # called after forking
-  def self.setup(klass)
-    Rainbows::G.kato == 0 and KEEP_ALIVE.replace(CLOSE)
-    range_class = body_class = klass
-    case Rainbows::Const::RACK_DEFAULTS['rainbows.model']
-    when :WriterThreadSpawn
-      body_class = Rainbows::WriterThreadSpawn::Client
-      range_class = Rainbows::HttpServer
-    when :EventMachine, :NeverBlock
-      range_class = nil # :<
-    end
-    return if body_class.included_modules.include?(Body)
-    body_class.__send__(:include, Body)
-    sf = IO.respond_to?(:copy_stream) || IO.method_defined?(:sendfile_nonblock)
-    if range_class
-      range_class.__send__(:include, sf ? Range : NoRange)
+  def close_if_private(io)
+    io.close if F === io
+  end
+
+  def io_for_fd(fd)
+    Rainbows::FD_MAP.delete(fd) || F.for_fd(fd)
+  end
+
+  # to_io is not part of the Rack spec, but make an exception here
+  # since we can conserve path lookups and file descriptors.
+  # \Rainbows! will never get here without checking for the existence
+  # of body.to_path first.
+  def body_to_io(body)
+    if body.respond_to?(:to_io)
+      body.to_io
+    else
+      # try to take advantage of Rainbows::DevFdResponse, calling F.open
+      # is a last resort
+      path = body.to_path
+      %r{\A/dev/fd/(\d+)\z} =~ path ? io_for_fd($1.to_i) : F.open(path)
     end
   end
 
-  module NoRange
-    # dummy method if we can't send range responses
-    def make_range!(env, status, headers)
+  module Each
+    # generic body writer, used for most dynamically-generated responses
+    def write_body_each(body)
+      body.each { |chunk| write(chunk) }
+    end
+
+    # generic response writer, used for most dynamically-generated responses
+    # and also when IO.copy_stream and/or IO#sendfile_nonblock is unavailable
+    def write_response(status, headers, body, alive)
+      write_headers(status, headers, alive)
+      write_body_each(body)
+      ensure
+        body.close if body.respond_to?(:close)
     end
   end
+  include Each
+
+  if IO.method_defined?(:sendfile_nonblock)
+    module Sendfile
+      def write_body_file(body, range)
+        io = body_to_io(body)
+        range ? sendfile(io, range[0], range[1]) : sendfile(io, 0)
+        ensure
+          close_if_private(io)
+      end
+    end
+    include Sendfile
+  end
+
+  if IO.respond_to?(:copy_stream)
+    unless IO.method_defined?(:sendfile_nonblock)
+      module CopyStream
+        def write_body_file(body, range)
+          range ? IO.copy_stream(body, self, range[1], range[0]) :
+                  IO.copy_stream(body, self, nil, 0)
+        end
+      end
+      include CopyStream
+    end
+
+    # write_body_stream is an alias for write_body_each if IO.copy_stream
+    # isn't used or available.
+    def write_body_stream(body)
+      IO.copy_stream(io = body_to_io(body), self)
+      ensure
+        close_if_private(io)
+    end
+  else # ! IO.respond_to?(:copy_stream)
+    alias write_body_stream write_body_each
+  end  # ! IO.respond_to?(:copy_stream)
+
+  if IO.method_defined?(:sendfile_nonblock) || IO.respond_to?(:copy_stream)
+    HTTP_RANGE = 'HTTP_RANGE'
+    Content_Range = 'Content-Range'.freeze
+
+    # This does not support multipart responses (does anybody actually
+    # use those?)
+    def sendfile_range(status, headers)
+      200 == status.to_i &&
+      /\Abytes=(\d+-\d*|\d*-\d+)\z/ =~ @hp.env[HTTP_RANGE] or
+        return
+      a, b = $1.split(/-/)
+
+      # HeaderHash is quite expensive, and Rack::File currently
+      # uses a regular Ruby Hash with properly-cased headers the
+      # same way they're presented in rfc2616.
+      headers = Rack::Utils::HeaderHash.new(headers) unless Hash === headers
+      clen = headers[Content_Length] or return
+      size = clen.to_i
+
+      if b.nil? # bytes=M-
+        offset = a.to_i
+        count = size - offset
+      elsif a.empty? # bytes=-N
+        offset = size - b.to_i
+        count = size - offset
+      else  # bytes=M-N
+        offset = a.to_i
+        count = b.to_i + 1 - offset
+      end
+
+      if 0 > count || offset >= size
+        headers[Content_Length] = "0"
+        headers[Content_Range] = "bytes */#{clen}"
+        return 416, headers, nil
+      else
+        count = size if count > size
+        headers[Content_Length] = count.to_s
+        headers[Content_Range] = "bytes #{offset}-#{offset+count-1}/#{clen}"
+        return 206, headers, [ offset, count ]
+      end
+    end
+
+    def write_response_path(status, headers, body, alive)
+      if File.file?(body.to_path)
+        if r = sendfile_range(status, headers)
+          status, headers, range = r
+          write_headers(status, headers, alive)
+          write_body_file(body, range) if range
+        else
+          write_headers(status, headers, alive)
+          write_body_file(body, nil)
+        end
+      else
+        write_headers(status, headers, alive)
+        write_body_stream(body)
+      end
+      ensure
+        body.close if body.respond_to?(:close)
+    end
+
+    module ToPath
+      def write_response(status, headers, body, alive)
+        if body.respond_to?(:to_path)
+          write_response_path(status, headers, body, alive)
+        else
+          super
+        end
+      end
+    end
+    include ToPath
+  end # IO.respond_to?(:copy_stream) || IO.method_defined?(:sendfile_nonblock)
 end