rainbows 0.97.0 → 1.0.0pre1

data/lib/rainbows/queue_pool.rb

@@ -2,32 +2,29 @@
 # :enddoc:
 require 'thread'
 
-module Rainbows
+# Thread pool class based on pulling off a single Ruby Queue.
+# This is NOT used for the ThreadPool class, since that class does not
+# need a userspace Queue.
+class Rainbows::QueuePool < Struct.new(:queue, :threads)
+  G = Rainbows::G
 
-  # Thread pool class based on pulling off a single Ruby Queue.
-  # This is NOT used for the ThreadPool class, since that class does not
-  # need a userspace Queue.
-  class QueuePool < Struct.new(:queue, :threads)
-    G = Rainbows::G
-
-    def initialize(size = 20, &block)
-      q = Queue.new
-      self.threads = (1..size).map do
-        Thread.new do
-          while job = q.shift
-            block.call(job)
-          end
+  def initialize(size = 20, &block)
+    q = Queue.new
+    self.threads = (1..size).map do
+      Thread.new do
+        while job = q.shift
+          block.call(job)
         end
       end
-      self.queue = q
     end
+    self.queue = q
+  end
 
-    def quit!
-      threads.each { |_| queue << nil }
-      threads.delete_if do |t|
-        G.tick
-        t.alive? ? t.join(0.01) : true
-      end until threads.empty?
-    end
+  def quit!
+    threads.each { |_| queue << nil }
+    threads.delete_if do |t|
+      G.tick
+      t.alive? ? t.join(0.01) : true
+    end until threads.empty?
   end
 end

data/lib/rainbows/read_timeout.rb

@@ -0,0 +1,28 @@
+# -*- encoding: binary -*-
+# :enddoc:
+module Rainbows::ReadTimeout
+  G = Rainbows::G # :nodoc:
+
+  def wait_readable
+    IO.select([self], nil, nil, G.kato)
+  end
+
+  # used for reading headers (respecting keepalive_timeout)
+  def read_timeout(buf = "")
+    expire = nil
+    begin
+      case rv = kgio_tryread(16384, buf)
+      when :wait_readable
+        now = Time.now.to_f
+        if expire
+          now > expire and return
+        else
+          expire = now + G.kato
+        end
+        wait_readable
+      else
+        return rv
+      end
+    end while true
+  end
+end

data/lib/rainbows/rev/client.rb

@@ -5,7 +5,6 @@ module Rainbows
   module Rev
 
     class Client < ::Rev::IO
-      include Rainbows::ByteSlice
       include Rainbows::EvCore
       G = Rainbows::G
       F = Rainbows::StreamFile
@@ -28,13 +27,14 @@ module Rainbows
       def write(buf)
         if @_write_buffer.empty?
           begin
-            w = @_io.write_nonblock(buf)
-            return enable_write_watcher if w == Rack::Utils.bytesize(buf)
-            # we never care for the return value, but yes, we may return
-            # a "fake" short write from super(buf) if anybody cares.
-            buf = byte_slice(buf, w..-1)
-          rescue Errno::EAGAIN
-            break # fall through to super(buf)
+            case rv = @_io.kgio_trywrite(buf)
+            when nil
+              return enable_write_watcher
+            when Kgio::WaitWritable
+              break # fall through to super(buf)
+            when String
+              buf = rv # retry, skb could grow or been drained
+            end
           rescue => e
             return handle_error(e)
           end while true
@@ -104,7 +104,7 @@ module Rainbows
       def app_call
         KATO.delete(self)
         @env[RACK_INPUT] = @input
-        @env[REMOTE_ADDR] = @remote_addr
+        @env[REMOTE_ADDR] = @_io.kgio_addr
         response = APP.call(@env.update(RACK_DEFAULTS))
 
         rev_write_response(response, alive = @hp.keepalive? && G.alive)
@@ -147,7 +147,7 @@ module Rainbows
       def handle_error(e)
         close_deferred
         if msg = Error.response(e)
