rainbows 0.92.0 → 0.93.0

data/Documentation/comparison.haml

@@ -99,6 +99,20 @@
     %td.r19 Yes
     %td.rbx No
     %td.slow Yes
+  %tr.comp_row
+    %td.mod WriterThreadPool
+    %td.tee Yes
+    %td.r18 Yes
+    %td.r19 Yes
+    %td.rbx Yes
+    %td.slow no
+  %tr.comp_row
+    %td.mod WriterThreadSpawn
+    %td.tee Yes
+    %td.r18 Yes
+    %td.r19 Yes
+    %td.rbx Yes
+    %td.slow no
 %ul
   %li
     RevThread* + 1.8 requires Rev >= 0.3.2 for reasonable performance
@@ -203,7 +217,16 @@
       %a(href="Rainbows/Fiber/IO.html") Rainbows::Fiber::IO
     %td.thr No
     %td.reent Yes
-
+  %tr.comp_base
+    %td.mod WriterThreadPool
+    %td.slowio avoid
+    %td.thr Maybe
+    %td.reent Maybe
+  %tr.comp_base
+    %td.mod WriterThreadSpawn
+    %td.slowio avoid
+    %td.thr Maybe
+    %td.reent Maybe
 %ul
   %li
     Requirements for single thread reentrancy are loose in that there is
@@ -219,6 +242,9 @@
     on UNIX domain sockets and named pipes.  Nearly all other operations
     on POSIX filesystems can be considered "fast", or at least
     uninterruptible.
+  %li
+    WriterThread{Pool,Spawn} will require thread safety if your response
+    body is dynamically generated during the body#each call.
 
 %h2 middlewares and frameworks
 %br
@@ -250,7 +276,7 @@
     %td.ws Sunshowers
   %tr.comp_row
     %td.mod ThreadPool
-    %td.devfd no-op
+    %td.devfd Yes
     %td.app_pool Yes
     %td.lock Yes
     %td.async standard Ruby
@@ -264,7 +290,7 @@
     %td.ws no
   %tr.comp_row
     %td.mod ThreadSpawn
-    %td.devfd no-op
+    %td.devfd Yes
     %td.app_pool Yes
     %td.lock Yes
     %td.async standard Ruby
@@ -316,15 +342,28 @@
     %td.devfd Yes
     %td.app_pool Yes
     %td.lock Dumb
-    %td.async standard Ruby
+    %td.async Rev, standard Ruby
     %td.ws no
   %tr.comp_row
     %td.mod RevFiberSpawn
     %td.devfd Yes
     %td.app_pool Yes
     %td.lock No!
-    %td.async Rainbows::Fiber::IO, Rainbows.sleep
-
+    %td.async Rev, Rainbows::Fiber::IO, Rainbows.sleep
+  %tr.comp_row
+    %td.mod WriterThreadPool
+    %td.devfd Yes
+    %td.app_pool no-op
+    %td.lock no-op
+    %td.async Standard Ruby in response body only
+    %td.ws response body only
+  %tr.comp_row
+    %td.mod WriterThreadSpawn
+    %td.devfd Yes
+    %td.app_pool no-op
+    %td.lock no-op
+    %td.async Standard Ruby in response body only
+    %td.ws response body only
 %ul
   %li
     "No!" means it's fundamentally incompatible, use an

data/FAQ

@@ -62,13 +62,19 @@ to ensure redirects go to "https://" URLs.
 
 === Is there a "rainbows_rails" command like there is "unicorn_rails"?
 
-Only if you write one and plan to support it.
+No.
 
 "unicorn_rails" was written primarily to support older versions of
-Rails.  Since \Rainbows! is designed for newer Rails, it can just use
-a "config.ru" file like other Rack frameworks and applications.
+Rails.  Since \Rainbows! is designed for newer applications based on
+Rack, it can just use a "config.ru" file like other Rack frameworks and
+applications.
 
