rainbows 2.1.0 → 3.0.0

data/lib/rainbows/revactor.rb

@@ -19,77 +19,17 @@ Revactor::VERSION >= '0.1.5' or abort 'revactor 0.1.5 is required'
 # \Revactor library as well, to take advantage of the networking
 # concurrency features this model provides.
 module Rainbows::Revactor
-
-  # :stopdoc:
-  RD_ARGS = {}
-
+  autoload :Client, 'rainbows/revactor/client'
   autoload :Proxy, 'rainbows/revactor/proxy'
-  autoload :TeeSocket, 'rainbows/revactor/tee_socket'
 
   include Rainbows::Base
-  LOCALHOST = Kgio::LOCALHOST
-  TCP = Revactor::TCP::Socket
-
-  # once a client is accepted, it is processed in its entirety here
-  # in 3 easy steps: read request, call app, write app response
-  def process_client(client) # :nodoc:
-    io = client.instance_variable_get(:@_io)
-    io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-    rd_args = [ nil ]
-    remote_addr = if TCP === client
-      rd_args << RD_ARGS
-      client.remote_addr
-    else
-      LOCALHOST
-    end
-    hp = Unicorn::HttpParser.new
-    buf = hp.buf
-    alive = false
-
-    begin
-      ts = nil
-      until env = hp.parse
-        buf << client.read(*rd_args)
-      end
-
-      env[CLIENT_IO] = client
-      env[RACK_INPUT] = 0 == hp.content_length ?
-               NULL_IO : IC.new(ts = TeeSocket.new(client), hp)
-      env[REMOTE_ADDR] = remote_addr
-      status, headers, body = app.call(env.update(RACK_DEFAULTS))
-
-      if 100 == status.to_i
-        client.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 && G.kato > 0
-        headers[CONNECTION] = alive ? KEEP_ALIVE : CLOSE
-        client.write(response_header(status, headers))
-        alive && ts and buf << ts.leftover
-      end
-      write_body(client, body, range)
-    end while alive
-  rescue Revactor::TCP::ReadError
-  rescue => e
-    Rainbows::Error.write(io, e)
-  ensure
-    client.close
-  end
 
   # runs inside each forked worker, this sits around and waits
   # for connections and doesn't die until the parent dies (or is
   # given a INT, QUIT, or TERM signal)
   def worker_loop(worker) #:nodoc:
+    Client.setup
     init_worker_process(worker)
-    require 'rainbows/revactor/body'
-    self.class.__send__(:include, Rainbows::Revactor::Body)
-    self.class.const_set(:IC, Unicorn::HttpRequest.input_class)
-    RD_ARGS[:timeout] = G.kato if G.kato > 0
     nr = 0
     limit = worker_connections
     actor_exit = Case[:exit, Actor, Object]
@@ -115,12 +55,12 @@ module Rainbows::Revactor
             f.when(actor_exit) { nr -= 1 }
             f.when(accept) do |_, _, s|
               nr += 1
-              Actor.spawn_link(s) { |c| process_client(c) }
+              Actor.spawn_link(s) { |c| Client.new(c).process_loop }
             end
           end
         rescue => e
           Rainbows::Error.listen_loop(e)
-        end while G.alive
+        end while Rainbows.alive
         Actor.receive do |f|
           f.when(close) {}
           f.when(actor_exit) { nr -= 1 }
@@ -128,7 +68,7 @@ module Rainbows::Revactor
       end
     end
 
-    Actor.sleep 1 while G.tick || nr > 0
+    Actor.sleep 1 while Rainbows.tick || nr > 0
     rescue Errno::EMFILE
       # ignore, let another worker process take it
   end

data/lib/rainbows/revactor/client.rb

