rainbows 0.6.0 → 0.7.0

data/Summary

@@ -0,0 +1,7 @@
+= \Rainbows! at a glance
+
+Confused by all the options we give you?  So are we!  Here's some tables
+to help keep your head straight.  Remember, engineering is all about
+trade-offs.
+
+INCLUDE

data/TODO

@@ -7,15 +7,13 @@ care about.
   unit tests, only integration tests that exercise externally
   visible parts.
 
-* Rev + Thread - current Rev model with threading, which will give
-  us a streaming (but rewindable) "rack.input".
-
 * EventMachine.spawn - should be like Revactor, maybe?
 
-* Rev + callcc - current Rev model with callcc (should work with MBARI)
+* {Packet,Rev,EventMachine}+Fibers
 
-* Fiber support - Revactor already uses these with Ruby 1.9, also not
-  sure how TeeInput can be done with this.
+* {Packet,Rev}ThreadPool
+
+* Rev + callcc - current Rev model with callcc (should work with MBARI)
 
 * Omnibus - haven't looked into it, probably like Revactor with 1.8?
 

data/bin/rainbows

@@ -69,7 +69,7 @@ opts = OptionParser.new("", 24, '  ') do |opts|
   opts.on("-P", "--pid FILE", "DEPRECATED") do |f|
     warn %q{Use of --pid/-P is strongly discouraged}
     warn %q{Use the 'pid' directive in the Unicorn config file instead}
-    options[:pid] = File.expand_path(f)
+    options[:pid] = f
   end
 
   opts.on("-s", "--server SERVER",
@@ -86,7 +86,7 @@ opts = OptionParser.new("", 24, '  ') do |opts|
   end
 
   opts.on("-c", "--config-file FILE", "Unicorn-specific config file") do |f|
-    options[:config_file] = File.expand_path(f)
+    options[:config_file] = f
   end
 
   # I'm avoiding Unicorn-specific config options on the command-line.

data/lib/rainbows.rb

@@ -1,12 +1,14 @@
 # -*- encoding: binary -*-
 require 'unicorn'
+require 'rainbows/error'
+require 'fcntl'
 
 module Rainbows
 
   # global vars because class/instance variables are confusing me :<
   # this struct is only accessed inside workers and thus private to each
-  # G.cur may not be used the network concurrency model
-  class State < Struct.new(:alive,:m,:cur,:server,:tmp)
+  # G.cur may not be used in the network concurrency model
+  class State < Struct.new(:alive,:m,:cur,:kato,:server,:tmp)
     def tick
       tmp.chmod(self.m = m == 0 ? 1 : 0)
       alive && server.master_pid == Process.ppid or quit!
@@ -18,7 +20,8 @@ module Rainbows
       false
     end
   end
-  G = State.new(true, 0, 0)
+  G = State.new(true, 0, 0, 2)
+  O = {}
 
   require 'rainbows/const'
   require 'rainbows/http_server'
@@ -43,6 +46,7 @@ module Rainbows
   #   Rainbows! do
   #     use :Revactor # this may also be :ThreadSpawn or :ThreadPool
   #     worker_connections 400
+  #     keepalive_timeout 0 # zero disables keepalives entirely
   #   end
   #
   #   # the rest of the Unicorn configuration
@@ -53,6 +57,12 @@ module Rainbows
   # each of them.  The total number of clients we're able to serve is
   # +worker_processes+ * +worker_connections+, so in the above example
   # we can serve 8 * 400 = 3200 clients concurrently.
+  #
+  # The default is +keepalive_timeout+ is 2 seconds, which should be
+  # enough under most conditions for browsers to render the page and
+  # start retrieving extra elements for.  Increasing this beyond 5
+  # seconds is not recommended.  Zero disables keepalive entirely
+  # (but pipelining fully-formed requests is still works).
   def Rainbows!(&block)
     block_given? or raise ArgumentError, "Rainbows! requires a block"
     HttpServer.setup(block)
@@ -69,10 +79,30 @@ module Rainbows
     :Rev => 50,
     :RevThreadSpawn => 50,
     :EventMachine => 50,
+    :FiberSpawn => 50,
+    :FiberPool => 50,
+    :ActorSpawn => 50,
+    :NeverBlock => 50,
   }.each do |model, _|
     u = model.to_s.gsub(/([a-z0-9])([A-Z0-9])/) { "#{$1}_#{$2.downcase!}" }
     autoload model, "rainbows/#{u.downcase!}"
   end
