rainbows 0.96.0 → 0.97.0

data/FAQ

@@ -2,7 +2,7 @@
 
 === Why is \Rainbows! a separate project from Unicorn?
 
-\Rainbows is for the odd, corner-case requests that Unicorn is poorly
+\Rainbows! is for the odd, corner-case requests that Unicorn is poorly
 suited for.  More scalable concurrency models introduce additional
 complexity that Unicorn users and developers are uncomfortable with for
 the common cases.
@@ -52,9 +52,14 @@ solution even if nginx will always outperform it in raw throughput.
 
 === How do I support SSL?
 
-If you need a streaming "rack.input" to do upload processing within your
-Rack application, then {stunnel}[http://stunnel.org/] is required.
-Otherwise, nginx is a perfectly good reverse proxy.
+If you need streaming "rack.input" to do on-the-fly upload processing
+within your Rack application, then using an SSL proxy such as
+{Pound}[http://www.apsis.ch/pound/] or {Stunnel}[http://stunnel.org/] is
+required.  Pound has built-in X-Forwarded-For support while Stunnel
+requires a extra {patch}[http://haproxy.1wt.eu/download/patches/].
+
+If you don't need streaming "rack.input", then nginx is a great HTTPS
+reverse proxy.
 
 Refer to the {Unicorn FAQ}[http://unicorn.bogomips.org/FAQ.html] on how
 to ensure redirects go to "https://" URLs.
@@ -77,15 +82,15 @@ 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"
+  require "#{::File.expand_path('config/environment')}"
   use Rails::Rack::Static
   run ActionController::Dispatcher.new
 
 For older versions of Rails, the following config.ru will work:
 
   ENV["RAILS_ENV"] ||= ENV["RACK_ENV"]
-  require 'config/boot'
-  require 'config/environment'
+  require "#{::File.expand_path('config/boot')}"
+  require "#{::File.expand_path('config/environment')}"
   require 'unicorn/app/old_rails'
   require 'unicorn/app/old_rails/static' # not needed with Unicorn 0.95+
   use Unicorn::App::OldRails::Static

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -62,7 +62,7 @@ NEWS: GIT-VERSION-FILE
 	$(RAKE) -s news_rdoc > $@+
 	mv $@+ $@
 
-SINCE = 0.95.0
+SINCE = 0.96.0
 ChangeLog: LOG_VERSION = \
   $(shell git rev-parse -q "$(GIT_VERSION)" >/dev/null 2>&1 && \
           echo $(GIT_VERSION) || git describe)

data/README

@@ -67,7 +67,7 @@ network concurrency.
 
 == Applications
 
-\Rainbows is mainly designed for the odd things Unicorn sucks at:
+\Rainbows! is mainly designed for the odd things Unicorn sucks at:
 
 * Web Sockets (via {Sunshowers}[http://rainbows.rubyforge.org/sunshowers/])
 * 3rd-party APIs (to services outside your control/LAN)
@@ -81,7 +81,7 @@ network concurrency.
 * Reverse AJAX
 * real-time upload processing (via {upr}[http://upr.bogomips.org/])
 
-\Rainbows can also be used to service slow clients directly even with
+\Rainbows! can also be used to service slow clients directly even with
 fast applications.
 
 == License
@@ -97,7 +97,7 @@ details.
 
 == Install
 
-You may download the tarball from the Rainbows project page on Rubyforge
+You may download the tarball from the \Rainbows! project page on Rubyforge
 and run setup.rb after unpacking it:
 
 http://rubyforge.org/frs/?group_id=8977

data/lib/rainbows.rb

@@ -30,6 +30,12 @@ module Rainbows
   G = State.new(true, 0, 0, 5)
   O = {}
   class Response416 < RangeError; end
+
+  # map of numeric file descriptors to IO objects to avoid using IO.new
+  # and potentially causing race conditions when using /dev/fd/
+  FD_MAP = {}
+  FD_MAP.compare_by_identity if FD_MAP.respond_to?(:compare_by_identity)
+
   # :startdoc:
 
   require 'rainbows/const'
@@ -69,22 +75,6 @@ module Rainbows
       HttpServer.new(app, options).start.join
     end
 
-    # returns nil if accept fails
-    def sync_accept(sock) # :nodoc:
-      rv = sock.accept
-      rv.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-      rv
-    rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EINTR
-    end
-
-    # returns nil if accept fails
-    def accept(sock) # :nodoc:
-      rv = sock.accept_nonblock
-      rv.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-      rv
-    rescue Errno::EAGAIN, Errno::ECONNABORTED
-    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.
@@ -131,4 +121,6 @@ module Rainbows
   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'

data/lib/rainbows/acceptor.rb

@@ -0,0 +1,26 @@
+# -*- encoding: binary -*-
+
+# :enddoc:
+require 'fcntl'
+
+# this should make life easier for Zbatery if compatibility with
+# fcntl-crippled platforms is required (or if FD_CLOEXEC is inherited)
+# and we want to microptimize away fcntl(2) syscalls.
+module Rainbows::Acceptor
+
+  # returns nil if accept fails
+  def sync_accept(sock)
+    rv = sock.accept
+    rv.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+    rv
+  rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EINTR
+  end
+
+  # returns nil if accept fails
+  def accept(sock)
+    rv = sock.accept_nonblock
+    rv.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+    rv
+  rescue Errno::EAGAIN, Errno::ECONNABORTED
+  end
+end

data/lib/rainbows/base.rb

@@ -1,6 +1,6 @@
 # -*- encoding: binary -*-
 
-# base class for Rainbows concurrency models, this is currently used by
+# 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

data/lib/rainbows/const.rb

@@ -3,7 +3,7 @@
 module Rainbows
 
   module Const
-    RAINBOWS_VERSION = '0.96.0'
+    RAINBOWS_VERSION = '0.97.0'
 
     include Unicorn::Const
 

data/lib/rainbows/dev_fd_response.rb

@@ -14,7 +14,8 @@
 class Rainbows::DevFdResponse < Struct.new(:app)
 
   # :stopdoc:
-  #
+  FD_MAP = Rainbows::FD_MAP
+
   # make this a no-op under Rubinius, it's pointless anyways
   # since Rubinius doesn't have IO.copy_stream
   def self.new(app)
@@ -37,6 +38,7 @@ class Rainbows::DevFdResponse < Struct.new(:app)
     headers = HeaderHash.new(headers)
     st = io.stat
     fileno = io.fileno
+    FD_MAP[fileno] = io
     if st.file?
       headers['Content-Length'] ||= st.size.to_s
       headers.delete('Transfer-Encoding')
@@ -70,7 +72,7 @@ class Rainbows::DevFdResponse < Struct.new(:app)
     end
 
     # remain Rack::Lint-compatible for people with wonky systems :P
-    unless File.exist?("/dev/fd/0")
+    unless File.directory?("/dev/fd")
       alias to_path_orig to_path
       undef_method :to_path
     end

data/lib/rainbows/event_machine.rb

@@ -95,7 +95,8 @@ module Rainbows
         # long-running async response
         (response.nil? || -1 == response[0]) and return @state = :close
 
-        em_write_response(response, alive = @hp.keepalive? && G.alive)
+        alive = @hp.keepalive? && G.alive && G.kato > 0
+        em_write_response(response, alive)
         if alive
           @env.clear
           @hp.reset
@@ -169,6 +170,7 @@ module Rainbows
     end
 
     module Server # :nodoc: all
+      include Rainbows::Acceptor
 
       def close
         detach
@@ -177,7 +179,7 @@ module Rainbows
 
       def notify_readable
         return if CUR.size >= MAX
-        io = Rainbows.accept(@io) or return
+        io = accept(@io) or return
         sig = EM.attach_fd(io.fileno, false)
         CUR[sig] = CL.new(sig, io)
       end

data/lib/rainbows/fiber/rev.rb

@@ -54,6 +54,7 @@ module Rainbows::Fiber
       include Rainbows
       include Rainbows::Const
       include Rainbows::Response
+      include Rainbows::Acceptor
       FIO = Rainbows::Fiber::IO
 
       def to_io
@@ -72,7 +73,7 @@ module Rainbows::Fiber
 
       def on_readable
         return if G.cur >= MAX
-        c = Rainbows.accept(@io) and ::Fiber.new { process(c) }.resume
+        c = accept(@io) and ::Fiber.new { process(c) }.resume
       end
 
       def process(io)

data/lib/rainbows/fiber_pool.rb

@@ -15,6 +15,7 @@ module Rainbows
 
   module FiberPool
     include Fiber::Base
+    include Rainbows::Acceptor
 
     def worker_loop(worker) # :nodoc:
       init_worker_process(worker)
@@ -29,7 +30,7 @@ module Rainbows
       begin
         schedule do |l|
           fib = pool.shift or break # let another worker process take it
-          if io = Rainbows.accept(l)
+          if io = accept(l)
             fib.resume(Fiber::IO.new(io, fib))
           else
             pool << fib

data/lib/rainbows/fiber_spawn.rb

@@ -12,6 +12,7 @@ module Rainbows
 
   module FiberSpawn
     include Fiber::Base
+    include Rainbows::Acceptor
 
     def worker_loop(worker) # :nodoc:
       init_worker_process(worker)
@@ -22,7 +23,7 @@ module Rainbows
       begin
         schedule do |l|
           break if G.cur >= limit
-          io = Rainbows.accept(l) or next
+          io = accept(l) or next
           ::Fiber.new { process_client(fio.new(io, ::Fiber.current)) }.resume
         end
       rescue => e

data/lib/rainbows/response.rb

@@ -34,6 +34,7 @@ module Rainbows::Response
 
   # called after forking
   def self.setup(klass)
+    Rainbows::G.kato == 0 and KEEP_ALIVE.replace(CLOSE)
     range_class = body_class = klass
     case Rainbows::Const::RACK_DEFAULTS['rainbows.model']
     when :WriterThreadSpawn

data/lib/rainbows/response/body.rb

@@ -30,6 +30,12 @@
 module Rainbows::Response::Body # :nodoc:
   ALIASES = {}
 
+  FD_MAP = Rainbows::FD_MAP
+
+  def io_for_fd(fd)
+    FD_MAP.delete(fd) || IO.new(fd)
+  end
+
   # to_io is not part of the Rack spec, but make an exception here
   # since we can conserve path lookups and file descriptors.
   # \Rainbows! will never get here without checking for the existence
@@ -41,7 +47,7 @@ module Rainbows::Response::Body # :nodoc:
       # try to take advantage of Rainbows::DevFdResponse, calling File.open
       # is a last resort
       path = body.to_path
-      path =~ %r{\A/dev/fd/(\d+)\z} ? IO.new($1.to_i) : File.open(path)
+      path =~ %r{\A/dev/fd/(\d+)\z} ? io_for_fd($1.to_i) : File.open(path)
     end
   end
 

data/lib/rainbows/rev/client.rb

@@ -58,7 +58,7 @@ module Rainbows
 
       def next!
         @deferred = nil
-        on_write_complete
+        enable_write_watcher
       end
 
       def timeout?
@@ -170,6 +170,7 @@ module Rainbows
       def on_close
         close_deferred
         CONN.delete(self)
+        KATO.delete(self)
       end
 
     end # module Client

data/lib/rainbows/rev/core.rb

@@ -7,12 +7,12 @@ require 'rainbows/rev/heartbeat'
 module Rainbows
   module Rev
     class Server < ::Rev::IO
-      G = Rainbows::G
+      include Rainbows::Acceptor
       # CL and MAX will be defined in the corresponding worker loop
 
       def on_readable
         return if CONN.size >= MAX
-        io = Rainbows.accept(@_io) and CL.new(io).attach(LOOP)
+        io = accept(@_io) and CL.new(io).attach(LOOP)
       end
     end # class Server
 

data/lib/rainbows/rev/heartbeat.rb

@@ -11,7 +11,7 @@ module Rainbows
     class Heartbeat < ::Rev::TimerWatcher
 
       def on_timer
-        if (ot = G.kato) > 0
+        if (ot = G.kato) >= 0
           ot = Time.now - ot
           KATO.delete_if { |client, time| time < ot and client.timeout? }
         end

data/lib/rainbows/rev/master.rb

@@ -2,25 +2,20 @@
 # :enddoc:
 require 'rainbows/rev'
 
-module Rainbows
+class Rainbows::Rev::Master < Rev::AsyncWatcher
 
-  module Rev
-    class Master < ::Rev::AsyncWatcher
-
-      def initialize(queue)
-        super()
-        @queue = queue
-      end
+  def initialize(queue)
+    super()
+    @queue = queue
+  end
 
-      def <<(output)
-        @queue << output
-        signal
-      end
+  def <<(output)
+    @queue << output
+    signal
+  end
 
-      def on_signal
-        client, response = @queue.pop
-        client.response_write(response)
-      end
-    end
+  def on_signal
+    client, response = @queue.pop
+    client.response_write(response)
   end
 end

data/lib/rainbows/revactor.rb

@@ -62,7 +62,7 @@ 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
+        env = false unless hp.keepalive? && G.alive && G.kato > 0
         headers[CONNECTION] = env ? KEEP_ALIVE : CLOSE
         client.write(response_header(status, headers))
       end

data/lib/rainbows/thread_pool.rb

@@ -24,6 +24,7 @@ module Rainbows
   module ThreadPool
 
     include Base
+    include Rainbows::Acceptor
 
     def worker_loop(worker) # :nodoc:
       init_worker_process(worker)
@@ -44,7 +45,7 @@ module Rainbows
     def sync_worker # :nodoc:
       s = LISTENERS[0]
       begin
-        c = Rainbows.sync_accept(s) and process_client(c)
+        c = sync_accept(s) and process_client(c)
       rescue => e
         Error.listen_loop(e)
       end while G.alive
@@ -58,7 +59,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 = Rainbows.accept(s) and process_client(s)
+          s = accept(s) and process_client(s)
         end
       rescue Errno::EINTR
       rescue => e

data/lib/rainbows/thread_spawn.rb

@@ -18,6 +18,7 @@ module Rainbows
 
   module ThreadSpawn
     include Base
+    include Rainbows::Acceptor
 
     def accept_loop(klass) #:nodoc:
       lock = Mutex.new
@@ -36,7 +37,7 @@ module Rainbows
               # 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)
+            elsif c = sync_accept(l)
               klass.new(c) do |c|
                 begin
                   lock.synchronize { G.cur += 1 }

data/lib/rainbows/thread_timeout.rb

@@ -0,0 +1,94 @@
+# -*- encoding: binary -*-
+require 'thread'
+
+# Soft timeout middleware for thread-based concurrency models in \Rainbows!
+# This timeout only includes application dispatch, and will not take into
+# account the (rare) response bodies that are dynamically generated while
+# they are being written out to the client.
+#
+# In your rackup config file (config.ru), the following line will
+# cause execution to timeout in 1.5 seconds.
+#
+#    use Rainbows::ThreadTimeout, :timeout => 1.5
+#    run MyApplication.new
+#
+# You may also specify a threshold, so the timeout does not take
+# effect until there are enough active clients.  It does not make
+# sense to set a +:threshold+ higher or equal to the
+# +worker_connections+ \Rainbows! configuration parameter.
+# You may specify a negative threshold to be an absolute
+# value relative to the +worker_connections+ parameter, thus
+# if you specify a threshold of -1, and have 100 worker_connections,
+# ThreadTimeout will only activate when there are 99 active requests.
+#
+#    use Rainbows::ThreadTimeout, :timeout => 1.5, :threshold => -1
+#    run MyApplication.new
+#
+# This middleware only affects elements below it in the stack, so
+# it can be configured to ignore certain endpoints or middlewares.
+#
+# Timed-out requests will cause this middleware to return with a
+# "408 Request Timeout" response.
+
+class Rainbows::ThreadTimeout < Struct.new(:app, :timeout,
+                                           :threshold, :watchdog,
+                                           :active, :lock)
+
+  # :stopdoc:
+  class ExecutionExpired < ::Exception
+  end
+
+  def initialize(app, opts)
+    timeout = opts[:timeout]
+    Numeric === timeout or
+      raise TypeError, "timeout=#{timeout.inspect} is not numeric"
+
+    if threshold = opts[:threshold]
+      Integer === threshold or
+        raise TypeError, "threshold=#{threshold.inspect} is not an integer"
+      threshold == 0 and
+        raise ArgumentError, "threshold=0 does not make sense"
+      threshold < 0 and
+        threshold += Rainbows::G.server.worker_connections
+    end
+    super(app, timeout, threshold, nil, {}, Mutex.new)
+  end
+
+  def call(env)
+    lock.synchronize do
+      start_watchdog unless watchdog
+      active[Thread.current] = Time.now + timeout
+    end
+    begin
+      app.call(env)
+    ensure
+      lock.synchronize { active.delete(Thread.current) }
+    end
+    rescue ExecutionExpired
+      [ 408, { 'Content-Type' => 'text/plain', 'Content-Length' => '0' }, [] ]
+  end
+
+  def start_watchdog
+    self.watchdog = Thread.new do
+      begin
+        if next_wake = lock.synchronize { active.values }.min
+          next_wake -= Time.now
+          sleep(next_wake) if next_wake > 0
+        else
+          sleep(timeout)
+        end
+
+        # "active.size" is atomic in MRI 1.8 and 1.9
+        next if threshold && active.size < threshold
+
+        now = Time.now
+        lock.synchronize do
+          active.delete_if do |thread, time|
+            time >= now and thread.raise(ExecutionExpired).nil?
+          end
+        end
+      end while true
+    end
+  end
+  # :startdoc:
+end

data/rainbows.gemspec

@@ -46,7 +46,7 @@ Gem::Specification.new do |s|
   # 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.1", "< 2.0.0"])
+  s.add_dependency(%q<unicorn>, [">= 1.1.3", "< 2.0.0"])
   s.add_development_dependency(%q<isolate>, "~> 2.1.0")
 
   # optional runtime dependencies depending on configuration

data/t/close-pipe-to_path-response.ru

@@ -0,0 +1,30 @@
+# must be run without Rack::Lint since that clobbers to_path
+class MyMiddleware < Struct.new(:app)
+  class Body < Struct.new(:body, :to_path)
+    def each(&block); body.each(&block); end
+    def close
+      c = body.respond_to?(:close)
+      ::File.open(ENV['fifo'], 'wb') do |fp|
+        fp.syswrite("CLOSING #{body.inspect} #{to_path} (#{c})\n")
+      end
+      body.close if c
+    end
+  end
+
+  def call(env)
+    status, headers, body = app.call(env)
+    body.respond_to?(:to_path) and body = Body.new(body, body.to_path)
+    [ status, headers, body ]
+  end
+end
+use MyMiddleware
+use Rainbows::DevFdResponse
+run(lambda { |env|
+  io = IO.popen('cat random_blob', 'rb')
+  [ 200,
+    {
+      'Content-Length' => ::File.stat('random_blob').size.to_s,
+      'Content-Type' => 'application/octet-stream',
+    },
+    io ]
+})

data/t/t0016-onenine-encoding-is-tricky.sh

@@ -4,7 +4,7 @@ t_plan 4 "proper handling of onenine encoding for $model"
 
 t_begin "setup and startup" && {
 	rainbows_setup $model
-	rainbows -D ./t0016.rb -c $unicorn_config
+	rainbows -E none -D ./t0016.rb -c $unicorn_config
 	rainbows_wait_start
 	expect_sha1=8ff79d8115f9fe38d18be858c66aa08a1cc27a66
 }

data/t/t0017-keepalive-timeout-zero.sh

@@ -0,0 +1,43 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 6 "keepalive_timeout 0 tests for $model"
+
+t_begin "setup and start" && {
+	rainbows_setup $model 2 0
+        grep 'keepalive_timeout 0' $unicorn_config
+	rainbows -D env.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin 'check server responds with Connection: close' && {
+	curl -sSfi http://$listen/ | grep 'Connection: close'
+}
+
+t_begin "send keepalive response that does not expect close" && {
+	req='GET / HTTP/1.1\r\nHost: example.com\r\n\r\n'
+	t0=$(date +%s)
+	(
+		cat $fifo > $tmp &
+		printf "$req"
+		wait
+		date +%s > $ok
+	) | socat - TCP:$listen > $fifo
+	now="$(cat $ok)"
+	elapsed=$(( $now - $t0 ))
+	t_info "elapsed=$elapsed (expecting <=3)"
+	test $elapsed -le 3
+}
+
+t_begin "'Connection: close' header set" && {
+	grep 'Connection: close' $tmp
+}
+
+t_begin "killing succeeds" && {
+	kill $rainbows_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/t/t0032-close-pipe-to_path-response.sh

@@ -0,0 +1,101 @@
+#!/bin/sh
+. ./test-lib.sh
+if ! test -d /dev/fd
+then
+	t_info "skipping $T since /dev/fd is required"
+	exit 0
+fi
+
+t_plan 16 "close pipe to_path response for $model"
+
+t_begin "setup and startup" && {
+	rtmpfiles err out http_fifo sub_ok
+	rainbows_setup $model
+	export fifo
+	rainbows -E none -D close-pipe-to_path-response.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "read random blob sha1" && {
+	random_blob_sha1=$(rsha1 < random_blob)
+}
+
+t_begin "start FIFO reader" && {
+	cat $fifo > $out &
+}
+
+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 "body.close called" && {
+	wait # for cat $fifo
+	grep CLOSING $out || die "body.close not logged"
+}
+
+t_begin "start FIFO reader for abortive HTTP/1.1 request" && {
+	cat $fifo > $out &
+}
+
+t_begin "send abortive HTTP/1.1 request" && {
+	rm -f $ok
+	(
+		printf 'GET /random_blob HTTP/1.1\r\nHost: example.com\r\n\r\n'
+		dd bs=4096 count=1 < $http_fifo >/dev/null
+		echo ok > $ok
+	) | socat - TCP:$listen > $http_fifo || :
+	test xok = x$(cat $ok)
+}
+
+t_begin "body.close called for aborted HTTP/1.1 request" && {
+	wait # for cat $fifo
+	grep CLOSING $out || die "body.close not logged"
+}
+
+t_begin "start FIFO reader for abortive HTTP/1.0 request" && {
+	cat $fifo > $out &
+}
+
+t_begin "send abortive HTTP/1.0 request" && {
+	rm -f $ok
+	(
+		printf 'GET /random_blob HTTP/1.0\r\n\r\n'
+		dd bs=4096 count=1 < $http_fifo >/dev/null
+		echo ok > $ok
+	) | socat - TCP:$listen > $http_fifo || :
+	test xok = x$(cat $ok)
+}
+
+t_begin "body.close called for aborted HTTP/1.0 request" && {
+	wait # for cat $fifo
+	grep CLOSING $out || die "body.close not logged"
+}
+
+t_begin "start FIFO reader for abortive HTTP/0.9 request" && {
+	cat $fifo > $out &
+}
+
+t_begin "send abortive HTTP/0.9 request" && {
+	rm -f $ok
+	(
+		printf 'GET /random_blob\r\n'
+		dd bs=4096 count=1 < $http_fifo >/dev/null
+		echo ok > $ok
+	) | socat - TCP:$listen > $http_fifo || :
+	test xok = x$(cat $ok)
+}
+
+t_begin "body.close called for aborted HTTP/0.9 request" && {
+	wait # for cat $fifo
+	grep CLOSING $out || die "body.close not logged"
+}
+
+t_begin "shutdown server" && {
+	kill -QUIT $rainbows_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/t/t9100-thread-timeout.sh

@@ -0,0 +1,36 @@
+#!/bin/sh
+. ./test-lib.sh
+case $model in
+ThreadSpawn|ThreadPool|RevThreadSpawn|RevThreadPool) ;;
+*) t_info "$0 is only compatible with Thread*"; exit 0 ;;
+esac
+
+t_plan 5 "ThreadTimeout Rack middleware test for $model"
+
+t_begin "configure and start" && {
+	rtmpfiles curl_err
+	rainbows_setup
+	rainbows -D t9100.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "normal request should not timeout" && {
+	test x"HI" = x"$(curl -sSf http://$listen/ 2>> $curl_err)"
+}
+
+t_begin "sleepy request times out with 408" && {
+	rm -f $ok
+	curl -sSf http://$listen/2 2>> $curl_err || > $ok
+	test -e $ok
+	grep 408 $curl_err
+}
+
+t_begin "kill server" && {
+	kill $rainbows_pid
+}
+
+t_begin "no errors in Rainbows! stderr" && {
+	check_stderr
+}
+
+t_done

data/t/t9100.ru

@@ -0,0 +1,9 @@
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+use Rainbows::ThreadTimeout, :timeout => 1
+run lambda { |env|
+  if env["PATH_INFO"] =~ %r{/([\d\.]+)\z}
+    Rainbows.sleep($1.to_f)
+  end
+  [ 200, [], [ "HI\n" ] ]
+}

data/t/t9101-thread-timeout-threshold.sh

@@ -0,0 +1,62 @@
+#!/bin/sh
+. ./test-lib.sh
+case $model in
+ThreadSpawn|ThreadPool|RevThreadSpawn|RevThreadPool) ;;
+*) t_info "$0 is only compatible with Thread*"; exit 0 ;;
+esac
+
+t_plan 6 "ThreadTimeout Rack middleware test for $model"
+
+t_begin "configure and start" && {
+	rtmpfiles curl_err curl_out
+	rainbows_setup $model 10
+	rainbows -D t9101.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "normal request should not timeout" && {
+	test x"HI" = x"$(curl -sSf http://$listen/ 2>> $curl_err)"
+}
+
+t_begin "8 sleepy requests do not time out" && {
+	> $curl_err
+	for i in 1 2 3 4 5 6 7 8
+	do
+		curl --no-buffer -sSf http://$listen/3 \
+		  2>> $curl_err >> $curl_out &
+	done
+	wait
+	test 8 -eq "$(wc -l < $curl_out)"
+	test xHI = x"$(sort < $curl_out | uniq)"
+}
+
+t_begin "9 sleepy requests do time out" && {
+	> $curl_err
+	> $curl_out
+	for i in 1 2 3 4 5 6 7 8 9
+	do
+		rtmpfiles curl_err_$i
+		curl -sSf --no-buffer \
+		  http://$listen/3 2>> ${curl_err}_${i} >> $curl_out &
+	done
+	wait
+	if test -s $curl_out
+	then
+		dbgcat curl_out
+		die "$curl_out should be empty"
+	fi
+	for i in 1 2 3 4 5 6 7 8 9
+	do
+		grep 408 ${curl_err}_${i}
+	done
+}
+
+t_begin "kill server" && {
+	kill $rainbows_pid
+}
+
+t_begin "no errors in Rainbows! stderr" && {
+	check_stderr
+}
+
+t_done

data/t/t9101.ru

@@ -0,0 +1,9 @@
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+use Rainbows::ThreadTimeout, :timeout => 1, :threshold => -1
+run lambda { |env|
+  if env["PATH_INFO"] =~ %r{/([\d\.]+)\z}
+    Rainbows.sleep($1.to_f)
+  end
+  [ 200, [], [ "HI\n" ] ]
+}

data/t/test_isolate.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rainbows
 version: !ruby/object:Gem::Version 
-  hash: 415
+  hash: 411
   prerelease: false
   segments: 
   - 0
-  - 96
+  - 97
   - 0
-  version: 0.96.0
+  version: 0.97.0
 platform: ruby
 authors: 
 - Rainbows! hackers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-03 00:00:00 +00:00
+date: 2010-08-28 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,12 +41,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 17
+        hash: 21
         segments: 
         - 1
         - 1
-        - 1
-        version: 1.1.1
+        - 3
+        version: 1.1.3
     - - <
       - !ruby/object:Gem::Version 
         hash: 15
@@ -87,6 +87,7 @@ extra_rdoc_files:
 - DEPLOY
 - FAQ
 - lib/rainbows.rb
+- lib/rainbows/acceptor.rb
 - lib/rainbows/actor_spawn.rb
 - lib/rainbows/app_pool.rb
 - lib/rainbows/base.rb
@@ -138,6 +139,7 @@ extra_rdoc_files:
 - lib/rainbows/tee_input.rb
 - lib/rainbows/thread_pool.rb
 - lib/rainbows/thread_spawn.rb
+- lib/rainbows/thread_timeout.rb
 - lib/rainbows/writer_thread_pool.rb
 - lib/rainbows/writer_thread_spawn.rb
 - LICENSE
@@ -178,6 +180,7 @@ files:
 - Test_Suite
 - bin/rainbows
 - lib/rainbows.rb
+- lib/rainbows/acceptor.rb
 - lib/rainbows/actor_spawn.rb
 - lib/rainbows/app_pool.rb
 - lib/rainbows/base.rb
@@ -229,6 +232,7 @@ files:
 - lib/rainbows/tee_input.rb
 - lib/rainbows/thread_pool.rb
 - lib/rainbows/thread_spawn.rb
+- lib/rainbows/thread_timeout.rb
 - lib/rainbows/writer_thread_pool.rb
 - lib/rainbows/writer_thread_spawn.rb
 - local.mk.sample
@@ -250,6 +254,7 @@ files:
 - t/bin/unused_listen
 - t/bin/utee
 - t/close-pipe-response.ru
+- t/close-pipe-to_path-response.ru
 - t/content-md5.ru
 - t/cramp/README
 - t/cramp/rainsocket.ru
@@ -302,6 +307,7 @@ files:
 - t/t0015-working_directory.sh
 - t/t0016-onenine-encoding-is-tricky.sh
 - t/t0016.rb
+- t/t0017-keepalive-timeout-zero.sh
 - t/t0020-large-sendfile-response.sh
 - t/t0021-sendfile-wrap-to_path.sh
 - t/t0022-copy_stream-byte-range.sh
@@ -309,6 +315,7 @@ files:
 - t/t0024-pipelined-sendfile-response.sh
 - t/t0030-fast-pipe-response.sh
 - t/t0031-close-pipe-response.sh
+- t/t0032-close-pipe-to_path-response.sh
 - t/t0034-pipelined-pipe-response.sh
 - t/t0100-rack-input-hammer-chunked.sh
 - t/t0100-rack-input-hammer-content-length.sh
@@ -332,6 +339,10 @@ files:
 - t/t9001.ru
 - t/t9002-server-token.sh
 - t/t9002.ru
+- t/t9100-thread-timeout.sh
+- t/t9100.ru
+- t/t9101-thread-timeout-threshold.sh
+- t/t9101.ru
 - t/test-lib.sh
 - t/test_isolate.rb
 - t/worker-follows-master-to-death.ru