rainbows 0.94.0 → 0.95.0

data/GIT-VERSION-FILE

@@ -1 +1 @@
-GIT_VERSION = 0.94.0
+GIT_VERSION = 0.95.0

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v0.94.0.GIT
+DEF_VER=v0.95.0.GIT
 
 LF='
 '

data/GNUmakefile

@@ -1,5 +1,6 @@
 # use GNU Make to run tests in parallel, and without depending on RubyGems
 all::
+MRI = ruby
 RUBY = ruby
 RAKE = rake
 RSYNC = rsync
@@ -15,6 +16,7 @@ endif
 ifeq ($(RUBY_VERSION),)
   RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
 endif
+RUBY_ENGINE := $(shell $(RUBY) -e 'puts((RUBY_ENGINE rescue "ruby"))')
 
 base_bins := rainbows
 bins := $(addprefix bin/, $(base_bins))
@@ -60,7 +62,7 @@ NEWS: GIT-VERSION-FILE
 	$(RAKE) -s news_rdoc > $@+
 	mv $@+ $@
 
-SINCE = 0.92.0
+SINCE = 0.94.0
 ChangeLog: LOG_VERSION = \
   $(shell git rev-parse -q "$(GIT_VERSION)" >/dev/null 2>&1 && \
           echo $(GIT_VERSION) || git describe)
@@ -91,16 +93,16 @@ doc: .document NEWS ChangeLog
 		< $${i}_1.html > tmp && mv tmp $${i}_1.html; \
 	  ln $${i}_1.html $${i}.1.html; \
 	  done
-	$(RUBY) -i -p -e \
+	$(MRI) -i -p -e \
 	  '$$_.gsub!("</title>",%q{\&$(call atom,$(cgit_atom))})' \
 	  doc/ChangeLog.html
-	$(RUBY) -i -p -e \
+	$(MRI) -i -p -e \
 	  '$$_.gsub!("</title>",%q{\&$(call atom,$(news_atom))})' \
 	  doc/NEWS.html doc/README.html
 	$(RAKE) -s news_atom > doc/NEWS.atom.xml
 	cd doc && ln README.html tmp && mv tmp index.html
 	$(MAKE) -C Documentation comparison.html
-	$(RUBY) -i -p -e \
+	$(MRI) -i -p -e \
 	  '$$_.gsub!(/INCLUDE/){File.read("Documentation/comparison.html")}' \
 	  doc/Summary.html
 	cat Documentation/comparison.css >> doc/rdoc.css

data/NEWS

@@ -1,3 +1,21 @@
+=== 0.95.0 / 2010-07-10 08:45 UTC
+
+  In addition to the 1.9-only IO.copy_stream, the new sendfile
+  1.0.0 gem may optionally be used with most concurrency models
+  (even under 1.8).
+
+  See http://rainbows.rubyforge.org/Static_Files.html for more info
+
+  Other changes:
+
+  * 1.9 encoding bugfix for (Rev)FiberSpawn and FiberPool
+  * fixed potential rack.input corruption with Revactor
+  * ThreadPool graceful shutdown no longer blocks until timeout
+  * optional ServerToken middleware for to display Server: header
+  * Dependencies bumped to Rack 1.1+ and Unicorn 1.1.0+
+  * numerous internal cleanups, small bugfixes and speedups
+  * more concise website oriented at users
+
 === 0.94.0 / 2010-06-04 08:42 UTC
 
   This release fixes corrupted large response bodies for Ruby 1.8

data/README

@@ -2,9 +2,17 @@
 
 \Rainbows! is an HTTP server for sleepy Rack applications.  It is based on
 Unicorn, but designed to handle applications that expect long
