rainbows 0.1.0

data/lib/rainbows/http_response.rb

@@ -0,0 +1,35 @@
+# -*- encoding: binary -*-
+require 'time'
+require 'rainbows'
+
+module Rainbows
+
+  class HttpResponse < ::Unicorn::HttpResponse
+
+    def self.write(socket, rack_response, out = [])
+      status, headers, body = rack_response
+
+      if Array === out
+        status = CODES[status.to_i] || status
+
+        headers.each do |key, value|
+          next if SKIP.include?(key.downcase)
+          if value =~ /\n/
+            out.concat(value.split(/\n/).map! { |v| "#{key}: #{v}\r\n" })
+          else
+            out << "#{key}: #{value}\r\n"
+          end
+        end
+
+        socket.write("HTTP/1.1 #{status}\r\n" \
+                     "Date: #{Time.now.httpdate}\r\n" \
+                     "Status: #{status}\r\n" \
+                     "#{out.join('')}\r\n")
+      end
+
+      body.each { |chunk| socket.write(chunk) }
+      ensure
+        body.respond_to?(:close) and body.close rescue nil
+    end
+  end
+end

data/lib/rainbows/http_server.rb

@@ -0,0 +1,47 @@
+# -*- encoding: binary -*-
+require 'rainbows'
+module Rainbows
+
+  class HttpServer < ::Unicorn::HttpServer
+    include Rainbows
+
+    @@instance = nil
+
+    class << self
+      def setup(block)
+        @@instance.instance_eval(&block)
+      end
+    end
+
+    def initialize(app, options)
+      @@instance = self
+      rv = super(app, options)
+      defined?(@use) or use(:Base)
+      @worker_connections ||= MODEL_WORKER_CONNECTIONS[@use]
+    end
+
+    def use(*args)
+      model = args.shift or return @use
+      mod = begin
+        Rainbows.const_get(model)
+      rescue NameError
+        raise ArgumentError, "concurrency model #{model.inspect} not supported"
+      end
+
+      Module === mod or
+        raise ArgumentError, "concurrency model #{model.inspect} not supported"
+      extend(mod)
+      @use = model
+    end
+
+    def worker_connections(*args)
+      return @worker_connections if args.empty?
+      nr = args.first
+      (Integer === nr && nr > 0) or
+        raise ArgumentError, "worker_connections must be a positive Integer"
+      @worker_connections = nr
+    end
+
+  end
+
+end

data/lib/rainbows/revactor.rb

