rainbows 2.1.0 → 3.0.0

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v2.1.0.GIT
+DEF_VER=v3.0.0.GIT
 
 LF='
 '

data/GNUmakefile

@@ -9,9 +9,6 @@ GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
 	@./GIT-VERSION-GEN
 -include GIT-VERSION-FILE
 -include local.mk
-ifeq ($(DLEXT),) # "so" for Linux
-  DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts Config::CONFIG["DLEXT"]')
-endif
 ifeq ($(RUBY_VERSION),)
   RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
 endif
@@ -45,6 +42,8 @@ clean:
 man html:
 	$(MAKE) -C Documentation install-$@
 
+pkg_extra := GIT-VERSION-FILE ChangeLog LATEST NEWS $(man1_paths)
+
 ChangeLog: GIT-VERSION-FILE .wrongdoc.yml
 	wrongdoc prepare
 

data/Rakefile

@@ -81,9 +81,12 @@ task :fm_update do
   uri = URI.parse('http://freshmeat.net/projects/rainbows/releases.json')
   rc = Net::Netrc.locate('rainbows-fm') or abort "~/.netrc not found"
   api_token = rc.password
-  changelog = tags.find { |t| t[:tag] == "v#{version}" }[:body]
+  _, subject, body = `git cat-file tag v#{version}`.split(/\n\n/, 3)
   tmp = Tempfile.new('fm-changelog')
-  tmp.syswrite(changelog)
+  tmp.puts subject
+  tmp.puts
+  tmp.puts body
+  tmp.flush
   system(ENV["VISUAL"], tmp.path) or abort "#{ENV["VISUAL"]} failed: #$?"
   changelog = File.read(tmp.path).strip
 

data/lib/rainbows.rb

@@ -1,31 +1,19 @@
 # -*- encoding: binary -*-
 require 'kgio'
 require 'unicorn'
-# the value passed to TCP_DEFER_ACCEPT actually matters in Linux 2.6.32+
-Unicorn::SocketHelper::DEFAULTS[:tcp_defer_accept] = 60
+Unicorn::SocketHelper::DEFAULTS.merge!({
+  # the value passed to TCP_DEFER_ACCEPT actually matters in Linux 2.6.32+
+  :tcp_defer_accept => 60,
 
-module Rainbows
+  # keep-alive performance sucks without this due to
+  # write(headers)-write(body)-read
+  # because we always write headers and bodies with two calls
+  :tcp_nodelay => true,
+})
 
-  # 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 in the network concurrency model
-  # :stopdoc:
-  class State < Struct.new(:alive,:m,:cur,:kato,:server,:tmp,:expire)
-    def tick
-      tmp.chmod(self.m = m == 0 ? 1 : 0)
-      exit!(2) if expire && Time.now >= expire
-      alive && server.master_pid == Process.ppid or quit!
-    end
+module Rainbows
 
-    def quit!
-      self.alive = false
-      self.expire ||= Time.now + (server.timeout * 2.0)
-      server.class.const_get(:LISTENERS).map! { |s| s.close rescue nil }
-      false
-    end
-  end
-  G = State.new(true, 0, 0, 5)
-  O = {}
+  O = {} # :nodoc:
   class Response416 < RangeError; end
 
   # map of numeric file descriptors to IO objects to avoid using IO.new
@@ -36,10 +24,12 @@ module Rainbows
   # :startdoc:
 
   require 'rainbows/const'
+  require 'rainbows/http_parser'
   require 'rainbows/http_server'
-  require 'rainbows/response'
-  require 'rainbows/client'
-  require 'rainbows/process_client'
+  autoload :RackInput, 'rainbows/rack_input'
+  autoload :Response, 'rainbows/response'
+  autoload :ProcessClient, 'rainbows/process_client'
+  autoload :Client, 'rainbows/client'
   autoload :Base, 'rainbows/base'
   autoload :Sendfile, 'rainbows/sendfile'
   autoload :AppPool, 'rainbows/app_pool'
@@ -49,42 +39,70 @@ module Rainbows
   autoload :EvCore, 'rainbows/ev_core'
   autoload :SocketProxy, 'rainbows/socket_proxy'
 
+  # Sleeps the current application dispatch.  This will pick the
+  # optimal method to sleep depending on the concurrency model chosen
+  # (which may still suck and block the entire process).  Using this
+  # with the basic :Coolio or :EventMachine models is not recommended.
+  # This should be used within your Rack application.
+  def self.sleep(nr)
+    case Rainbows.server.use
+    when :FiberPool, :FiberSpawn
+      Rainbows::Fiber.sleep(nr)
+    when :RevFiberSpawn, :CoolioFiberSpawn
+      Rainbows::Fiber::Coolio::Sleeper.new(nr)
+    when :Revactor
+      Actor.sleep(nr)
+    else
+      Kernel.sleep(nr)
+    end
+  end
+
+  # runs the Rainbows! HttpServer with +app+ and +options+ and does
+  # not return until the server has exited.
+  def self.run(app, options = {}) # :nodoc:
+    HttpServer.new(app, options).start.join
+  end
+
+  # :stopdoc:
   class << self