-request/response times and/or slow clients.  For Rack applications not
-heavily bound by slow external network dependencies, consider Unicorn
-instead as it simpler and easier to debug.
+request/response times and/or slow clients.
+
+For Rack applications not heavily bound by slow external network
+dependencies, consider Unicorn instead as it simpler and easier to
+debug.
+
+If you're on a small system, or write extremely tight and reliable code
+and don't want multiple worker processes, check out
+{Zbatery}[http://zbatery.bogomip.org/], too. Zbatery can use all the
+crazy network concurrency options of \Rainbows! in a single worker
+process.
 
 == \Rainbows! is about Diversity
 
@@ -125,8 +133,8 @@ config file:
       worker_connections 100
     end
 
-See the {Rainbows! configuration}[link:Rainbows.html#method-i-Rainbows!]
-{documentation}[link:Rainbows.html#method-i-Rainbows!]
+See the {Rainbows! configuration}[link:Rainbows/Configurator.html]
+{documentation}[link:Rainbows/Configurator.html]
 for more details.
 
 == Development

data/Static_Files

@@ -0,0 +1,71 @@
+= Static file serving with \Rainbows!
+
+While Ruby application servers aren't traditionally used to serve static
+files, it'll be fun for us to see how far we can go with \Rainbows!
+
+We aren't delusional enough (yet :) to compete with C-based servers like
+nginx or lighttpd in terms of raw performance, but wouldn't it be nice
+to simplify your deployments and only deploy one server?
+
+== {sendfile}[http://rubygems.org/gems/sendfile] RubyGem
+
+To enable the "sendfile" gem, just make sure you have 1.0.0 or later and
+"require" it in your Rainbows!/Unicorn config file (not your Rack
+config.ru):
+
+    require 'sendfile' # that's it! nothing else to do
+
+    # the rest of you Rainbows! config goes below:
+    worker_processes 4
+    stderr_path "/var/log/app/rainbows.err.log"
+    Rainbows! do
+      use :RevFiberSpawn
+      worker_connections 100
+    end
+
+The sendfile gem is works for all of our concurrency models except
+Revactor, NeverBlock and EventMachine (see below).
+
+The sendfile gem is less buggy than current (Ruby 1.9.2-rc1)
+IO.copy_stream and supports FreeBSD and Solaris in addition to Linux.
+This RubyGem also works under Ruby 1.8 (even with threads) and should
+work with rubinius.git, too.
+
+\Rainbows! supports the sendfile gem since v0.95.0
+
+== IO.copy_stream (Ruby 1.9 only)
+
+Users of pure-Ruby Thread-based models ThreadPool, ThreadSpawn, and
+their Writer* variants use the core IO.copy_stream method under Ruby
+1.9.  IO.copy_stream uses sendfile() under Linux, and a pread()/write()
+loop (implemented in C) on other systems.
+
+IO.copy_stream under Linux with Ruby 1.9.2-rc1 (and before) is also
+subject to hanging indefinitely when a client disconnected prematurely.
+This issue is fixed in Ruby trunk (July 2010) and will be in the next
+Ruby 1.9.2 release.
+
+\Rainbows! supports IO.copy_stream since v0.93.0
+
+== EventMachine FileStreamer
+
+EventMachine and NeverBlock users automatically take advantage of
+the mmap()-based FileStreamer class distributed with EventMachine.
+
+\Rainbows! supports EventMachine FileStreamer since v0.4.0
+
+== Performance
+
+With large files and high-throughput clients, there should be little
+performance difference compared to optimal C implementation such as
+nginx and lighttpd.  Ruby runtime overhead matters more when serving
+slower clients and smaller files.
+
+== The Future...
+
+Future releases of \Rainbows! will have byte-range support to serve
+partial and multipart responses, too.  We'll also support an open file
+cache (similar to nginx) which allows us to reuse open file descriptors.
+
+Under Linux, we'll support the splice(2) system call for zero-copy
+proxying {io_splice}[http://bogomips.org/ruby_io_splice/], too.

data/TODO

@@ -3,9 +3,21 @@
 We're lazy and pick the easy items to do first, then the ones people
 care about.
 
+* documentation improvements
+
 * Split out NeverBlock into NeverBlockEventMachine and NeverBlockReactor
   NeverBlock will default to one of them (depending on NB upstream).
 
+* allow _OPTIONAL_ splice(2) with DevFdResponse under Linux
+  (splice is very broken under some older kernels)
+
+* use IO#sendfile_nonblock for EventMachine/Revactor/NeverBlock
+
+* Open file cache Rack app/middleware (idea from nginx), since sendfile
+  (and IO.copy_stream) allows pread(2)-style offsets
+
+* Byte range responses for static files + sendfile
+
 * Improve test suite coverage.  We won't waste cycles with puny
   unit tests, only integration tests that exercise externally
   visible parts.

data/Test_Suite

@@ -12,7 +12,7 @@ easily portable to non-Ruby web servers.
 == Requirements
 
 * {Ruby 1.8 or 1.9}[http://www.ruby-lang.org/] (duh!)
-* {isolate ~> 2.0.2}[http://github.com/jbarnette/isolate] - for dependencies
+* {isolate ~> 2.1.0}[http://github.com/jbarnette/isolate] - for dependencies
 * {GNU make}[http://www.gnu.org/software/make/]
 * {socat}[http://www.dest-unreach.org/socat/]
 * {curl >= 7.18.0}[http://curl.haxx.se/]

data/bin/rainbows

@@ -110,10 +110,7 @@ opts = OptionParser.new("", 24, '  ') do |opts|
   opts.parse! ARGV
 end
 
-config = ARGV[0] || "config.ru"
-abort "configuration file #{config} not found" unless File.exist?(config)
-
-app = Unicorn.builder(config, opts)
+app = Unicorn.builder(ARGV[0] || 'config.ru', opts)
 listeners << "#{host}:#{port}" if set_listener
 
 if $DEBUG

data/lib/rainbows/actor_spawn.rb

@@ -20,7 +20,7 @@ module Rainbows
     # 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)
+    def worker_loop(worker) # :nodoc:
       Const::RACK_DEFAULTS["rack.multithread"] = true # :(
       init_worker_process(worker)
       accept_loop(Actor)

data/lib/rainbows/app_pool.rb

@@ -82,7 +82,7 @@ module Rainbows
     end
 
     # Rack application endpoint, +env+ is the Rack environment
-    def call(env)
+    def call(env) # :nodoc:
 
       # we have to do this check at call time (and not initialize)
       # because of preload_app=true and models being changeable with SIGHUP

data/lib/rainbows/base.rb

@@ -1,106 +1,96 @@
 # -*- encoding: binary -*-
+require 'rainbows/tee_input'
 
-module Rainbows
+# base class for Rainbows concurrency models, this is currently used by
+# ThreadSpawn and ThreadPool models.  Base is also its own
+# (non-)concurrency model which is basically Unicorn-with-keepalive, and
+# not intended for production use, as keepalive with a pure prefork
+# concurrency model is extremely expensive.
+module Rainbows::Base
 
-  # base class for Rainbows concurrency models, this is currently
-  # used by ThreadSpawn and ThreadPool models
-  module Base
+  # :stopdoc:
+  include Rainbows::Const
+  include Rainbows::Response
 
-    include Unicorn
-    include Rainbows::Const
-    G = Rainbows::G
+  # shortcuts...
+  G = Rainbows::G
+  NULL_IO = Unicorn::HttpRequest::NULL_IO
+  TeeInput = Rainbows::TeeInput
+  HttpParser = Unicorn::HttpParser
 
-    def init_worker_process(worker)
-      super(worker)
-      MaxBody.setup
-      G.tmp = worker.tmp
+  # this method is called by all current concurrency models
+  def init_worker_process(worker) # :nodoc:
+    super(worker)
+    Rainbows::Response.setup(self.class)
+    Rainbows::MaxBody.setup
+    G.tmp = worker.tmp
 
-      # avoid spurious wakeups and blocking-accept() with 1.8 green threads
-      if RUBY_VERSION.to_f < 1.9
-        require "io/nonblock"
-        HttpServer::LISTENERS.each { |l| l.nonblock = true }
-      end
-
-      # we're don't use the self-pipe mechanism in the Rainbows! worker
-      # since we don't defer reopening logs
-      HttpServer::SELF_PIPE.each { |x| x.close }.clear
-      trap(:USR1) { reopen_worker_logs(worker.nr) }
-      trap(:QUIT) { G.quit! }
-      [:TERM, :INT].each { |sig| trap(sig) { exit!(0) } } # instant shutdown
-      logger.info "Rainbows! #@use worker_connections=#@worker_connections"
+    # avoid spurious wakeups and blocking-accept() with 1.8 green threads
+    if ! defined?(RUBY_ENGINE) && RUBY_VERSION.to_f < 1.9
+      require "io/nonblock"
+      Rainbows::HttpServer::LISTENERS.each { |l| l.nonblock = true }
     end
 
-    if IO.respond_to?(:copy_stream)
-      def write_body(client, body)
-        if body.respond_to?(:to_path)
-          io = body.respond_to?(:to_io) ? body.to_io : body.to_path
-          IO.copy_stream(io, client)
-        else
-          body.each { |chunk| client.write(chunk) }
-        end
-        ensure
-          body.respond_to?(:close) and body.close
-      end
-    else
-      def write_body(client, body)
-        body.each { |chunk| client.write(chunk) }
-        ensure
-          body.respond_to?(:close) and body.close
-      end
-    end
-
-    module_function :write_body
+    # we're don't use the self-pipe mechanism in the Rainbows! worker
+    # since we don't defer reopening logs
+    Rainbows::HttpServer::SELF_PIPE.each { |x| x.close }.clear
+    trap(:USR1) { reopen_worker_logs(worker.nr) }
+    trap(:QUIT) { G.quit! }
+    [:TERM, :INT].each { |sig| trap(sig) { exit!(0) } } # instant shutdown
+    logger.info "Rainbows! #@use worker_connections=#@worker_connections"
+  end
 
-    # 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)
-      buf = client.readpartial(CHUNK_SIZE) # accept filters protect us here
-      hp = HttpParser.new
-      env = {}
-      alive = true
-      remote_addr = Rainbows.addr(client)
+  def wait_headers_readable(client)  # :nodoc:
+    IO.select([client], nil, nil, G.kato)
+  end
 
-      begin # loop
-        while ! hp.headers(env, buf)
-          IO.select([client], nil, nil, G.kato) or return
-          buf << client.readpartial(CHUNK_SIZE)
-        end
+  # 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:
+    buf = client.readpartial(CHUNK_SIZE) # accept filters protect us here
+    hp = HttpParser.new
+    env = {}
+    alive = true
+    remote_addr = Rainbows.addr(client)
 
-        env[CLIENT_IO] = client
-        env[RACK_INPUT] = 0 == hp.content_length ?
-                 HttpRequest::NULL_IO : TeeInput.new(client, env, hp, buf)
-        env[REMOTE_ADDR] = remote_addr
-        status, headers, body = app.call(env.update(RACK_DEFAULTS))
+    begin # loop
+      until hp.headers(env, buf)
+        wait_headers_readable(client) or return
+        buf << client.readpartial(CHUNK_SIZE)
+      end
 
-        if 100 == status.to_i
-          client.write(EXPECT_100_RESPONSE)
-          env.delete(HTTP_EXPECT)
-          status, headers, body = app.call(env)
-        end
+      env[CLIENT_IO] = client
+      env[RACK_INPUT] = 0 == hp.content_length ?
+                        NULL_IO : TeeInput.new(client, env, hp, buf)
+      env[REMOTE_ADDR] = remote_addr
+      response = app.call(env.update(RACK_DEFAULTS))
 
-        alive = hp.keepalive? && G.alive
-        if hp.headers?
-          out = [ alive ? CONN_ALIVE : CONN_CLOSE ]
-          client.write(HttpResponse.header_string(status, headers, out))
-        end
-        write_body(client, body)
-      end while alive and hp.reset.nil? and env.clear
-    # 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
-      Error.write(client, e)
-    ensure
-      client.close unless client.closed?
-    end
+      if 100 == response[0].to_i
+        client.write(EXPECT_100_RESPONSE)
+        env.delete(HTTP_EXPECT)
+        response = app.call(env)
+      end
 
-    def self.included(klass)
-      klass.const_set :LISTENERS, HttpServer::LISTENERS
-      klass.const_set :G, Rainbows::G
-    end
+      alive = hp.keepalive? && G.alive
+      out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if hp.headers?
+      write_response(client, response, out)
+    end while alive and hp.reset.nil? and env.clear
+  # 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)
+  ensure
+    client.close unless client.closed?
+  end
 
+  def self.included(klass) # :nodoc:
+    klass.const_set :LISTENERS, Rainbows::HttpServer::LISTENERS
+    klass.const_set :G, Rainbows::G
   end
+
+  # :startdoc:
 end

data/lib/rainbows/byte_slice.rb

@@ -0,0 +1,17 @@
+# -*- encoding: binary -*-
+# :enddoc:
+module Rainbows::ByteSlice
+  if String.method_defined?(:encoding)
+    def byte_slice(buf, range)
+      if buf.encoding != Encoding::BINARY
+        buf.dup.force_encoding(Encoding::BINARY)[range]
+      else
+        buf[range]
+      end
+    end
+  else
+    def byte_slice(buf, range)
+      buf[range]
+    end
+  end
+end

data/lib/rainbows/configurator.rb

@@ -0,0 +1,46 @@
+# -*- encoding: binary -*-
+module Rainbows
+
+  # This module adds \Rainbows! to the
+  # {Unicorn::Configurator}[http://unicorn.bogomips.org/Unicorn/Configurator.html]
+  module Configurator
+
+    # configures \Rainbows! with a given concurrency model to +use+ and
+    # a +worker_connections+ upper-bound.  This method may be called
+    # inside a Unicorn/\Rainbows! configuration file:
+    #
+    #   Rainbows! do
+    #     use :ThreadSpawn # concurrency model to use
+    #     worker_connections 400
+    #     keepalive_timeout 0 # zero disables keepalives entirely
+    #     client_max_body_size 5*1024*1024 # 5 megabytes
+    #   end
+    #
+    #   # the rest of the Unicorn configuration
+    #   worker_processes 8
+    #
+    # See the documentation for the respective Revactor, ThreadSpawn,
+    # and ThreadPool classes for descriptions and recommendations for
+    # 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 5 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).
+    #
+    # The default +client_max_body_size+ is 1 megabyte (1024 * 1024 bytes),
+    # setting this to +nil+ will disable body size checks and allow any
+    # size to be specified.
+    def Rainbows!(&block)
+      block_given? or raise ArgumentError, "Rainbows! requires a block"
+      HttpServer.setup(block)
+    end
+
+  end
+end
+
+# inject the Rainbows! method into Unicorn::Configurator
+Unicorn::Configurator.class_eval { include Rainbows::Configurator }

data/lib/rainbows/const.rb

@@ -1,9 +1,9 @@
 # -*- encoding: binary -*-
-
+# :enddoc:
 module Rainbows
 
   module Const
-    RAINBOWS_VERSION = '0.94.0'
+    RAINBOWS_VERSION = '0.95.0'
 
     include Unicorn::Const
 

data/lib/rainbows/dev_fd_response.rb

@@ -1,56 +1,64 @@
 # -*- encoding: binary -*-
 
-module Rainbows
+# Rack response middleware wrapping any IO-like object with an
+# OS-level file descriptor associated with it.  May also be used to
+# create responses from integer file descriptors or existing +IO+
+# objects.  This may be used in conjunction with the #to_path method
+# on servers that support it to pass arbitrary file descriptors into
+# the HTTP response without additional open(2) syscalls
+#
+# This middleware is currently a no-op for Rubinius, as it lacks
+# IO.copy_stream in 1.9 and also due to a bug here:
+#   http://github.com/evanphx/rubinius/issues/379
 
-  # Rack response middleware wrapping any IO-like object with an
-  # OS-level file descriptor associated with it.  May also be used to
-  # create responses from integer file descriptors or existing +IO+
-  # objects.  This may be used in conjunction with the #to_path method
-  # on servers that support it to pass arbitrary file descriptors into
-  # the HTTP response without additional open(2) syscalls
+class Rainbows::DevFdResponse < Struct.new(:app)
 
-  class DevFdResponse < Struct.new(:app, :to_io, :to_path)
-    include Rack::Utils
+  # :stopdoc:
+  #
+  # make this a no-op under Rubinius, it's pointless anyways
+  # since Rubinius doesn't have IO.copy_stream
+  def self.new(app)
+    app
+  end if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  include Rack::Utils
 
-    # Rack middleware entry point, we'll just pass through responses
-    # unless they respond to +to_io+ or +to_path+
-    def call(env)
-      status, headers, body = response = app.call(env)
+  # Rack middleware entry point, we'll just pass through responses
+  # unless they respond to +to_io+ or +to_path+
+  def call(env)
+    status, headers, body = response = app.call(env)
 
-      # totally uninteresting to us if there's no body
-      return response if STATUS_WITH_NO_ENTITY_BODY.include?(status)
+    # totally uninteresting to us if there's no body
+    return response if STATUS_WITH_NO_ENTITY_BODY.include?(status)
 
-      io = body.to_io if body.respond_to?(:to_io)
-      io ||= File.open(body.to_path, 'rb') if body.respond_to?(:to_path)
-      return response if io.nil?
+    io = body.to_io if body.respond_to?(:to_io)
+    io ||= File.open(body.to_path, 'rb') if body.respond_to?(:to_path)
+    return response if io.nil?
 
-      headers = HeaderHash.new(headers)
-      st = io.stat
-      if st.file?
-        headers['Content-Length'] ||= st.size.to_s
-        headers.delete('Transfer-Encoding')
-      elsif st.pipe? || st.socket? # epoll-able things
-        if env['rainbows.autochunk']
-          headers['Transfer-Encoding'] = 'chunked'
-          headers.delete('Content-Length')
-        else
-          headers['X-Rainbows-Autochunk'] = 'no'
-        end
+    headers = HeaderHash.new(headers)
+    st = io.stat
+    if st.file?
+      headers['Content-Length'] ||= st.size.to_s
+      headers.delete('Transfer-Encoding')
+    elsif st.pipe? || st.socket? # epoll-able things
+      if env['rainbows.autochunk']
+        headers['Transfer-Encoding'] = 'chunked'
+        headers.delete('Content-Length')
+      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, :RevFiberSpawn
-          return [ status, headers.to_hash, Fiber::IO.new(io,::Fiber.current) ]
-        end
-      else # unlikely, char/block device file, directory, ...
-        return response
+      # we need to make sure our pipe output is Fiber-compatible
+      case env["rainbows.model"]
+      when :FiberSpawn, :FiberPool, :RevFiberSpawn
+        return [ status, headers, Rainbows::Fiber::IO.new(io,::Fiber.current) ]
       end
-      resp = dup # be reentrant here
-      resp.to_path = "/dev/fd/#{io.fileno}"
-      resp.to_io = io
-      [ status, headers.to_hash, resp ]
+    else # unlikely, char/block device file, directory, ...
+      return response
     end
+    [ status, headers, Body.new(io, "/dev/fd/#{io.fileno}") ]
+  end
 
+  class Body < Struct.new(:to_io, :to_path)
     # called by the webserver or other middlewares if they can't
     # handle #to_path
     def each(&block)
@@ -70,6 +78,6 @@ module Rainbows
       rescue IOError # could've been IO::new()'ed and closed
       end
     end
-
-  end # class
-end
+  end
+  #:startdoc:
+end # class

data/lib/rainbows/error.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+# :enddoc:
 module Rainbows
 
   class Error

data/lib/rainbows/ev_core.rb

@@ -1,5 +1,5 @@
 # -*- encoding: binary -*-
-
+# :enddoc:
 module Rainbows
 
   # base module for evented models like Rev and EventMachine
@@ -7,6 +7,7 @@ module Rainbows
     include Unicorn
     include Rainbows::Const
     G = Rainbows::G
+    NULL_IO = Unicorn::HttpRequest::NULL_IO
 
     # Apps may return this Rack response: AsyncResponse = [ -1, {}, [] ]
     ASYNC_CALLBACK = "async.callback".freeze
@@ -40,7 +41,7 @@ module Rainbows
         @state = :body
         len = @hp.content_length
         if len == 0
-          @input = HttpRequest::NULL_IO
+          @input = NULL_IO
           app_call # common case
         else # nil or len > 0
           # since we don't do streaming input, we have no choice but