+  autoload :Fiber, 'rainbows/fiber' # core class
+
+  # returns nil if accept fails
+  if defined?(Fcntl::FD_CLOEXEC)
+    def self.accept(sock)
+      rv = sock.accept_nonblock
+      rv.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      rv
+    rescue Errno::EAGAIN, Errno::ECONNABORTED
+    end
+  else
+    def self.accept(sock)
+      sock.accept_nonblock
+    rescue Errno::EAGAIN, Errno::ECONNABORTED
+    end
+  end
 
 end
 

data/lib/rainbows/actor_spawn.rb

@@ -0,0 +1,29 @@
+# -*- encoding: binary -*-
+
+require 'actor'
+module Rainbows
+
+  # Actor concurrency model for Rubinius.  We can't seem to get message
+  # passing working right, so we're throwing a Mutex into the mix for
+  # now.  Hopefully somebody can fix things for us.  Currently, this is
+  # exactly the same as the ThreadSpawn model since we don't use the
+  # message passing capabilities of the Actor model (and even then
+  # it wouldn't really make sense since Actors in Rubinius are just
+  # Threads underneath and our ThreadSpawn model is one layer of
+  # complexity less.
+  #
+  # This is different from the Revactor one which is not prone to race
+  # conditions within the same process at all (since it uses Fibers).
+  module ActorSpawn
+    include ThreadSpawn
+
+    # 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)
+      Const::RACK_DEFAULTS["rack.multithread"] = true # :(
+      init_worker_process(worker)
+      accept_loop(Actor)
+    end
+  end
+end

data/lib/rainbows/app_pool.rb

@@ -42,11 +42,8 @@ module Rainbows
   # AppPool has no effect on the Rev or EventMachine concurrency models
   # as those are single-threaded/single-instance as far as application
   # concurrency goes.  In other words, +P+ is always +one+ when using
-  # Rev or EventMachine.  AppPool currently only works with the
-  # ThreadSpawn and ThreadPool models.  It does not yet work reliably
-  # with the Revactor model, but actors are far more lightweight and
-  # probably better suited for lightweight applications that would
-  # not benefit from AppPool.
+  # Rev or EventMachine.  As of \Rainbows! 0.7.0, it is safe to use with
+  # Revactor and the new FiberSpawn and FiberPool concurrency models.
   #
   # Since this is Rack middleware, you may load this in your Rack
   # config.ru file and even use it in threaded servers other than
@@ -60,7 +57,7 @@ module Rainbows
   # You may to load this earlier or later in your middleware chain
   # depending on the concurrency/copy-friendliness of your middleware(s).
 
-  class AppPool < Struct.new(:pool)
+  class AppPool < Struct.new(:pool, :re)
 
     # +opt+ is a hash, +:size+ is the size of the pool (default: 6)
     # meaning you can have up to 6 concurrent instances of +app+
@@ -86,6 +83,20 @@ module Rainbows
 
     # Rack application endpoint, +env+ is the Rack environment
     def call(env)
+
+      # we have to do this check at call time (and not initialize)
+      # because of preload_app=true and models being changeable with SIGHUP
+      # fortunately this is safe for all the reentrant (but not multithreaded)
+      # classes that depend on it and a safe no-op for multithreaded
+      # concurrency models
+      self.re ||= begin
+        case env["rainbows.model"]
+        when :FiberSpawn, :FiberPool, :Revactor, :NeverBlock
+          self.pool = Rainbows::Fiber::Queue.new(pool)
+        end
+        true
+      end
+
       app = pool.shift
       app.call(env)
       ensure

data/lib/rainbows/base.rb

@@ -10,10 +10,9 @@ module Rainbows
     include Rainbows::Const
     G = Rainbows::G
 
-    def listen_loop_error(e)
-      G.alive or return
-      logger.error "Unhandled listen loop exception #{e.inspect}."
-      logger.error e.backtrace.join("\n")
+    def handle_error(client, e)
+      msg = Error.response(e) and client.write_nonblock(msg)
+      rescue
     end
 
     def init_worker_process(worker)
@@ -32,7 +31,7 @@ module Rainbows
     # 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)
-      buf = client.readpartial(CHUNK_SIZE)
+      buf = client.readpartial(CHUNK_SIZE) # accept filters protect us here
       hp = HttpParser.new
       env = {}
       alive = true
@@ -40,6 +39,7 @@ module Rainbows
 
       begin # loop
         while ! hp.headers(env, buf)
+          IO.select([client], nil, nil, G.kato) or return
           buf << client.readpartial(CHUNK_SIZE)
         end
 
@@ -59,25 +59,22 @@ module Rainbows
         out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if hp.headers?
         HttpResponse.write(client, response, out)
       end while alive and hp.reset.nil? and env.clear