@@ -0,0 +1,60 @@
+# -*- encoding: binary -*-
+# :enddoc:
+require 'fcntl'
+class Rainbows::Revactor::Client
+  autoload :TeeSocket, 'rainbows/revactor/client/tee_socket'
+  RD_ARGS = {}
+  Rainbows.keepalive_timeout > 0 and
+    RD_ARGS[:timeout] = Rainbows.keepalive_timeout
+  attr_reader :kgio_addr
+
+  def initialize(client)
+    @client, @rd_args, @ts = client, [ nil ], nil
+    io = client.instance_variable_get(:@_io)
+    io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+    @kgio_addr = if Revactor::TCP::Socket === client
+      @rd_args << RD_ARGS
+      client.remote_addr
+    else
+      Kgio::LOCALHOST
+    end
+  end
+
+  def kgio_read!(nr, buf)
+    buf.replace(@client.read)
+  end
+
+  def write(buf)
+    @client.write(buf)
+  end
+
+  def write_nonblock(buf) # only used for errors
+    @client.instance_variable_get(:@_io).write_nonblock(buf)
+  end
+
+  def timed_read(buf2)
+    buf2.replace(@client.read(*@rd_args))
+  end
+
+  def set_input(env, hp)
+    env[RACK_INPUT] = 0 == hp.content_length ?
+                      NULL_IO : IC.new(@ts = TeeSocket.new(@client), hp)
+    env[CLIENT_IO] = @client
+  end
+
+  def close
+    @client.close
+    @client = nil
+  end
+
+  def closed?
+    @client.nil?
+  end
+
+  def self.setup
+    self.const_set(:IC, Unicorn::HttpRequest.input_class)
+    include Rainbows::ProcessClient
+    include Methods
+  end
+end
+require 'rainbows/revactor/client/methods'

data/lib/rainbows/revactor/{body.rb → client/methods.rb}

@@ -1,15 +1,10 @@
 # -*- encoding: binary -*-
 # :enddoc:
-module Rainbows::Revactor::Body
-  # TODO non-blocking splice(2) under Linux
-  ALIASES = {
-    :write_body_stream => :write_body_each
-  }
-
+module Rainbows::Revactor::Client::Methods
   if IO.method_defined?(:sendfile_nonblock)
-    def write_body_file(client, body, range)
-      body = body_to_io(body)
-      sock = client.instance_variable_get(:@_io)
+    def write_body_file(body, range)
+      body, client = body_to_io(body), @client
+      sock = @client.instance_variable_get(:@_io)
       pfx = Revactor::TCP::Socket === client ? :tcp : :unix
       write_complete = T[:"#{pfx}_write_complete", client]
       closed = T[:"#{pfx}_closed", client]
@@ -33,13 +28,18 @@ module Rainbows::Revactor::Body
       ensure
         close_if_private(body)
     end
-  else
-    ALIASES[:write_body] = :write_body_each
+  end
+
+  def handle_error(e)
+    Revactor::TCP::ReadError === e or super
+  end
+
+  def write_response(status, headers, body, alive)
+    super(status, headers, body, alive)
+    alive && @ts and @hp.buf << @ts.leftover
   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/revactor/{tee_socket.rb → client/tee_socket.rb}

@@ -5,7 +5,7 @@
 # enough to avoid mucking with TeeInput internals.  Fortunately
 # this code is not heavily used so we can usually avoid the overhead
 # of adding a userspace buffer.
-class Rainbows::Revactor::TeeSocket
+class Rainbows::Revactor::Client::TeeSocket
   def initialize(socket)
     # IO::Buffer is used internally by Rev which Revactor is based on
     # so we'll always have it available

data/lib/rainbows/sendfile.rb

@@ -72,13 +72,12 @@ class Rainbows::Sendfile < Struct.new(:app)
   end
 
   # :stopdoc:
-  HH = Rack::Utils::HeaderHash
   X_SENDFILE = 'X-Sendfile'
   # :startdoc:
 
   def call(env) # :nodoc:
     status, headers, body = app.call(env)