-          @_io.write_nonblock(msg) rescue nil
+          @_io.kgio_trywrite(msg) rescue nil
         end
         @_write_buffer.clear
         ensure

data/lib/rainbows/rev/core.rb

@@ -7,12 +7,11 @@ require 'rainbows/rev/heartbeat'
 module Rainbows
   module Rev
     class Server < ::Rev::IO
-      include Rainbows::Acceptor
       # CL and MAX will be defined in the corresponding worker loop
 
       def on_readable
         return if CONN.size >= MAX
-        io = accept(@_io) and CL.new(io).attach(LOOP)
+        io = @_io.kgio_tryaccept and CL.new(io).attach(LOOP)
       end
     end # class Server
 
@@ -27,7 +26,7 @@ module Rainbows
         require 'rainbows/rev/sendfile'
         Rainbows::Rev::Client.__send__(:include, Rainbows::Rev::Sendfile)
         init_worker_process(worker)
-        mod = self.class.const_get(@use)
+        mod = Rainbows.const_get(@use)
         rloop = Server.const_set(:LOOP, ::Rev::Loop.default)
         Server.const_set(:MAX, @worker_connections)
         Server.const_set(:CL, mod.const_get(:Client))

data/lib/rainbows/rev/thread.rb

@@ -34,7 +34,7 @@ module Rainbows
       # here because that could cause a deadlock and we'd leak FDs
       def app_response
         begin
-          @env[REMOTE_ADDR] = @remote_addr
+          @env[REMOTE_ADDR] = @_io.kgio_addr
           APP.call(@env.update(RACK_DEFAULTS))
         rescue => e
           Error.app(e) # we guarantee this does not raise

data/lib/rainbows/rev_fiber_spawn.rb

@@ -1,31 +1,28 @@
 # -*- encoding: binary -*-
 require 'rainbows/fiber/rev'
 
-module Rainbows
+# A combination of the Rev and FiberSpawn models.  This allows Ruby
+# 1.9 Fiber-based concurrency for application processing while
+# exposing a synchronous execution model and using scalable network
+# concurrency provided by Rev.  A "rack.input" is exposed as well
+# being Sunshowers-compatible.  Applications are strongly advised to
+# wrap all slow IO objects (sockets, pipes) using the
+# Rainbows::Fiber::IO or a Rev-compatible class whenever possible.
+module Rainbows::RevFiberSpawn
 
-  # A combination of the Rev and FiberSpawn models.  This allows Ruby
-  # 1.9 Fiber-based concurrency for application processing while
-  # exposing a synchronous execution model and using scalable network
-  # concurrency provided by Rev.  A "rack.input" is exposed as well
-  # being Sunshowers-compatible.  Applications are strongly advised to
-  # wrap all slow IO objects (sockets, pipes) using the
-  # Rainbows::Fiber::IO or a Rev-compatible class whenever possible.
-  module RevFiberSpawn
+  include Rainbows::Base
+  include Rainbows::Fiber::Rev
 
-    include Base
-    include Fiber::Rev
-
-    def worker_loop(worker) # :nodoc:
-      Rainbows::Response.setup(Rainbows::Fiber::Rev::Server)
-      init_worker_process(worker)
-      Server.const_set(:MAX, @worker_connections)
-      Rainbows::Fiber::Base.setup(Rainbows::Fiber::Rev::Server, nil)
-      Server.const_set(:APP, G.server.app)
-      Heartbeat.new(1, true).attach(::Rev::Loop.default)
-      kato = Kato.new.attach(::Rev::Loop.default)
-      Rainbows::Fiber::IO.const_set(:KATO, kato)
-      LISTENERS.map! { |s| Server.new(s).attach(::Rev::Loop.default) }
-      ::Rev::Loop.default.run
-    end
+  def worker_loop(worker) # :nodoc:
+    Rainbows::Response.setup(Server)
+    init_worker_process(worker)
+    Server.const_set(:MAX, @worker_connections)
+    Rainbows::Fiber::Base.setup(Server, nil)
+    Server.const_set(:APP, G.server.app)
+    Heartbeat.new(1, true).attach(Rev::Loop.default)
+    kato = Kato.new.attach(Rev::Loop.default)
+    Rainbows::Fiber::Rev::Methods.const_set(:KATO, kato)
+    LISTENERS.map! { |s| Server.new(s).attach(Rev::Loop.default) }
+    Rev::Loop.default.run
   end
 end