-      client.close
     # 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
       handle_error(client, e)
+    ensure
+      client.close
     end
 
     def join_threads(threads)
-      G.quit!
       expire = Time.now + (timeout * 2.0)
-      until (threads.delete_if { |thr| ! thr.alive? }).empty?
-        threads.each { |thr|
-          G.tick
-          thr.join(1)
-          break if Time.now >= expire
-        }
+      until threads.empty? || Time.now >= expire
+        threads.delete_if { |thr| thr.alive? ? thr.join(0.01) : true }
       end
+      exit!(0) unless threads.empty?
     end
 
     def self.included(klass)

data/lib/rainbows/const.rb

@@ -3,7 +3,7 @@
 module Rainbows
 
   module Const
-    RAINBOWS_VERSION = '0.6.0'
+    RAINBOWS_VERSION = '0.7.0'
 
     include Unicorn::Const
 

data/lib/rainbows/dev_fd_response.rb

@@ -36,6 +36,12 @@ module Rainbows
         else
           headers['X-Rainbows-Autochunk'] = 'no'
         end
+
+        # we need to make sure our pipe output is Fiber-compatible
+        case env["rainbows.model"]
+        when :FiberSpawn, :FiberPool
+          return [ status, headers.to_hash, Fiber::IO.new(io,::Fiber.current) ]
+        end
       else # unlikely, char/block device file, directory, ...
         return response
       end

data/lib/rainbows/error.rb

@@ -0,0 +1,34 @@
+# -*- encoding: binary -*-
+module Rainbows
+
+  class Error
+    class << self
+
+      def app(e)
+        G.server.logger.error "app error: #{e.inspect}"
+        G.server.logger.error e.backtrace.join("\n")
+        rescue
+      end
+
+      def listen_loop(e)
+        G.alive or return
+        G.server.logger.error "listen loop error: #{e.inspect}."
+        G.server.logger.error e.backtrace.join("\n")
+        rescue
+      end
+
+      def response(e)
+        case e
+        when EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
+          # swallow error if client shuts down one end or disconnects
+        when Unicorn::HttpParserError
+          Const::ERROR_400_RESPONSE # try to tell the client they're bad
+        else
+          app(e)
+          Const::ERROR_500_RESPONSE
+        end
+      end
+
+    end
+  end
+end

data/lib/rainbows/ev_core.rb

@@ -26,17 +26,7 @@ module Rainbows
     end
 
     def handle_error(e)
-      msg = case e
-      when EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
-        ERROR_500_RESPONSE
-      when HttpParserError # try to tell the client they're bad
-        ERROR_400_RESPONSE
-      else
-        G.server.logger.error "Read error: #{e.inspect}"
-        G.server.logger.error e.backtrace.join("\n")
-        ERROR_500_RESPONSE
-      end
-      write(msg)
+      msg = Error.response(e) and write(msg)
       ensure
         quit
     end
@@ -74,11 +64,12 @@ module Rainbows
         end
       when :trailers
         if @hp.trailers(@env, @buf << data)
+          @input.rewind
           app_call
           @input.close if File === @input
         end
       end
-      rescue Object => e
+      rescue => e
         handle_error(e)
     end
 

data/lib/rainbows/event_machine.rb

@@ -51,8 +51,9 @@ module Rainbows
       end
 
       def app_call
+        set_comm_inactivity_timeout 0
         begin
-          (@env[RACK_INPUT] = @input).rewind
+          @env[RACK_INPUT] = @input
           @env[REMOTE_ADDR] = @remote_addr
           @env[ASYNC_CALLBACK] = method(:response_write)
 
@@ -73,6 +74,7 @@ module Rainbows
             @state = :headers
             # keepalive requests are always body-less, so @input is unchanged
             @hp.headers(@env, @buf) and next
+            set_comm_inactivity_timeout G.kato
           end
           return
         end while true
@@ -172,12 +174,9 @@ module Rainbows
 
       def notify_readable
         return if CUR.size >= MAX
-        begin
-          io = @io.accept_nonblock
-          sig = EM.attach_fd(io.fileno, false)
-          CUR[sig] = Client.new(sig, io)
-        rescue Errno::EAGAIN, Errno::ECONNABORTED
-        end
+        io = Rainbows.accept(@io) or return
+        sig = EM.attach_fd(io.fileno, false)
+        CUR[sig] = Client.new(sig, io)
       end
     end
 
@@ -191,8 +190,7 @@ module Rainbows
       EM.epoll
       EM.kqueue
       logger.info "EventMachine: epoll=#{EM.epoll?} kqueue=#{EM.kqueue?}"