-    headers = HH.new(headers)
+    headers = Rack::Utils::HeaderHash.new(headers) unless Hash === headers
     if path = headers.delete(X_SENDFILE)
       body = Body.new(path, headers) unless body.respond_to?(:to_path)
     end

data/lib/rainbows/server_token.rb

@@ -30,7 +30,7 @@ class ServerToken < Struct.new(:app, :token)
 
   def call(env)
     status, headers, body = app.call(env)
-    headers = Rack::Utils::HeaderHash.new(headers)
+    headers = Rack::Utils::HeaderHash.new(headers) unless Hash === headers
     headers[SERVER] = token
     [ status, headers, body ]
   end

data/lib/rainbows/thread_pool.rb

@@ -28,11 +28,11 @@ module Rainbows::ThreadPool
       Thread.new { LISTENERS.size == 1 ? sync_worker : async_worker }
     end
 
-    while G.alive
+    while Rainbows.alive
       # if any worker dies, something is serious wrong, bail
       pool.each do |thr|
-        G.tick or break
-        thr.join(1) and G.quit!
+        Rainbows.tick or break
+        thr.join(1) and Rainbows.quit!
       end
     end
     join_threads(pool)
@@ -41,10 +41,10 @@ module Rainbows::ThreadPool
   def sync_worker # :nodoc:
     s = LISTENERS[0]
     begin
-      c = s.kgio_accept and process_client(c)
+      c = s.kgio_accept and c.process_loop
     rescue => e
       Rainbows::Error.listen_loop(e)
-    end while G.alive
+    end while Rainbows.alive
   end
 
   def async_worker # :nodoc:
@@ -55,18 +55,18 @@ module Rainbows::ThreadPool
       # problem.  On the other hand, a thundering herd may not
       # even incur as much overhead as an extra Mutex#synchronize
       ret = select(LISTENERS) and ret[0].each do |s|
-        s = s.kgio_tryaccept and process_client(s)
+        s = s.kgio_tryaccept and s.process_loop
       end
     rescue Errno::EINTR
     rescue => e
       Rainbows::Error.listen_loop(e)
-    end while G.alive
+    end while Rainbows.alive
   end
 
   def join_threads(threads) # :nodoc:
-    G.quit!
+    Rainbows.quit!
     threads.delete_if do |thr|
-      G.tick
+      Rainbows.tick
       begin
         thr.run
         thr.join(0.01)

data/lib/rainbows/thread_spawn.rb

@@ -22,27 +22,28 @@ module Rainbows::ThreadSpawn
   def accept_loop(klass) #:nodoc:
     lock = Mutex.new
     limit = worker_connections
+    nr = 0
     LISTENERS.each do |l|
       klass.new(l) do |l|
         begin
-          if lock.synchronize { G.cur >= limit }
+          if lock.synchronize { nr >= limit }
             worker_yield
           elsif c = l.kgio_accept
             klass.new(c) do |c|
               begin
-                lock.synchronize { G.cur += 1 }
-                process_client(c)
+                lock.synchronize { nr += 1 }
+                c.process_loop
               ensure
-                lock.synchronize { G.cur -= 1 }
+                lock.synchronize { nr -= 1 }
               end
             end
           end
         rescue => e
           Rainbows::Error.listen_loop(e)
-        end while G.alive
+        end while Rainbows.alive
       end
     end
-    sleep 1 while G.tick || lock.synchronize { G.cur > 0 }
+    sleep 1 while Rainbows.tick || lock.synchronize { nr > 0 }
   end
 
   def worker_loop(worker) #:nodoc:

data/lib/rainbows/thread_timeout.rb

@@ -47,7 +47,7 @@ class Rainbows::ThreadTimeout
       @threshold == 0 and
         raise ArgumentError, "threshold=0 does not make sense"
       @threshold < 0 and
-        @threshold += Rainbows::G.server.worker_connections
+        @threshold += Rainbows.server.worker_connections
     end
     @app = app
     @active = {}