data/lib/rainbows/revactor.rb

@@ -1,5 +1,6 @@
 # -*- encoding: binary -*-
 require 'revactor'
+require 'fcntl'
 Revactor::VERSION >= '0.1.5' or abort 'revactor 0.1.5 is required'
 
 # Enables use of the Actor model through
@@ -25,7 +26,7 @@ module Rainbows::Revactor
   autoload :Proxy, 'rainbows/revactor/proxy'
 
   include Rainbows::Base
-  LOCALHOST = Unicorn::HttpRequest::LOCALHOST
+  LOCALHOST = Kgio::LOCALHOST
   TCP = ::Revactor::TCP::Socket
 
   # once a client is accepted, it is processed in its entirety here
@@ -40,16 +41,17 @@ module Rainbows::Revactor
     else
       LOCALHOST
     end
-    buf = client.read(*rd_args)
-    hp = HttpParser.new
-    env = {}
+    hp = Unicorn::HttpParser.new
+    buf = hp.buf
 
     begin
-      buf << client.read(*rd_args) until hp.headers(env, buf)
+      until env = hp.parse
+        buf << client.read(*rd_args)
+      end
 
       env[CLIENT_IO] = client
       env[RACK_INPUT] = 0 == hp.content_length ?
-               NULL_IO : TeeInput.new(PartialSocket.new(client), env, hp, buf)
+               NULL_IO : TeeInput.new(TeeSocket.new(client), hp)
       env[REMOTE_ADDR] = remote_addr
       status, headers, body = app.call(env.update(RACK_DEFAULTS))
 
@@ -62,12 +64,12 @@ module Rainbows::Revactor
       if hp.headers?
         headers = HH.new(headers)
         range = make_range!(env, status, headers) and status = range.shift
-        env = false unless hp.keepalive? && G.alive && G.kato > 0
+        env = hp.keepalive? && G.alive && G.kato > 0
         headers[CONNECTION] = env ? KEEP_ALIVE : CLOSE
         client.write(response_header(status, headers))
       end
       write_body(client, body, range)
-    end while env && env.clear && hp.reset.nil?
+    end while env && hp.reset.nil?
   rescue ::Revactor::TCP::ReadError
   rescue => e
     Rainbows::Error.write(io, e)
@@ -145,36 +147,37 @@ module Rainbows::Revactor
   # 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 PartialSocket < Struct.new(:socket, :rbuf)
+  class TeeSocket
     def initialize(socket)
       # IO::Buffer is used internally by Rev which Revactor is based on
       # so we'll always have it available
-      super(socket, IO::Buffer.new)
+      @socket, @rbuf = socket, IO::Buffer.new
     end
 
     # Revactor socket reads always return an unspecified amount,
     # sometimes too much
-    def readpartial(length, dst = "")
+    def kgio_read(length, dst = "")
       return dst.replace("") if length == 0
 
       # always check and return from the userspace buffer first
-      rbuf.size > 0 and return dst.replace(rbuf.read(length))
+      @rbuf.size > 0 and return dst.replace(@rbuf.read(length))
 
       # read off the socket since there was nothing in rbuf
-      tmp = socket.read
+      tmp = @socket.read
 
       # we didn't read too much, good, just return it straight back
       # to avoid needlessly wasting memory bandwidth
       tmp.size <= length and return dst.replace(tmp)
 
       # ugh, read returned too much