@@ -0,0 +1,158 @@
+# -*- encoding: binary -*-
+require 'revactor'
+
+# workaround revactor 0.1.4 still using the old Rev::Buffer
+# ref: http://rubyforge.org/pipermail/revactor-talk/2009-October/000034.html
+defined?(Rev::Buffer) or Rev::Buffer = IO::Buffer
+
+module Rainbows
+
+  # Enables use of the Actor model through
+  # {Revactor}[http://revactor.org] under Ruby 1.9.  It spawns one
+  # long-lived Actor for every listen socket in the process and spawns a
+  # new Actor for every client connection accept()-ed.
+  # +worker_connections+ will limit the number of client Actors we have
+  # running at any one time.
+  #
+  # Applications using this model are required to be reentrant, but
+  # generally do not have to worry about race conditions.  Multiple
+  # instances of the same app may run in the same address space
+  # sequentially (but at interleaved points).  Any network dependencies
+  # in the application using this model should be implemented using the
+  # \Revactor library as well.
+
+  module Revactor
+    require 'rainbows/revactor/tee_input'
+
+    include Base
+
+    # 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.read or return # this probably does not happen...
+      hp = HttpParser.new
+      env = {}
+      remote_addr = ::Revactor::TCP::Socket === client ?
+                    client.remote_addr : LOCALHOST
+
+      begin
+        while ! hp.headers(env, buf)
+          buf << client.read
+        end
+
+        env[Const::RACK_INPUT] = 0 == hp.content_length ?
+                 HttpRequest::NULL_IO :
+                 Rainbows::Revactor::TeeInput.new(client, env, hp, buf)
+        env[Const::REMOTE_ADDR] = remote_addr
+        response = app.call(env.update(RACK_DEFAULTS))
+
+        if 100 == response.first.to_i
+          client.write(Const::EXPECT_100_RESPONSE)
+          env.delete(Const::HTTP_EXPECT)
+          response = app.call(env)
+        end
+
+        out = [ hp.keepalive? ? CONN_ALIVE : CONN_CLOSE ] if hp.headers?
+        HttpResponse.write(client, response, out)
+      end while hp.keepalive? 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 EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
+      emergency_response(client, Const::ERROR_500_RESPONSE)
+    rescue HttpParserError # try to tell the client they're bad
+      buf.empty? or emergency_response(client, Const::ERROR_400_RESPONSE)
+    rescue Object => e
+      emergency_response(client, Const::ERROR_500_RESPONSE)
+      logger.error "Read error: #{e.inspect}"
+      logger.error e.backtrace.join("\n")
+    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)
+      ppid = master_pid
+      init_worker_process(worker)
+      alive = worker.tmp # tmp is our lifeline to the master process
+
+      trap(:USR1) { reopen_worker_logs(worker.nr) }
+      trap(:QUIT) { alive = false; LISTENERS.each { |s| s.close rescue nil } }
+      [:TERM, :INT].each { |sig| trap(sig) { exit!(0) } } # instant shutdown
+
+      root = Actor.current
+      root.trap_exit = true
+
+      limit = worker_connections
+      listeners = revactorize_listeners
+      logger.info "worker=#{worker.nr} ready with Revactor"
+      clients = 0
+
+      listeners.map! do |s|
+        Actor.spawn(s) do |l|
+          begin
+            while clients >= limit
+              logger.info "busy: clients=#{clients} >= limit=#{limit}"
+              Actor.receive { |filter| filter.when(:resume) {} }
+            end
+            actor = Actor.spawn(l.accept) { |c| process_client(c) }
+            clients += 1
+            root.link(actor)
+          rescue Errno::EAGAIN, Errno::ECONNABORTED
+          rescue Object => e
+            if alive
+              logger.error "Unhandled listen loop exception #{e.inspect}."
+              logger.error e.backtrace.join("\n")
+            end
+          end while alive
+        end
+      end
+
+      nr = 0
+      begin
+        Actor.receive do |filter|
+          filter.after(1) do
+            if alive
+              alive.chmod(nr = 0 == nr ? 1 : 0)
+              listeners.each { |l| alive = false if l.dead? }
+              ppid == Process.ppid or alive = false
+            end
+          end
+          filter.when(Case[:exit, Actor, Object]) do |_,actor,_|
+            orig = clients
+            clients -= 1
+            orig >= limit and listeners.each { |l| l << :resume }
+          end
+        end
+      end while alive || clients > 0
+    end
+
+  private
+
+    # write a response without caring if it went out or not
+    # This is in the case of untrappable errors
+    def emergency_response(client, response_str)
+      client.instance_eval do
+        # this is Revactor implementation dependent
+        @_io.write_nonblock(response_str) rescue nil
+      end
+      client.close rescue nil
+    end
+
+    def revactorize_listeners
+      LISTENERS.map do |s|
+        if TCPServer === s
+          ::Revactor::TCP.listen(s, nil)
+        elsif defined?(::Revactor::UNIX) && UNIXServer === s
+          ::Revactor::UNIX.listen(s)
+        else
+          logger.error "your version of Revactor can't handle #{s.inspect}"
+          nil
+        end
+      end.compact
+    end
+
+  end
+end

data/lib/rainbows/revactor/tee_input.rb

@@ -0,0 +1,44 @@
+# -*- encoding: binary -*-
+require 'rainbows/revactor'
+
+module Rainbows
+  module Revactor
+
+    # acts like tee(1) on an input input to provide a input-like stream
+    # while providing rewindable semantics through a File/StringIO
+    # backing store.  On the first pass, the input is only read on demand
+    # so your Rack application can use input notification (upload progress
+    # and like).  This should fully conform to the Rack::InputWrapper
+    # specification on the public API.  This class is intended to be a
+    # strict interpretation of Rack::InputWrapper functionality and will
+    # not support any deviations from it.
+    class TeeInput < ::Unicorn::TeeInput
+
+    private
+
+      # tees off a +length+ chunk of data from the input into the IO
+      # backing store as well as returning it.  +dst+ must be specified.
+      # returns nil if reading from the input returns nil
+      def tee(length, dst)
+        unless parser.body_eof?
+          begin
+            if parser.filter_body(dst, buf << socket.read).nil?
+              @tmp.write(dst)
+              return dst
+            end
+          rescue EOFError
+          end
+        end
+        finalize_input
+      end
+
+      def finalize_input
+        while parser.trailers(req, buf).nil?
+          buf << socket.read
+        end
+        self.socket = nil
+      end
+
+    end
+  end
+end

data/lib/rainbows/thread_pool.rb