-      Server.const_set(:MAX, G.server.worker_connections +
-                             HttpServer::LISTENERS.size)
+      Server.const_set(:MAX, worker_connections + LISTENERS.size)
       EvCore.setup(Client)
       EM.run {
         conns = EM.instance_variable_get(:@conns) or

data/lib/rainbows/fiber.rb

@@ -0,0 +1,15 @@
+# -*- encoding: binary -*-
+begin
+  require 'fiber'
+rescue LoadError
+  defined?(NeverBlock) or raise
+end
+
+module Rainbows
+
+  # core module for all things that use Fibers in Rainbows!
+  module Fiber
+    autoload :Base, 'rainbows/fiber/base'
+    autoload :Queue, 'rainbows/fiber/queue'
+  end
+end

data/lib/rainbows/fiber/base.rb

@@ -0,0 +1,112 @@
+# -*- encoding: binary -*-
+require 'rainbows/fiber/io'
+
+module Rainbows
+  module Fiber
+
+    # blocked readers (key: Rainbows::Fiber::IO object, value is irrelevant)
+    RD = {}
+
+    # blocked writers (key: Rainbows::Fiber::IO object, value is irrelevant)
+    WR = {}
+
+    # sleeping fibers go here (key: Fiber object, value: wakeup time)
+    ZZ = {}
+
+    # puts the current Fiber into uninterruptible sleep for at least
+    # +seconds+.  Unlike Kernel#sleep, this it is not possible to sleep
+    # indefinitely to be woken up (nobody wants that in a web server,
+    # right?).
+    def self.sleep(seconds)
+      ZZ[::Fiber.current] = Time.now + seconds
+      ::Fiber.yield
+    end
+
+    # base module used by FiberSpawn and FiberPool
+    module Base
+      include Rainbows::Base
+
+      # the scheduler method that powers both FiberSpawn and FiberPool
+      # concurrency models.  It times out idle clients and attempts to
+      # schedules ones that were blocked on I/O.  At most it'll sleep
+      # for one second (returned by the schedule_sleepers method) which
+      # will cause it.
+      def schedule(&block)
+        ret = begin
+          G.tick
+          RD.keys.each { |c| c.f.resume } # attempt to time out idle clients
+          t = schedule_sleepers
+          Kernel.select(RD.keys.concat(LISTENERS), WR.keys, nil, t) or return
+        rescue Errno::EINTR
+          retry
+        rescue Errno::EBADF, TypeError
+          LISTENERS.compact!
+          raise
+        end or return
+
+        # active writers first, then _all_ readers for keepalive timeout
+        ret[1].concat(RD.keys).each { |c| c.f.resume }
+
+        # accept is an expensive syscall, filter out listeners we don't want
+        (ret.first & LISTENERS).each(&block)
+      end
+
+      # wakes up any sleepers that need to be woken and
+      # returns an interval to IO.select on
+      def schedule_sleepers
+        max = nil
+        now = Time.now
+        ZZ.delete_if { |fib, time|
+          if now >= time
+            fib.resume
+            now = Time.now
+          else
+            max = time
+            false
+          end
+        }
+        max.nil? || max > (now + 1) ? 1 : max - now
+      end
+
+      def process_client(client)
+        G.cur += 1
+        io = client.to_io
+        buf = client.read_timeout or return
+        hp = HttpParser.new
+        env = {}
+        alive = true
+        remote_addr = TCPSocket === io ? io.peeraddr.last : LOCALHOST
+
+        begin # loop
+          while ! hp.headers(env, buf)
+            buf << (client.read_timeout or return)
+          end
+
+          env[RACK_INPUT] = 0 == hp.content_length ?
+                    HttpRequest::NULL_IO : TeeInput.new(client, env, hp, buf)
+          env[REMOTE_ADDR] = remote_addr
+          response = APP.call(env.update(RACK_DEFAULTS))
+
+          if 100 == response.first.to_i
+            client.write(EXPECT_100_RESPONSE)
+            env.delete(HTTP_EXPECT)
+            response = APP.call(env)
+          end
+
+          alive = hp.keepalive? && G.alive
+          out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if hp.headers?
+          HttpResponse.write(client, response, out)
+        end while alive and hp.reset.nil? and env.clear
+      rescue => e
+        handle_error(io, e)
+      ensure
+        G.cur -= 1
+        RD.delete(client)
+        WR.delete(client)
+        ZZ.delete(client.f)
+        io.close unless io.closed?
+      end
+
+    end
+  end
+end