-For Rails 2.3.x and later, the following config.ru will work for you:
+For Rails 3.x, you should already have a config.ru file and
+"rainbows(1)" will work out-of-the-box like "rackup(1)".  Rails 3
+will support RACK_ENV as set by "rainbows(1)", so you won't need
+to set RAILS_ENV.
+
+For Rails 2.3.x, the following config.ru will work for you:
 
   ENV["RAILS_ENV"] ||= ENV["RACK_ENV"]
   require "config/environment"

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -17,8 +17,8 @@ ifeq ($(RUBY_VERSION),)
 endif
 
 # rake takes forever to start
-isolate: tmp/gems/$(RUBY_VERSION)/.isolate
-tmp/gems/$(RUBY_VERSION)/.isolate: $(ISOLATE_CONFIG)
+isolate: tmp/isolate/ruby-$(RUBY_VERSION)/.isolate
+tmp/isolate/ruby-$(RUBY_VERSION)/.isolate: $(ISOLATE_CONFIG)
 	ISOLATE_CONFIG=$(ISOLATE_CONFIG) $(RAKE) isolate
 	> $@
 
@@ -66,7 +66,7 @@ NEWS: GIT-VERSION-FILE
 	$(RAKE) -s news_rdoc > $@+
 	mv $@+ $@
 
-SINCE = 0.91.1
+SINCE = 0.92.0
 ChangeLog: LOG_VERSION = \
   $(shell git rev-parse -q "$(GIT_VERSION)" >/dev/null 2>&1 && \
           echo $(GIT_VERSION) || git describe)

data/README

@@ -24,6 +24,8 @@ For network concurrency, models we currently support are:
 * {FiberPool}[link:Rainbows/FiberPool.html]
 * {NeverBlock}[link:Rainbows/NeverBlock.html]
 * {RevThreadPool}[link:Rainbows/RevThreadPool.html]