@@ -0,0 +1,96 @@
+# -*- encoding: binary -*-
+
+module Rainbows
+
+  # Implements a worker thread pool model.  This is suited for platforms
+  # where the cost of dynamically spawning a new thread for every new
+  # client connection is too high.
+  #
+  # Applications using this model are required to be thread-safe.
+  # Threads are never spawned dynamically under this model.  If you're
+  # connecting to external services and need to perform DNS lookups,
+  # consider using the "resolv-replace" library which replaces parts of
+  # the core Socket package with concurrent DNS lookup capabilities.
+  #
+  # This model is less suited for many slow clients than the others and
+  # thus a lower +worker_connections+ setting is recommended.
+  module ThreadPool
+
+    include Base
+
+    def worker_loop(worker)
+      init_worker_process(worker)
+      threads = ThreadGroup.new
+      alive = worker.tmp
+      nr = 0
+
+      # closing anything we IO.select on will raise EBADF
+      trap(:USR1) { reopen_worker_logs(worker.nr) rescue nil }
+      trap(:QUIT) { alive = false; LISTENERS.map! { |s| s.close rescue nil } }
+      [:TERM, :INT].each { |sig| trap(sig) { exit(0) } } # instant shutdown
+      logger.info "worker=#{worker.nr} ready with ThreadPool"
+
+      while alive && master_pid == Process.ppid
+        maintain_thread_count(threads)
+        threads.list.each do |thr|
+          alive.chmod(nr += 1)
+          thr.join(timeout / 2.0) and break
+        end
+      end
+      join_worker_threads(threads)
+    end
+
+    def join_worker_threads(threads)
+      logger.info "Joining worker threads..."
+      t0 = Time.now
+      timeleft = timeout
+      threads.list.each { |thr|
+        thr.join(timeleft)
+        timeleft -= (Time.now - t0)
+      }
+      logger.info "Done joining worker threads."
+    end
+
+    def maintain_thread_count(threads)
+      threads.list.each do |thr|
+        next if (Time.now - (thr[:t] || next)) < timeout
+        thr.kill
+        logger.error "killed #{thr.inspect} for being too old"
+      end
+
+      while threads.list.size < worker_connections
+        threads.add(new_worker_thread)
+      end
+    end
+
+    def new_worker_thread
+      Thread.new {
+        alive = true
+        thr = Thread.current
+        begin
+          ret = begin
+            thr[:t] = Time.now
+            IO.select(LISTENERS, nil, nil, timeout/2.0) or next
+          rescue Errno::EINTR
+            retry
+          rescue Errno::EBADF
+            return
+          end
+          ret.first.each do |sock|
+            begin
+              process_client(sock.accept_nonblock)
+              thr[:t] = Time.now
+            rescue Errno::EAGAIN, Errno::ECONNABORTED
+            end
+          end
+        rescue Object => e
+          if alive
+            logger.error "Unhandled listen loop exception #{e.inspect}."
+            logger.error e.backtrace.join("\n")
+          end
+        end while alive = LISTENERS.first
+      }
+    end
+
+  end
+end

data/lib/rainbows/thread_spawn.rb

@@ -0,0 +1,79 @@
+# -*- encoding: binary -*-
+module Rainbows
+
+  # Spawns a new thread for every client connection we accept().  This
+  # model is recommended for platforms where spawning threads is
+  # inexpensive.
+  #
+  # If you're connecting to external services and need to perform DNS
+  # lookups, consider using the "resolv-replace" library which replaces
+  # parts of the core Socket package with concurrent DNS lookup
+  # capabilities
+  module ThreadSpawn
+
+    include Base
+
+    def worker_loop(worker)
+      init_worker_process(worker)
+      threads = ThreadGroup.new
+      alive = worker.tmp
+      nr = 0
+      limit = worker_connections
+
+      # closing anything we IO.select on will raise EBADF
+      trap(:USR1) { reopen_worker_logs(worker.nr) rescue nil }
+      trap(:QUIT) { alive = false; LISTENERS.map! { |s| s.close rescue nil } }
+      [:TERM, :INT].each { |sig| trap(sig) { exit(0) } } # instant shutdown
+      logger.info "worker=#{worker.nr} ready with ThreadSpawn"
+
+      while alive && master_pid == Process.ppid
+        ret = begin
+          IO.select(LISTENERS, nil, nil, timeout/2.0) or next
+        rescue Errno::EINTR
+          retry
+        rescue Errno::EBADF
+          alive = false
+        end
+
+        ret.first.each do |l|
+          while threads.list.size >= limit
+            nuke_old_thread(threads)
+          end
+          c = begin
+            l.accept_nonblock
+          rescue Errno::EINTR, Errno::ECONNABORTED
+            next
+          end
+          threads.add(Thread.new(c) { |c|
+            Thread.current[:t] = Time.now
+            process_client(c)
+          })
+        end
+      end
+      join_spawned_threads(threads)
+    end
+
+    def nuke_old_thread(threads)
+      threads.list.each do |thr|
+        next if (Time.now - (thr[:t] || next)) < timeout
+        thr.kill
+        logger.error "killed #{thr.inspect} for being too old"
+        return
+      end
+      # nothing to kill, yield to another thread
+      Thread.pass
+    end
+
+    def join_spawned_threads(threads)
+      logger.info "Joining spawned threads..."
+      t0 = Time.now
+      timeleft = timeout
+      threads.list.each { |thr|
+        thr.join(timeleft)
+        timeleft -= (Time.now - t0)
+      }
+      logger.info "Done joining spawned threads."
+    end
+
+  end
+end