-      rbuf << tmp[length, tmp.size]
+      @rbuf << tmp[length, tmp.size]
       dst.replace(tmp[0, length])
+      rescue EOFError
     end
 
     # just proxy any remaining methods TeeInput may use
     def close
-      socket.close
+      @socket.close
     end
   end
 

data/lib/rainbows/thread_pool.rb

@@ -22,9 +22,7 @@ module Rainbows
   # others and thus a lower +worker_connections+ setting is recommended.
 
   module ThreadPool
-
     include Base
-    include Rainbows::Acceptor
 
     def worker_loop(worker) # :nodoc:
       init_worker_process(worker)
@@ -45,7 +43,7 @@ module Rainbows
     def sync_worker # :nodoc:
       s = LISTENERS[0]
       begin
-        c = sync_accept(s) and process_client(c)
+        c = s.kgio_accept and process_client(c)
       rescue => e
         Error.listen_loop(e)
       end while G.alive
@@ -59,7 +57,7 @@ module Rainbows
         # problem.  On the other hand, a thundering herd may not
         # even incur as much overhead as an extra Mutex#synchronize
         ret = IO.select(LISTENERS, nil, nil, 1) and ret[0].each do |s|
-          s = accept(s) and process_client(s)
+          s = s.kgio_tryaccept and process_client(s)
         end
       rescue Errno::EINTR
       rescue => e

data/lib/rainbows/thread_spawn.rb

@@ -18,7 +18,6 @@ module Rainbows
 
   module ThreadSpawn
     include Base
-    include Rainbows::Acceptor
 
     def accept_loop(klass) #:nodoc:
       lock = Mutex.new
@@ -37,7 +36,7 @@ module Rainbows
               # CPU during I/O wait, CPU cycles that can be better used
               # by other worker _processes_.
               sleep(0.01)
-            elsif c = sync_accept(l)
+            elsif c = l.kgio_accept
               klass.new(c) do |c|
                 begin
                   lock.synchronize { G.cur += 1 }

data/lib/rainbows/writer_thread_pool.rb

@@ -20,17 +20,26 @@ module Rainbows
   # slow client denial-of-service attacks.
 
   module WriterThreadPool
+    # :stopdoc:
     include Base
 
     # used to wrap a BasicSocket to use with +q+ for all writes
     # this is compatible with IO.select
     class QueueSocket < Struct.new(:to_io, :q) # :nodoc:
-      def readpartial(size, buf = "")
-        to_io.readpartial(size, buf)
+      def kgio_addr
+        to_io.kgio_addr
       end
 
-      def write_nonblock(buf)
-        to_io.write_nonblock(buf)
+      def kgio_read(size, buf = "")
+        to_io.kgio_read(size, buf)
+      end
+
+      def kgio_read!(size, buf = "")
+        to_io.kgio_read!(size, buf)
+      end
+
+      def kgio_trywrite(buf)
+        to_io.kgio_trywrite(buf)
       end
 
       def write(buf)
@@ -87,5 +96,6 @@ module Rainbows
       super(worker) # accept loop from Unicorn
       qp.map { |q| q.quit! }
     end
+    # :startdoc:
   end
 end

data/lib/rainbows/writer_thread_spawn.rb

@@ -21,6 +21,7 @@ module Rainbows
   # vulnerable to slow client denial-of-service attacks.
 
   module WriterThreadSpawn
+    # :stopdoc:
     include Base
 
     CUR = {} # :nodoc:
@@ -30,12 +31,20 @@ module Rainbows
     class MySocket < Struct.new(:to_io, :q, :thr)  # :nodoc: all
       include Rainbows::Response
 
-      def readpartial(size, buf = "")
-        to_io.readpartial(size, buf)
+      def kgio_addr
+        to_io.kgio_addr
       end
 