+    attr_accessor :max_bytes, :keepalive_timeout
+    attr_accessor :server
+    attr_accessor :cur # may not always be used
+    attr_reader :alive
+    attr_writer :tick_io
+  end
+  # :startdoc:
 
-    # Sleeps the current application dispatch.  This will pick the
-    # optimal method to sleep depending on the concurrency model chosen
-    # (which may still suck and block the entire process).  Using this
-    # with the basic :Coolio or :EventMachine models is not recommended.
-    # This should be used within your Rack application.
-    def sleep(nr)
-      case G.server.use
-      when :FiberPool, :FiberSpawn
-        Rainbows::Fiber.sleep(nr)
-      when :RevFiberSpawn, :CoolioFiberSpawn
-        Rainbows::Fiber::Coolio::Sleeper.new(nr)
-      when :Revactor
-        Actor.sleep(nr)
-      else
-        Kernel.sleep(nr)
-      end
-    end
+  # the default max body size is 1 megabyte (1024 * 1024 bytes)
+  @max_bytes = 1024 * 1024
 
-    # runs the Rainbows! HttpServer with +app+ and +options+ and does
-    # not return until the server has exited.
-    def run(app, options = {}) # :nodoc:
-      HttpServer.new(app, options).start.join
-    end
+  # the default keepalive_timeout is 5 seconds
+  @keepalive_timeout = 5
 
-    # :stopdoc:
-    # the default max body size is 1 megabyte (1024 * 1024 bytes)
-    @@max_bytes = 1024 * 1024
+  # :stopdoc:
+  @alive = true
+  @cur = 0
+  @tick_mod = 0
+  @expire = nil
 
-    def max_bytes; @@max_bytes; end
-    def max_bytes=(nr); @@max_bytes = nr; end
-    # :startdoc:
+  def self.tick
+    @tick_io.chmod(@tick_mod = 0 == @tick_mod ? 1 : 0)
+    exit!(2) if @expire && Time.now >= @expire
+    @alive && @server.master_pid == Process.ppid or quit!
+  end
+
+  def self.cur_alive
+    @alive || @cur > 0
+  end
+
+  def self.quit!
+    @alive = false
+    Rainbows::HttpParser.quit
+    @expire ||= Time.now + (@server.timeout * 2.0)
+    @server.class.const_get(:LISTENERS).map! { |s| s.close rescue nil }
+    false
   end
 
-  # :stopdoc:
   # maps models to default worker counts, default worker count numbers are
   # pretty arbitrary and tuning them to your application and hardware is
   # highly recommended

data/lib/rainbows/base.rb

@@ -6,12 +6,7 @@
 # not intended for production use, as keepalive with a pure prefork
 # concurrency model is extremely expensive.
 module Rainbows::Base
-
   # :stopdoc:
-  include Rainbows::ProcessClient
-
-  # shortcuts...
-  G = Rainbows::G
 
   # this method is called by all current concurrency models
   def init_worker_process(worker) # :nodoc:
@@ -19,7 +14,7 @@ module Rainbows::Base
     Rainbows::Response.setup(self.class)
     Rainbows::MaxBody.setup
     Rainbows::RackInput.setup
-    G.tmp = worker.tmp
+    Rainbows.tick_io = worker.tmp
 
     listeners = Rainbows::HttpServer::LISTENERS
     Rainbows::HttpServer::IO_PURGATORY.concat(listeners)
@@ -28,15 +23,18 @@ module Rainbows::Base
     # 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! }
+    trap(:QUIT) { Rainbows.quit! }
     [:TERM, :INT].each { |sig| trap(sig) { exit!(0) } } # instant shutdown
-    Rainbows::ProcessClient.const_set(:APP, G.server.app)
+    Rainbows::ProcessClient.const_set(:APP, Rainbows.server.app)
     logger.info "Rainbows! #@use worker_connections=#@worker_connections"
   end
 
+  def process_client(client)
+    client.process_loop
+  end
+
   def self.included(klass) # :nodoc:
     klass.const_set :LISTENERS, Rainbows::HttpServer::LISTENERS
-    klass.const_set :G, Rainbows::G
   end
 
   # :startdoc:

data/lib/rainbows/client.rb

@@ -1,9 +1,30 @@
 # -*- encoding: binary -*-
 # :enddoc:
 
-require 'rainbows/timed_read'
-
+# this class is used for most synchronous concurrency models
 class Rainbows::Client < Kgio::Socket