data/lib/rainbows/writer_thread_pool.rb

@@ -19,30 +19,14 @@
 module Rainbows::WriterThreadPool
   # :stopdoc:
   include Rainbows::Base
+  autoload :Client, 'rainbows/writer_thread_pool/client'
 
   @@nr = 0
   @@q = nil
 
-  def async_write_body(qclient, body, range)
-    if body.respond_to?(:close)
-      Rainbows::SyncClose.new(body) do |body|
-        qclient.q << [ qclient.to_io, :body, body, range ]
-      end
-    else
-      qclient.q << [ qclient.to_io, :body, body, range ]
-    end
-  end
-
   def process_client(client) # :nodoc:
     @@nr += 1
-    super(Client.new(client, @@q[@@nr %= @@q.size]))
-  end
-
-  def init_worker_process(worker)
-    super
-    self.class.__send__(:alias_method, :sync_write_body, :write_body)
-    Rainbows::WriterThreadPool.__send__(
-                        :alias_method, :write_body, :async_write_body)
+    Client.new(client, @@q[@@nr %= @@q.size]).process_loop
   end
 
   def worker_loop(worker) # :nodoc:
@@ -51,12 +35,14 @@ module Rainbows::WriterThreadPool
     qp = (1..worker_connections).map do |n|
       Rainbows::QueuePool.new(1) do |response|
         begin
-          io, arg1, arg2, arg3 = response
-          case arg1
-          when :body then sync_write_body(io, arg2, arg3)
-          when :close then io.close unless io.closed?
+          io, arg, *rest = response
+          case arg
+          when String
+            io.kgio_write(arg)
+          when :close
+            io.close unless io.closed?
           else
-            io.write(arg1)
+            io.__send__(arg, *rest)
           end
         rescue => err
           Rainbows::Error.write(io, err)
@@ -70,5 +56,3 @@ module Rainbows::WriterThreadPool
   end
   # :startdoc:
 end
-# :enddoc:
-require 'rainbows/writer_thread_pool/client'

data/lib/rainbows/writer_thread_pool/client.rb

@@ -4,6 +4,49 @@
 # this is compatible with IO.select
 class Rainbows::WriterThreadPool::Client < Struct.new(:to_io, :q)
   include Rainbows::SocketProxy
+  include Rainbows::ProcessClient
+
+  module Methods
+    def write_body_each(body)
+      q << [ to_io, :write_body_each, body ]
+    end
+
+    def write_response_close(status, headers, body, alive)
+      to_io.instance_variable_set(:@hp, @hp) # XXX ugh
+      Rainbows::SyncClose.new(body) { |sync_body|
+        q << [ to_io, :write_response, status, headers, sync_body, alive ]
+      }
+    end
+
+    if IO.respond_to?(:copy_stream) || IO.method_defined?(:sendfile_nonblock)
+      def write_response(status, headers, body, alive)
+        if body.respond_to?(:close)
+          write_response_close(status, headers, body, alive)
+        elsif body.respond_to?(:to_path)
+          write_response_path(status, headers, body, alive)
+        else
+          super
+        end
+      end
+
+      def write_body_file(body, range)
+        q << [ to_io, :write_body_file, body, range ]
+      end
+
+      def write_body_stream(body)
+        q << [ to_io, :write_body_stream, body ]
+      end
+    else # each-only body response
+      def write_response(status, headers, body, alive)
+        if body.respond_to?(:close)
+          write_response_close(status, headers, body, alive)
+        else
+          super
+        end
+      end
+    end # each-only body response
+  end # module Methods
+  include Methods
 
   def write(buf)
     q << [ to_io, buf ]
@@ -14,6 +57,6 @@ class Rainbows::WriterThreadPool::Client < Struct.new(:to_io, :q)
   end
 
   def closed?
-    false
+    to_io.closed?
   end
 end