-      def write_nonblock(buf)
-        to_io.write_nonblock(buf)
+      def kgio_read(size, buf = "")
+        to_io.kgio_read(size, buf)
+      end
+
+      def kgio_read!(size, buf = "")
+        to_io.kgio_read!(size, buf)
+      end
+
+      def kgio_trywrite(buf)
+        to_io.kgio_trywrite(buf)
       end
 
       def queue_writer
@@ -107,5 +116,6 @@ module Rainbows
         t.alive? ? t.join(0.01) : true
       end until CUR.empty?
     end
+    # :startdoc:
   end
 end

data/lib/rainbows.rb

@@ -1,12 +1,9 @@
 # -*- 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
 
-require 'rainbows/error'
-require 'rainbows/configurator'
-require 'fcntl'
-
 module Rainbows
 
   # global vars because class/instance variables are confusing me :<
@@ -41,8 +38,10 @@ module Rainbows
   require 'rainbows/const'
   require 'rainbows/http_server'
   require 'rainbows/response'
+  require 'rainbows/client'
+  require 'rainbows/tee_input'
+  require 'rainbows/process_client'
   autoload :Base, 'rainbows/base'
-  autoload :TeeInput, 'rainbows/tee_input'
   autoload :Sendfile, 'rainbows/sendfile'
   autoload :AppPool, 'rainbows/app_pool'
   autoload :DevFdResponse, 'rainbows/dev_fd_response'
@@ -75,14 +74,6 @@ module Rainbows
       HttpServer.new(app, options).start.join
     end
 
-    # returns a string representing the address of the given client +io+
-    # For local UNIX domain sockets, this will return a string referred
-    # to by the (non-frozen) Unicorn::HttpRequest::LOCALHOST constant.
-    def addr(io) # :nodoc:
-      io.respond_to?(:peeraddr) ?
-                        io.peeraddr[-1] : Unicorn::HttpRequest::LOCALHOST
-    end
-
     # :stopdoc:
     # the default max body size is 1 megabyte (1024 * 1024 bytes)
     @@max_bytes = 1024 * 1024
@@ -118,9 +109,10 @@ module Rainbows
   end
   # :startdoc:
   autoload :Fiber, 'rainbows/fiber' # core class
-  autoload :ByteSlice, 'rainbows/byte_slice'
   autoload :StreamFile, 'rainbows/stream_file'
   autoload :HttpResponse, 'rainbows/http_response' # deprecated
   autoload :ThreadTimeout, 'rainbows/thread_timeout'
 end
-require 'rainbows/acceptor'
+
+require 'rainbows/error'
+require 'rainbows/configurator'

data/local.mk.sample

@@ -17,13 +17,7 @@ DLEXT := so
 prefix = $(HOME)
 
 ifeq ($(r192),)
-  ifeq ($(r19),)
-    RUBY := $(prefix)/bin/ruby
-  else
-    prefix := $(prefix)/ruby-1.9
-    export PATH := $(prefix)/bin:$(PATH)
-    RUBY := $(prefix)/bin/ruby --disable-gems
-  endif
+  RUBY := $(prefix)/bin/ruby
 else
   prefix := $(prefix)/ruby-1.9.2
   export PATH := $(prefix)/bin:$(PATH)
@@ -36,12 +30,10 @@ SHELL := /bin/ksh93 -e -o pipefail
 
 # trace execution of tests
 # TRACER = strace -f -o $(t_pfx).strace -s 100000
-TRACER = /usr/bin/time -v -o $(t_pfx).time
+# TRACER = /usr/bin/time -v -o $(t_pfx).time
 
-full-test: test-18 test-191 test-192
+full-test: test-18 test-192
 test-18:
 	$(MAKE) test 2>&1 | sed -e 's!^!1.8 !'
-test-191:
-	$(MAKE) test r19=T 2>&1 | sed -e 's!^!1.9.1 !'
 test-192:
 	$(MAKE) test r192=T 2>&1 | sed -e 's!^!1.9.2 !'

data/rainbows.gemspec