-  include Rainbows::TimedRead
+  def read_expire
+    Time.now + Rainbows.keepalive_timeout
+  end
+
+  def kgio_wait_readable
+    IO.select([self], nil, nil, Rainbows.keepalive_timeout)
+  end
+
+  # used for reading headers (respecting keepalive_timeout)
+  def timed_read(buf)
+    expire = nil
+    begin
+      case rv = kgio_tryread(16384, buf)
+      when :wait_readable
+        return if expire && expire < Time.now
+        expire ||= read_expire
+        kgio_wait_readable
+      else
+        return rv
+      end
+    end while true
+  end
+
+  include Rainbows::ProcessClient
 end
-Kgio.accept_class = Rainbows::Client

data/lib/rainbows/const.rb

@@ -2,7 +2,7 @@
 # :enddoc:
 module Rainbows::Const
 
-  RAINBOWS_VERSION = '2.1.0'
+  RAINBOWS_VERSION = '3.0.0'
 
   include Unicorn::Const
 

data/lib/rainbows/coolio.rb

@@ -18,6 +18,9 @@ require 'rainbows/coolio_support'
 # allows the Rack application to process data as it arrives.  This
 # means "rack.input" will be fully buffered in memory or to a
 # temporary file before the application is entered.
+#
+# This model is mostly compatible with users of "async.callback" in
+# the Rack environment as long as they do not depend on EventMachine.
 module Rainbows::Coolio
   # :stopdoc:
   # keep-alive timeout scoreboard
@@ -31,15 +34,15 @@ module Rainbows::Coolio
     KATO.compare_by_identity
   end
 
+  autoload :Client, 'rainbows/coolio/client'
   autoload :Master, 'rainbows/coolio/master'
   autoload :ThreadClient, 'rainbows/coolio/thread_client'
-  autoload :DeferredChunkResponse, 'rainbows/coolio/deferred_chunk_response'
+  autoload :ResponsePipe, 'rainbows/coolio/response_pipe'
+  autoload :ResponseChunkPipe, 'rainbows/coolio/response_chunk_pipe'
   # :startdoc:
 end
 # :enddoc:
 require 'rainbows/coolio/heartbeat'
 require 'rainbows/coolio/server'
 require 'rainbows/coolio/core'
-require 'rainbows/coolio/deferred_response'
-require 'rainbows/coolio/client'
 Rainbows::Coolio.__send__ :include, Rainbows::Coolio::Core

data/lib/rainbows/coolio/client.rb

@@ -2,12 +2,9 @@
 # :enddoc:
 class Rainbows::Coolio::Client < Coolio::IO
   include Rainbows::EvCore
-  G = Rainbows::G
-  SF = Rainbows::StreamFile
   CONN = Rainbows::Coolio::CONN
   KATO = Rainbows::Coolio::KATO
-  DeferredResponse = Rainbows::Coolio::DeferredResponse
-  DeferredChunkResponse = Rainbows::Coolio::DeferredChunkResponse
+  LOOP = Coolio::Loop.default
 
   def initialize(io)
     CONN[self] = false
@@ -22,7 +19,7 @@ class Rainbows::Coolio::Client < Coolio::IO
 
   def quit
     super
-    close if @deferred.nil? && @_write_buffer.empty?
+    close if nil == @deferred && @_write_buffer.empty?
   end
 
   # override the Coolio::IO#write method try to write directly to the
@@ -59,87 +56,78 @@ class Rainbows::Coolio::Client < Coolio::IO
     close
   end
 
-  # queued, optional response bodies, it should only be unpollable "fast"
-  # devices where read(2) is uninterruptable.  Unfortunately, NFS and ilk
-  # are also part of this.  We'll also stick DeferredResponse bodies in
-  # here to prevent connections from being closed on us.
-  def defer_body(io)
-    @deferred = io
-    enable_write_watcher
-  end
-
   # allows enabling of write watcher even when read watcher is disabled
   def evloop
-    LOOP # this constant is set in when a worker starts
+    LOOP
   end
 
   def next!
     attached? or return
     @deferred = nil
-    enable_write_watcher
+    enable_write_watcher # trigger on_write_complete
   end
 
   def timeout?
-    @deferred.nil? && @_write_buffer.empty? and close.nil?
+    nil == @deferred && @_write_buffer.empty? and close.nil?
   end
 
   # used for streaming sockets and pipes
-  def stream_response(status, headers, io, body)
-    c = stream_response_headers(status, headers) if headers
+  def stream_response_body(body, io, chunk)
     # we only want to attach to the Coolio::Loop belonging to the
     # main thread in Ruby 1.9