+* {WriterThreadPool}[link:Rainbows/WriterThreadPool.html]
+* {WriterThreadSpawn}[link:Rainbows/WriterThreadSpawn.html]
 
 We have {many more on the way}[link:TODO.html] for handling network
 concurrency.  Additionally, we also use multiple processes (managed by

data/Rakefile

@@ -187,6 +187,20 @@ end
 desc 'isolate gems for development'
 task :isolate do
   require 'isolate'
-  Isolate.gems "tmp/gems/#{RUBY_VERSION}",
-               :file => ENV['ISOLATE_CONFIG']
+  require 'rbconfig'
+
+  Isolate.now! :file => ENV['ISOLATE_CONFIG'], :system => false
+
+  # for Ruby 1.8 isolate uses "1.8" instead of "1.8.7" for paths,
+  # but we'll still try to support 1.8.6 for now even though isolate
+  # does not.
+  if Gem.ruby_engine == "ruby" &&
+     RbConfig::CONFIG["ruby_version"] != RUBY_VERSION
+    require 'fileutils'
+    Dir.chdir('tmp/isolate') do
+      FileUtils.rm_rf("ruby-#{RUBY_VERSION}")
+      File.symlink "ruby-#{RbConfig::CONFIG["ruby_version"]}",
+                   "ruby-#{RUBY_VERSION}"
+    end
+  end
 end

data/config/isolate.rb

@@ -4,7 +4,7 @@
 # `rake isolate' or (faster in the unmodified case, `make isolate')
 
 gem 'rack', '1.1.0'
-gem 'unicorn', '0.97.1'
+gem 'unicorn', '0.99.0'
 
 gem 'iobuffer', '0.1.3'
 gem 'rev', '0.3.2'
@@ -22,4 +22,4 @@ if defined?(::Fiber)
   gem 'rack-fiber_pool', '0.9.0'
 end
 
-gem 'cramp', '0.10'
+gem 'cramp', '0.11'

data/lib/rainbows.rb

@@ -35,6 +35,7 @@ module Rainbows
   autoload :AppPool, 'rainbows/app_pool'
   autoload :DevFdResponse, 'rainbows/dev_fd_response'
   autoload :MaxBody, 'rainbows/max_body'
+  autoload :QueuePool, 'rainbows/queue_pool'
 
   class << self
 
@@ -133,6 +134,8 @@ module Rainbows
   # highly recommended
   MODEL_WORKER_CONNECTIONS = {
     :Base => 1, # this one can't change
+    :WriterThreadPool => 20,
+    :WriterThreadSpawn => 20,
     :Revactor => 50,
     :ThreadSpawn => 30,
     :ThreadPool => 20,

data/lib/rainbows/base.rb

@@ -49,6 +49,8 @@ module Rainbows
       end
     end
 
+    module_function :write_body
+
     # 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

data/lib/rainbows/const.rb

@@ -3,7 +3,7 @@
 module Rainbows
 
   module Const
-    RAINBOWS_VERSION = '0.92.0'
+    RAINBOWS_VERSION = '0.93.0'
 
     include Unicorn::Const
 

data/lib/rainbows/queue_pool.rb

@@ -0,0 +1,32 @@
+# -*- encoding: binary -*-
+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 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
+        end
+      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
+  end
+end

data/lib/rainbows/thread_spawn.rb

@@ -33,6 +33,9 @@ module Rainbows
               # synchronization primitives for _every_ case, not just this
               # unlikely one.  Since this case is (or should be) uncommon,
               # just busy wait when we have to.
+              # We don't use Thread.pass because it needlessly spins the
+              # CPU during I/O wait, CPU cycles that can be better used
+              # by other worker _processes_.
               sleep(0.01)
             elsif c = Rainbows.sync_accept(l)
               klass.new(c) do |c|

data/lib/rainbows/writer_thread_pool.rb

@@ -0,0 +1,90 @@
+# -*- encoding: binary -*-
+
+module Rainbows
+
+  # This concurrency model implements a single-threaded app dispatch
+  # with a separate thread pool for writing responses.
+  #
+  # Unlike most \Rainbows! concurrency models, WriterThreadPool is
+  # designed to run behind nginx just like Unicorn is.  This concurrency
+  # model may be useful for existing Unicorn users looking for more
+  # output concurrency than socket buffers can provide while still
+  # maintaining a single-threaded application dispatch (though if the
+  # response body is dynamically generated, it must be thread safe).
+  #
+  # For serving large or streaming responses, using more threads (via
+  # the +worker_connections+ setting) and setting "proxy_buffering off"
+  # in nginx is recommended.  If your application does not handle
+  # uploads, then using any HTTP-aware proxy like haproxy is fine.
+  # Using a non-HTTP-aware proxy will leave you vulnerable to
+  # slow client denial-of-service attacks.
+
+  module WriterThreadPool
+    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)
+      def readpartial(size, buf = "")
+        to_io.readpartial(size, buf)
+      end
+
+      def write_nonblock(buf)
+        to_io.write_nonblock(buf)
+      end
+
+      def write(buf)
+        q << [ to_io, buf ]
+      end
+
+      def close
+        q << [ to_io, :close ]
+      end
+
+      def closed?
+        false
+      end
+    end
+
+    alias base_write_body write_body
+    if IO.respond_to?(:copy_stream)
+      undef_method :write_body
+
+      def write_body(qclient, body)
+        qclient.q << [ qclient.to_io, :body, body ]
+      end
+    end
+
+    @@nr = 0
+    @@q = nil
+
+    def process_client(client)
+      @@nr += 1
+      super(QueueSocket[client, @@q[@@nr %= @@q.size]])
+    end
+
+    def worker_loop(worker)
+      # we have multiple, single-thread queues since we don't want to
+      # interleave writes from the same client
+      qp = (1..worker_connections).map do |n|
+        QueuePool.new(1) do |response|
+          begin
+            io, arg1, arg2 = response
+            case arg1
+            when :body then base_write_body(io, arg2)
+            when :close then io.close unless io.closed?
+            else
+              io.write(arg1)
+            end
+          rescue => err
+            Error.app(err)
+          end
+        end
+      end
+
+      @@q = qp.map { |q| q.queue }
+      super(worker) # accept loop from Unicorn
+      qp.map { |q| q.quit! }
+    end
+  end
+end

data/lib/rainbows/writer_thread_spawn.rb

@@ -0,0 +1,113 @@
+# -*- encoding: binary -*-
+require 'thread'
+module Rainbows
+
+  # This concurrency model implements a single-threaded app dispatch and
+  # spawns a new thread for writing responses.  This concurrency model
+  # should be ideal for apps that serve large responses or stream
+  # responses slowly.
+  #
+  # Unlike most \Rainbows! concurrency models, WriterThreadSpawn is
+  # designed to run behind nginx just like Unicorn is.  This concurrency
+  # model may be useful for existing Unicorn users looking for more
+  # output concurrency than socket buffers can provide while still
+  # maintaining a single-threaded application dispatch (though if the
+  # response body is generated on-the-fly, it must be thread safe).
+  #
+  # For serving large or streaming responses, setting
+  # "proxy_buffering off" in nginx is recommended.  If your application
+  # does not handle uploads, then using any HTTP-aware proxy like
+  # haproxy is fine.  Using a non-HTTP-aware proxy will leave you
+  # vulnerable to slow client denial-of-service attacks.
+
+  module WriterThreadSpawn
+    include Base
+
+    CUR = {}
+
+    # used to wrap a BasicSocket to use with +q+ for all writes
+    # this is compatible with IO.select
+    class MySocket < Struct.new(:to_io, :q, :thr)
+      def readpartial(size, buf = "")
+        to_io.readpartial(size, buf)
+      end
+
+      def write_nonblock(buf)
+        to_io.write_nonblock(buf)
+      end
+
+      def queue_writer
+        # not using Thread.pass here because that spins the CPU during
+        # I/O wait and will eat cycles from other worker processes.
+        until CUR.size < MAX
+          CUR.delete_if { |t,_|
+            t.alive? ? t.join(0) : true
+          }.size >= MAX and sleep(0.01)
+        end
+
+        q = Queue.new
+        self.thr = Thread.new(to_io, q) do |io, q|
+          while response = q.shift
+            begin
+              arg1, arg2 = response
+              case arg1
+              when :body then Base.write_body(io, arg2)
+              when :close
+                io.close unless io.closed?
+                break
+              else
+                io.write(arg1)
+              end
+            rescue => e
+              Error.app(e)
+            end
+          end
+          CUR.delete(Thread.current)
+        end
+        CUR[thr] = q
+      end
+
+      def write(buf)
+        (self.q ||= queue_writer) << buf
+      end
+
+      def write_body(body)
+        (self.q ||= queue_writer) << [ :body, body ]
+      end
+
+      def close
+        if q
+          q << :close
+        else
+          to_io.close
+        end
+      end
+
+      def closed?
+        false
+      end
+    end
+
+    if IO.respond_to?(:copy_stream)
+      undef_method :write_body
+
+      def write_body(my_sock, body)
+        my_sock.write_body(body)
+      end
+    end
+
+    def process_client(client)
+      super(MySocket[client])
+    end
+
+    def worker_loop(worker)
+      MySocket.const_set(:MAX, worker_connections)
+      super(worker) # accept loop from Unicorn
+      CUR.delete_if do |t,q|
+        q << nil
+        G.tick
+        t.alive? ? t.join(0.01) : true
+      end until CUR.empty?
+    end
+  end
+end

data/local.mk.sample

@@ -27,7 +27,7 @@ endif
 RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
 
 updir := $(shell git rev-parse --show-cdup)
-gem_paths := $(wildcard $(updir)tmp/gems/$(RUBY_VERSION)/gems/*-*)
+gem_paths := $(wildcard $(updir)tmp/isolate/ruby-$(RUBY_VERSION)/gems/*-*)
 
 ifdef gem_paths
   sp :=

data/rainbows.gemspec

@@ -43,7 +43,7 @@ Gem::Specification.new do |s|
   # we need Unicorn for the HTTP parser and process management
   # The HTTP parser in Unicorn <= 0.97.0 was vulnerable to a remote DoS
   # when exposed directly to untrusted clients.
-  s.add_dependency(%q<unicorn>, [">= 0.97.1", "< 1.0.0"])
+  s.add_dependency(%q<unicorn>, [">= 0.97.1", "< 2.0.0"])
 
   # Unicorn already depends on Rack
   # s.add_dependency(%q<rack>)

data/t/.gitignore

@@ -2,3 +2,4 @@
 /test-bin-*
 /random_blob
 /.dep+*
+/trash

data/t/GNUmakefile

@@ -22,6 +22,8 @@ else
 endif
 export RUBYLIB RUBY_VERSION
 
+models += WriterThreadPool
+models += WriterThreadSpawn
 models += ThreadPool
 models += ThreadSpawn
 models += Rev

data/t/simple-http_WriterThreadPool.ru

@@ -0,0 +1,9 @@
+use Rack::ContentLength
+use Rack::ContentType
+run lambda { |env|
+  if env['rack.multithread'] && env['rainbows.model'] == :WriterThreadPool
+    [ 200, {}, [ Thread.current.inspect << "\n" ] ]
+  else
+    raise "rack.multithread is false"
+  end
+}

data/t/simple-http_WriterThreadSpawn.ru

@@ -0,0 +1,9 @@
+use Rack::ContentLength
+use Rack::ContentType
+run lambda { |env|
+  if env['rack.multithread'] && env['rainbows.model'] == :WriterThreadSpawn
+    [ 200, {}, [ Thread.current.inspect << "\n" ] ]
+  else
+    raise "rack.multithread is false"
+  end
+}

data/t/t0004-heartbeat-timeout.sh

@@ -1,7 +1,7 @@
 #!/bin/sh
 . ./test-lib.sh
 
-t_plan 9 "heartbeat/timeout test for $model"
+t_plan 12 "heartbeat/timeout test for $model"
 
 t_begin "setup and startup" && {
 	rainbows_setup $model
@@ -22,8 +22,9 @@ t_begin "sleep for a bit, ensure worker PID does not change" && {
 }
 
 t_begin "block the worker process to force it to die" && {
+	rm $ok
 	t0=$(date +%s)
-	err="$(curl -sSf http://$listen/block-forever 2>&1 || :)"
+	err="$(curl -sSf http://$listen/block-forever 2>&1 || > $ok)"
 	t1=$(date +%s)
 	elapsed=$(($t1 - $t0))
 	t_info "elapsed=$elapsed err=$err"
@@ -31,9 +32,13 @@ t_begin "block the worker process to force it to die" && {
 	test x"$err" != x"$worker_pid"
 }
 
-t_begin "ensure timeout took 3-6 seconds" && {
+t_begin "ensure worker was killed" && {
+	test -e $ok
+	test 1 -eq $(grep timeout $r_err | grep killing | wc -l)
+}
+
+t_begin "ensure timeout took at least 3 seconds" && {
 	test $elapsed -ge 3
-	test $elapsed -le 6 # give it some slack in case box is bogged down
 }
 
 t_begin "wait for new worker to start up" && {
@@ -45,6 +50,10 @@ t_begin "we get a fresh new worker process" && {
 	test $new_worker_pid -ne $worker_pid
 }
 
+t_begin "truncate the server error log" && {
+	> $r_err
+}
+
 t_begin "SIGSTOP and SIGCONT on rainbows master does not kill worker" && {
 	kill -STOP $rainbows_pid
 	sleep 4
@@ -54,9 +63,11 @@ t_begin "SIGSTOP and SIGCONT on rainbows master does not kill worker" && {
 }
 
 t_begin "stop server" && {
-	kill $rainbows_pid
+	kill -QUIT $rainbows_pid
 }
 
+t_begin "check stderr" && check_stderr
+
 dbgcat r_err
 
 t_done

data/t/t0005-large-file-response.sh

@@ -12,7 +12,7 @@ t_plan 10 "large file response slurp avoidance for $model"
 
 t_begin "setup and startup" && {
 	rtmpfiles curl_out
-	rainbows_setup $model
+	rainbows_setup $model 1
 	# can't load Rack::Lint here since it'll cause Rev to slurp
 	rainbows -E none -D large-file-response.ru -c $unicorn_config
 	rainbows_wait_start
@@ -50,11 +50,11 @@ t_begin "HTTP/1.0 test" && {
 t_begin "HTTP/0.9 test" && {
 	(
 		printf 'GET /random_blob\r\n'
-		cat $fifo > $tmp &
+		rsha1 < $fifo > $tmp &
 		wait
 		echo ok > $ok
 	) | socat - TCP:$listen > $fifo
-	cmp $tmp random_blob
+	test $(cat $tmp) = $(rsha1 < random_blob)
 	test xok = x$(cat $ok)
 }
 
@@ -72,8 +72,12 @@ t_begin "shutdown server" && {
 
 t_begin "compare RSS before and after" && {
 	diff=$(( $rss_after - $rss_before ))
+
+	# default GC malloc limit in MRI:
+	fudge=$(( 8 * 1024 * 1024 ))
+
 	t_info "test diff=$diff < orig=$random_blob_size"
-	test $diff -le $random_blob_size
+	test $diff -le $(( $random_blob_size + $fudge ))
 }
 
 dbgcat r_err

data/t/t0007-worker-follows-master-to-death.sh

@@ -32,7 +32,12 @@ t_begin "nuke the master once we're connected" && {
 }
 
 t_begin "worker is no longer running" && {
-	sleep 6
+	nr=30
+	while kill -0 $worker_pid 2>/dev/null && test $nr -gt 0
+	do
+		nr=$(( $nr - 1))
+		sleep 1
+	done
 	kill -0 $worker_pid 2> $tmp && false
 	test -s $tmp
 }

data/t/t0102-rack-input-short.sh

@@ -8,7 +8,7 @@ t_begin "setup and startup" && {
 	rtmpfiles curl_out curl_err
 	rainbows_setup $model
 	rainbows -D sha1-random-size.ru -c $unicorn_config
-        blob_sha1=$(rsha1 random_blob)
+        blob_sha1=$(rsha1 < random_blob)
         t_info "blob_sha1=$blob_sha1"
 	rainbows_wait_start
 }

data/t/t0103-rack-input-limit.sh

@@ -1,6 +1,7 @@
 #!/bin/sh
 . ./test-lib.sh
 test -r random_blob || die "random_blob required, run with 'make $0'"
+req_curl_chunked_upload_err_check
 
 t_plan 6 "rack.input client_max_body_size default"
 

data/t/t0104-rack-input-limit-tiny.sh

@@ -1,6 +1,7 @@
 #!/bin/sh
 . ./test-lib.sh
 test -r random_blob || die "random_blob required, run with 'make $0'"
+req_curl_chunked_upload_err_check
 
 t_plan 6 "rack.input client_max_body_size tiny"
 

data/t/t0105-rack-input-limit-bigger.sh

@@ -1,5 +1,7 @@
 #!/bin/sh
 . ./test-lib.sh
+test -r random_blob || die "random_blob required, run with 'make $0'"
+req_curl_chunked_upload_err_check
 
 t_plan 10 "rack.input client_max_body_size bigger"
 

data/t/t0200-async-response.sh

@@ -2,6 +2,8 @@
 CONFIG_RU=${CONFIG_RU-'async-response.ru'}
 . ./test-lib.sh
 
+skip_models Base WriterThreadPool WriterThreadSpawn
+
 case $CONFIG_RU in
 *no-autochunk.ru)
 	t_plan 7 "async response w/o autochunk for $model"

data/t/test-lib.sh

@@ -42,6 +42,19 @@ require_check () {
 	fi
 }
 
+skip_models () {
+	for i in "$@"
+	do
+		if test x"$model" != x"$i"
+		then
+			continue
+		fi
+		t_info "skipping $T since it is not compatible with $model"
+		exit 0
+	done
+}
+
+
 # given a list of variable names, create temporary files and assign
 # the pathnames to those variables
 rtmpfiles () {
@@ -146,7 +159,22 @@ rsha1 () {
 
 	# last resort, see comments in sha1sum.rb for reasoning
 	test -n "$_cmd" || _cmd=sha1sum.rb
-	expr "$($_cmd < random_blob)" : '\([a-f0-9]\{40\}\)'
+	expr "$($_cmd)" : '\([a-f0-9]\{40\}\)'
+}
+
+req_curl_chunked_upload_err_check () {
+	set +e
+	curl --version 2>/dev/null | awk '$1 == "curl" {
+		split($2, v, /\./)
+		if ((v[1] < 7) || (v[1] == 7 && v[2] < 18))
+			code = 1
+	}
+	END { exit(code) }'
+	if test $? -ne 0
+	then
+		t_info "curl >= 7.18.0 required for $T"
+		exit 0
+	fi
 }
 
 case $model in

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rainbows
 version: !ruby/object:Gem::Version 
-  version: 0.92.0
+  version: 0.93.0
 platform: ruby
 authors: 
 - Rainbows! hackers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-04 00:00:00 +00:00
+date: 2010-05-29 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -23,7 +23,7 @@ dependencies:
         version: 0.97.1
     - - <
       - !ruby/object:Gem::Version 
-        version: 1.0.0
+        version: 2.0.0
     version: 
 description: |-
   \Rainbows! is an HTTP server for sleepy Rack applications.  It is based on
@@ -61,6 +61,7 @@ extra_rdoc_files:
 - lib/rainbows/max_body.rb
 - lib/rainbows/never_block.rb
 - lib/rainbows/never_block/event_machine.rb
+- lib/rainbows/queue_pool.rb
 - lib/rainbows/rev.rb
 - lib/rainbows/rev/client.rb
 - lib/rainbows/rev/core.rb
@@ -75,6 +76,8 @@ extra_rdoc_files:
 - lib/rainbows/tee_input.rb
 - lib/rainbows/thread_pool.rb
 - lib/rainbows/thread_spawn.rb
+- lib/rainbows/writer_thread_pool.rb
+- lib/rainbows/writer_thread_spawn.rb
 - LICENSE
 - NEWS
 - README
@@ -131,6 +134,7 @@ files:
 - lib/rainbows/max_body.rb
 - lib/rainbows/never_block.rb
 - lib/rainbows/never_block/event_machine.rb
+- lib/rainbows/queue_pool.rb
 - lib/rainbows/rev.rb
 - lib/rainbows/rev/client.rb
 - lib/rainbows/rev/core.rb
@@ -145,6 +149,8 @@ files:
 - lib/rainbows/tee_input.rb
 - lib/rainbows/thread_pool.rb
 - lib/rainbows/thread_spawn.rb
+- lib/rainbows/writer_thread_pool.rb
+- lib/rainbows/writer_thread_spawn.rb
 - local.mk.sample
 - man/man1/rainbows.1
 - rainbows.gemspec
@@ -187,6 +193,8 @@ files:
 - t/simple-http_Revactor.ru
 - t/simple-http_ThreadPool.ru
 - t/simple-http_ThreadSpawn.ru
+- t/simple-http_WriterThreadPool.ru
+- t/simple-http_WriterThreadSpawn.ru
 - t/sleep.ru
 - t/t0000-simple-http.sh
 - t/t0000.ru