@@ -44,10 +44,8 @@ Gem::Specification.new do |s|
   s.add_dependency(%q<rack>, ['~> 1.1'])
 
   # we need Unicorn for the HTTP parser and process management
-  # Unicorn 0.991.0 handles config.ru when started outside of
-  # the prespecified working_directory
-  s.add_dependency(%q<unicorn>, [">= 1.1.3", "< 2.0.0"])
-  s.add_development_dependency(%q<isolate>, "~> 2.1.0")
+  s.add_dependency(%q<unicorn>, ["~> 2.0.0pre3"])
+  s.add_development_dependency(%q<isolate>, "~> 3.0.0")
 
   # optional runtime dependencies depending on configuration
   # see t/test_isolate.rb for the exact versions we've tested with

data/t/kgio-pipe-response.ru

@@ -0,0 +1,10 @@
+# must be run without Rack::Lint since that clobbers to_path
+use Rainbows::DevFdResponse
+run(lambda { |env|
+  [ 200,
+    {
+      'Content-Length' => ::File.stat('random_blob').size.to_s,
+      'Content-Type' => 'application/octet-stream',
+    },
+    Rainbows::Fiber::IO::Pipe.popen('cat random_blob', 'rb') ]
+})

data/t/t0035-kgio-pipe-response.sh

@@ -0,0 +1,70 @@
+#!/bin/sh
+. ./test-lib.sh
+test -r random_blob || die "random_blob required, run with 'make $0'"
+case $model in
+*Fiber* ) ;;
+*)
+	t_info "skipping $T since it's not compatible with $model"
+	exit 0
+	;;
+esac
+
+t_plan 10 "fast Kgio pipe response for $model"
+
+t_begin "setup and startup" && {
+	rtmpfiles err out
+	rainbows_setup $model
+	rainbows -E none -D kgio-pipe-response.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "read random blob sha1" && {
+	random_blob_sha1=$(rsha1 < random_blob)
+	three_sha1=$(cat random_blob random_blob random_blob | rsha1)
+}
+
+t_begin "single request matches" && {
+	sha1=$(curl -sSfv 2> $err http://$listen/ | rsha1)
+	test -n "$sha1"
+	test x"$sha1" = x"$random_blob_sha1"
+}
+
+t_begin "Content-Length header preserved in response" && {
+	grep "^< Content-Length:" $err
+}
+
+t_begin "send three keep-alive requests" && {
+	sha1=$(curl -vsSf 2> $err \
+	       http://$listen/ http://$listen/ http://$listen/ | rsha1)
+	test -n "$sha1"
+	test x"$sha1" = x"$three_sha1"
+}
+
+t_begin "ensure responses were all keep-alive" && {
+	test 3 -eq $(grep '< Connection: keep-alive' < $err | wc -l)
+}
+
+t_begin "HTTP/1.0 test" && {
+	sha1=$(curl -0 -v 2> $err -sSf http://$listen/ | rsha1)
+	test $sha1 = $random_blob_sha1
+	grep '< Connection: close' < $err
+}
+
+t_begin "HTTP/0.9 test" && {
+	(
+		printf 'GET /\r\n'
+		rsha1 < $fifo > $tmp &
+		wait
+		echo ok > $ok
+	) | socat - TCP:$listen > $fifo
+	test $(cat $tmp) = $random_blob_sha1
+	test xok = x$(cat $ok)
+}
+
+t_begin "shutdown server" && {
+	kill -QUIT $rainbows_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/t/test_isolate.rb

@@ -15,7 +15,8 @@ $stdout.reopen($stderr)
 
 Isolate.now!(opts) do
   gem 'rack', '1.1.0' # Cramp currently requires ~> 1.1.0
-  gem 'unicorn', '1.1.3'
+  gem 'kgio', '1.3.1'
+  gem 'unicorn', '2.0.0pre3'
   gem 'kcar', '0.1.1'
 
   if engine == "ruby"