-    io = (c ? DeferredChunkResponse : DeferredResponse).new(io, self, body)
-    defer_body(io.attach(LOOP))
+    (chunk ? Rainbows::Coolio::ResponseChunkPipe :
+             Rainbows::Coolio::ResponsePipe).new(io, self, body).attach(LOOP)
+    @deferred = true
   end
 
-  def coolio_write_response(response, alive)
-    status, headers, body = response
-    headers = @hp.headers? ? HH.new(headers) : nil
+  def write_response_path(status, headers, body, alive)
+    io = body_to_io(body)
+    st = io.stat
+
+    if st.file?
+      defer_file(status, headers, body, alive, io, st)
+    elsif st.socket? || st.pipe?
+      chunk = stream_response_headers(status, headers, alive)
+      stream_response_body(body, io, chunk)
+    else
+      # char or block device... WTF?
+      write_response(status, headers, body, alive)
+    end
+  end
 
-    headers[CONNECTION] = alive ? KEEP_ALIVE : CLOSE if headers
+  def ev_write_response(status, headers, body, alive)
     if body.respond_to?(:to_path)
-      io = body_to_io(body)
-      st = io.stat
-
-      if st.file?
-        offset, count = 0, st.size
-        if headers
-          if range = make_range!(@env, status, headers)
-            status, offset, count = range
-          end
-          write(response_header(status, headers))
-        end
-        return defer_body(SF.new(offset, count, io, body))
-      elsif st.socket? || st.pipe?
-        return stream_response(status, headers, io, body)
-      end
-      # char or block device... WTF? fall through to body.each
+      write_response_path(status, headers, body, alive)
+    else
+      write_response(status, headers, body, alive)
     end
-    write(response_header(status, headers)) if headers
-    write_body_each(self, body, nil)
+    return quit unless alive && :close != @state
+    @state = :headers
   end
 
   def app_call
     KATO.delete(self)
+    disable if enabled?
     @env[RACK_INPUT] = @input
     @env[REMOTE_ADDR] = @_io.kgio_addr
-    response = APP.call(@env.update(RACK_DEFAULTS))
+    @env[ASYNC_CALLBACK] = method(:write_async_response)
+    status, headers, body = catch(:async) {
+      APP.call(@env.merge!(RACK_DEFAULTS))
+    }
 
-    coolio_write_response(response, alive = @hp.next? && G.alive)
-    return quit unless alive && :close != @state
-    @state = :headers
-    disable if enabled?
+    (nil == status || -1 == status) ? @deferred = true :
+        ev_write_response(status, headers, body, @hp.next?)
   end
 
   def on_write_complete
     case @deferred
-    when DeferredResponse then return
-    when NilClass # fall through
+    when true then return # #next! will clear this bit
+    when nil # fall through
     else
       begin
-        return rev_sendfile(@deferred)
+        return stream_file_chunk(@deferred)
       rescue EOFError # expected at file EOF
-        close_deferred
+        close_deferred # fall through
       end
     end
 
@@ -171,13 +159,11 @@ class Rainbows::Coolio::Client < Coolio::IO
   end
 
   def close_deferred
-    case @deferred
-    when DeferredResponse, NilClass
-    else
+    if @deferred
       begin
-        @deferred.close
+        @deferred.close if @deferred.respond_to?(:close)
       rescue => e
-        G.server.logger.error("closing #@deferred: #{e}")
+        Rainbows.server.logger.error("closing #@deferred: #{e}")
       end
       @deferred = nil
     end
@@ -188,4 +174,39 @@ class Rainbows::Coolio::Client < Coolio::IO
     CONN.delete(self)
     KATO.delete(self)
   end
+
+  if IO.method_defined?(:sendfile_nonblock)
+    def defer_file(status, headers, body, alive, io, st)
+      if r = sendfile_range(status, headers)
+        status, headers, range = r
+        write_headers(status, headers, alive)
+        range and defer_file_stream(range[0], range[1], io, body)
+      else
+        write_headers(status, headers, alive)
+        defer_file_stream(0, st.size, io, body)
+      end
+    end
+
+    def stream_file_chunk(sf) # +sf+ is a Rainbows::StreamFile object
+      sf.offset += (n = @_io.sendfile_nonblock(sf, sf.offset, sf.count))
+      0 == (sf.count -= n) and raise EOFError
+      enable_write_watcher
+      rescue Errno::EAGAIN
+        enable_write_watcher
+    end
+  else
+    def defer_file(status, headers, body, alive, io, st)
+      write_headers(status, headers, alive)
+      defer_file_stream(0, st.size, io, body)
+    end
+
+    def stream_file_chunk(body)
+      write(body.to_io.sysread(0x4000))
+    end
+  end
+
+  def defer_file_stream(offset, count, io, body)
+    @deferred = Rainbows::StreamFile.new(offset, count, io, body)
+    enable_write_watcher
+  end
 end