rainbows 0.90.0 → 0.90.1

data/Documentation/rainbows.1.txt

@@ -12,10 +12,9 @@ rainbows [-c CONFIG_FILE] [-E RACK_ENV] [-D] [RACKUP_FILE]
 
 # DESCRIPTION
 
-A rackup(1)-like command to launch Rack applications using
-Rainbows!.  It is expected to be started in your application root
-(APP_ROOT), but "Dir.chdir" may also be executed in the CONFIG_FILE or
-RACKUP_FILE.
+A rackup(1)-like command to launch Rack applications using Rainbows!.
+It is expected to be started in your application root (APP_ROOT),
+but the "working_directory" directive may be used in the CONFIG_FILE.
 
 While Rainbows! takes a myriad of command-line options for
 compatibility with ruby(1) and rackup(1), it is recommended to stick
@@ -34,10 +33,9 @@ with rackup(1) but strongly discouraged.
 # UNICORN OPTIONS
 -c, \--config-file CONFIG_FILE
 :   Path to the Unicorn-specific config file.  The config file is
-    implemented as a Ruby DSL, so Ruby code may executed (e.g.
-    "Dir.chdir", "Process::UID.change_privilege").  See the RDoc/ri
-    for the *Unicorn::Configurator* class for the full list of
-    directives available from the DSL.
+    implemented as a Ruby DSL, so Ruby code may executed.
+    See the RDoc/ri for the *Unicorn::Configurator* class for the full
+    list of directives available from the DSL.
 
 -D, \--daemonize
 :   Run daemonized in the background.  The process is detached from

data/GIT-VERSION-GEN

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

data/TODO

@@ -3,14 +3,15 @@
 We're lazy and pick the easy items to do first, then the ones people
 care about.
 
+* Split out NeverBlock into NeverBlockEventMachine and NeverBlockReactor
+  NeverBlock will default to one of them (depending on NB upstream).
+
 * Improve test suite coverage.  We won't waste cycles with puny
   unit tests, only integration tests that exercise externally
   visible parts.
 
 * EventMachine.spawn - should be like Revactor, maybe?
 
-* EventMachine deferrables
-
 * conditional app.deferred?(env) support
   Merb uses it, some other servers support it
 

data/lib/rainbows.rb

@@ -60,6 +60,13 @@ module Rainbows
 
     # returns nil if accept fails
     if defined?(Fcntl::FD_CLOEXEC)
+      def sync_accept(sock)
+        rv = sock.accept
+        rv.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+        rv
+      rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EINTR
+      end
+
       def accept(sock)
         rv = sock.accept_nonblock
         rv.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
@@ -67,6 +74,11 @@ module Rainbows
       rescue Errno::EAGAIN, Errno::ECONNABORTED
       end
     else
+      def sync_accept(sock)
+        sock.accept
+      rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EINTR
+      end
+
       def accept(sock)
         sock.accept_nonblock
       rescue Errno::EAGAIN, Errno::ECONNABORTED

data/lib/rainbows/const.rb

@@ -3,7 +3,7 @@
 module Rainbows
 
   module Const
-    RAINBOWS_VERSION = '0.90.0'
+    RAINBOWS_VERSION = '0.90.1'
 
     include Unicorn::Const
 

data/lib/rainbows/ev_core.rb

@@ -11,6 +11,8 @@ module Rainbows
     # Apps may return this Rack response: AsyncResponse = [ -1, {}, [] ]
     ASYNC_CALLBACK = "async.callback".freeze
 
+    ASYNC_CLOSE = "async.close".freeze
+
     def post_init
       @remote_addr = ::TCPSocket === @_io ? @_io.peeraddr.last : LOCALHOST
       @env = {}

data/lib/rainbows/event_machine.rb

@@ -37,6 +37,7 @@ module Rainbows
 
       def initialize(io)
         @_io = io
+        @body = nil
       end
 
       alias write send_data
@@ -54,6 +55,9 @@ module Rainbows
           @env[REMOTE_ADDR] = @remote_addr
           @env[ASYNC_CALLBACK] = method(:response_write)
 
+          # we're not sure if anybody uses this, but Thin sets it, too
+          @env[ASYNC_CLOSE] = EM::DefaultDeferrable.new
+
           response = catch(:async) { APP.call(@env.update(RACK_DEFAULTS)) }
 
           # too tricky to support pipelining with :async since the
@@ -77,9 +81,14 @@ module Rainbows
         end while true
       end
 
-      def response_write(response, out = [], alive = false)
-        body = response.last
-        unless body.respond_to?(:to_path)
+      def response_write(response, out = [ CONN_CLOSE ], alive = false)
+        @body = body = response.last
+        if body.respond_to?(:errback) && body.respond_to?(:callback)
+          body.callback { quit }
+          body.errback { quit }
+          HttpResponse.write(self, response, out)
+          return
+        elsif ! body.respond_to?(:to_path)
           HttpResponse.write(self, response, out)
           quit unless alive
           return
@@ -120,6 +129,8 @@ module Rainbows
       end
 
       def unbind
+        async_close = @env[ASYNC_CLOSE] and async_close.succeed
+        @body.respond_to?(:fail) and @body.fail
         @_io.close
       end
     end

data/lib/rainbows/thread_pool.rb

@@ -44,8 +44,7 @@ module Rainbows
     def sync_worker
       s = LISTENERS.first
       begin
-        process_client(s.accept)
-      rescue Errno::EINTR, Errno::ECONNABORTED
+        c = Rainbows.sync_accept(s) and process_client(c)
       rescue => e
         Error.listen_loop(e)
       end while G.alive

data/lib/rainbows/thread_spawn.rb

@@ -34,8 +34,8 @@ module Rainbows
               # unlikely one.  Since this case is (or should be) uncommon,
               # just busy wait when we have to.
               sleep(0.01)
-            else
-              klass.new(l.accept) do |c|
+            elsif c = Rainbows.sync_accept(l)
+              klass.new(c) do |c|
                 begin
                   lock.synchronize { G.cur += 1 }
                   process_client(c)
@@ -44,7 +44,6 @@ module Rainbows
                 end
               end
             end
-          rescue Errno::EINTR, Errno::ECONNABORTED
           rescue => e
             Error.listen_loop(e)
           end while G.alive

data/rainbows.gemspec

@@ -41,8 +41,7 @@ Gem::Specification.new do |s|
   s.test_files = test_files
 
   # we need Unicorn for the HTTP parser and process management
-  # Unicorn 0.95.0 should be released on or around Nov 13/14/15, 2009
-  s.add_dependency(%q<unicorn>, ["~> 0.95.0"])
+  s.add_dependency(%q<unicorn>, ["~> 0.95.0", "< 0.97.0"])
 
   # Unicorn already depends on Rack
   # s.add_dependency(%q<rack>)

data/t/async_examples/README

@@ -0,0 +1,3 @@
+These examples in this directory are stolen from Thin 1.2.5 with only
+trivial changes.  All examples in this directory retain their original
+license (MIT) and copyrights.

data/t/async_examples/async_app.ru

@@ -0,0 +1,126 @@
+#!/usr/bin/env rackup -s thin
+#
+#  async_app.ru
+#  raggi/thin
+#
+#   A second demo app for async rack + thin app processing!
+#   Now using http status code 100 instead.
+#
+#  Created by James Tucker on 2008-06-17.
+#  Copyright 2008 James Tucker <raggi@rubyforge.org>.
+#
+#--
+# Benchmark Results:
+#
+# raggi@mbk:~$ ab -c 100 -n 500 http://127.0.0.1:3000/
+# This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0
+# Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
+# Copyright 2006 The Apache Software Foundation, http://www.apache.org/
+#
+# Benchmarking 127.0.0.1 (be patient)
+# Completed 100 requests
+# Completed 200 requests
+# Completed 300 requests
+# Completed 400 requests
+# Finished 500 requests
+#
+#
+# Server Software:        thin
+# Server Hostname:        127.0.0.1
+# Server Port:            3000
+#
+# Document Path:          /
+# Document Length:        12 bytes
+#
+# Concurrency Level:      100
+# Time taken for tests:   5.263089 seconds
+# Complete requests:      500
+# Failed requests:        0
+# Write errors:           0
+# Total transferred:      47000 bytes
+# HTML transferred:       6000 bytes
+# Requests per second:    95.00 [#/sec] (mean)
+# Time per request:       1052.618 [ms] (mean)
+# Time per request:       10.526 [ms] (mean, across all concurrent requests)
+# Transfer rate:          8.55 [Kbytes/sec] received
+#
+# Connection Times (ms)
+#               min  mean[+/-sd] median   max
+# Connect:        0    3   2.2      3       8
+# Processing:  1042 1046   3.1   1046    1053
+# Waiting:     1037 1042   3.6   1041    1050
+# Total:       1045 1049   3.1   1049    1057
+#
+# Percentage of the requests served within a certain time (ms)
+#   50%   1049
+#   66%   1051
+#   75%   1053
+#   80%   1053
+#   90%   1054
+#   95%   1054
+#   98%   1056
+#   99%   1057
+#  100%   1057 (longest request)
+
+class DeferrableBody
+  include EventMachine::Deferrable
+
+  def call(body)
+    body.each do |chunk|
+      @body_callback.call(chunk)
+    end
+  end
+
+  def each &blk
+    @body_callback = blk
+  end
+
+end
+
+class AsyncApp
+
+  # This is a template async response. N.B. Can't use string for body on 1.9
+  AsyncResponse = [-1, {}, []].freeze
+
+  def call(env)
+
+    body = DeferrableBody.new
+
+    # Get the headers out there asap, let the client know we're alive...
+    EventMachine::next_tick { env['async.callback'].call [200, {'Content-Type' => 'text/plain'}, body] }
+
+    # Semi-emulate a long db request, instead of a timer, in reality we'd be
+    # waiting for the response data. Whilst this happens, other connections
+    # can be serviced.
+    # This could be any callback based thing though, a deferrable waiting on
+    # IO data, a db request, an http request, an smtp send, whatever.
+    EventMachine::add_timer(1) {
+      body.call ["Woah, async!\n"]
+
+      EventMachine::next_tick {
+        # This could actually happen any time, you could spawn off to new
+        # threads, pause as a good looking lady walks by, whatever.
+        # Just shows off how we can defer chunks of data in the body, you can
+        # even call this many times.
+        body.call ["Cheers then!"]
+        body.succeed
+      }
+    }
+
+    # throw :async # Still works for supporting non-async frameworks...
+
+    AsyncResponse # May end up in Rack :-)
+  end
+
+end
+
+# The additions to env for async.connection and async.callback absolutely
+# destroy the speed of the request if Lint is doing it's checks on env.
+# It is also important to note that an async response will not pass through
+# any further middleware, as the async response notification has been passed
+# right up to the webserver, and the callback goes directly there too.
+# Middleware could possibly catch :async, and also provide a different
+# async.connection and async.callback.
+
+# use Rack::Lint
+run AsyncApp.new

data/t/async_examples/async_tailer.ru

@@ -0,0 +1,105 @@
+#!/usr/bin/env rackup -s thin
+#
+#  async_tailer.ru
+#  raggi/thin
+#
+#  Tested with 150 spawned tails on OS X
+#
+#  Created by James Tucker on 2008-06-18.
+#  Copyright 2008 James Tucker <raggi@rubyforge.org>.
+
+# Uncomment if appropriate for you..
+# EM.epoll
+# EM.kqueue
+
+tail_log_file = ENV["TAIL_LOG_FILE"] or abort "TAIL_LOG_FILE= env must be set"
+unless ::File.file?(tail_log_file) && ::File.readable?(tail_log_file)
+  abort "#{tail_log_file} must be a readable regular file"
+end
+
+class DeferrableBody
+  include EventMachine::Deferrable
+
+  def initialize
+    @queue = []
+    # make sure to flush out the queue before closing the connection
+    callback{
+      until @queue.empty?
+        @queue.shift.each{|chunk| @body_callback.call(chunk) }
+      end
+    }
+  end
+
+  def schedule_dequeue
+    return unless @body_callback
+    EventMachine::next_tick do
+      next unless body = @queue.shift
+      body.each do |chunk|
+        @body_callback.call(chunk)
+      end
+      schedule_dequeue unless @queue.empty?
+    end
+  end
+
+  def call(body)
+    @queue << body
+    schedule_dequeue
+  end
+
+  def each &blk
+    @body_callback = blk
+    schedule_dequeue
+  end
+
+end
+
+module TailRenderer
+  attr_accessor :callback
+
+  def receive_data(data)
+    @callback.call([data])
+  end
+
+  def unbind
+    @callback.succeed
+  end
+end
+
+class AsyncTailer
+
+  AsyncResponse = [-1, {}, []].freeze
+
+  def call(env)
+
+    body = DeferrableBody.new
+
+    EventMachine::next_tick do
+
+      env['async.callback'].call [200, {'Content-Type' => 'text/html'}, body]
+
+      body.call ["<h1>Async Tailer</h1><pre>"]
+
+    end
+
+    EventMachine::popen("tail -f #{ENV["TAIL_LOG_FILE"]}", TailRenderer) do |t|
+
+      t.callback = body
+
+      # If for some reason we 'complete' body, close the tail.
+      body.callback do
+        t.close_connection
+      end
+
+      # If for some reason the client disconnects, close the tail.
+      body.errback do
+        t.close_connection
+      end
+
+    end
+
+    AsyncResponse
+  end
+
+end
+
+run AsyncTailer.new

data/t/t0012-spurious-wakeups-quiet.sh

@@ -0,0 +1,41 @@
+#!/bin/sh
+nr=${nr-4}
+. ./test-lib.sh
+
+# ApacheBench (ab) is commonly installed in the sbin paths in Debian-based
+# systems...
+AB="$(which ab 2>/dev/null || :)"
+if test -z "$AB"
+then
+	AB=$(PATH=/usr/local/sbin:/usr/sbin:$PATH which ab 2>/dev/null || :)
+fi
+
+if test -z "$AB"
+then
+	t_info "skipping $T since 'ab' could not be found"
+	exit 0
+fi
+
+t_plan 4 "quiet spurious wakeups for $model"
+
+t_begin "setup and start" && {
+	rainbows_setup $model
+	echo "preload_app true" >> $unicorn_config
+	echo "worker_processes $nr" >> $unicorn_config
+	rainbows -D env.ru -c $unicorn_config -E none
+	rainbows_wait_start
+}
+
+t_begin "spam the server with requests" && {
+	$AB -c1 -n100 http://$listen/
+}
+
+t_begin "killing succeeds" && {
+	kill -QUIT $rainbows_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/t/t0400-em-async-app.sh

@@ -0,0 +1,57 @@
+#!/bin/sh
+nr=${nr-5}
+. ./test-lib.sh
+case $model in
+NeverBlock|EventMachine) ;;
+*)
+	t_info "skipping $T since it's not compatible with $model"
+	exit 0
+	;;
+esac
+
+t_plan 7 "async_app test for test for EM"
+
+CONFIG_RU=async_examples/async_app.ru
+
+t_begin "setup and start" && {
+	rainbows_setup
+	rtmpfiles a b c curl_err expect
+
+	# this does not does not support Rack::Lint
+	rainbows -E deployment -D $CONFIG_RU -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "send async requests off in parallel" && {
+	t0=$(date +%s)
+	curl --no-buffer -sSf http://$listen/ > $a 2>> $curl_err &
+	curl --no-buffer -sSf http://$listen/ > $b 2>> $curl_err &
+	curl --no-buffer -sSf http://$listen/ > $c 2>> $curl_err &
+}
+
+t_begin "wait for curl terminations" && {
+	wait
+	t1=$(date +%s)
+	elapsed=$(( $t1 - $t0 ))
+	t_info "elapsed=$elapsed"
+}
+
+t_begin "termination signal sent" && {
+	kill $rainbows_pid
+}
+
+t_begin "no errors from curl" && {
+	test ! -s $curl_err
+}
+
+t_begin "no errors in stderr" && check_stderr
+
+t_begin "responses match expected" && {
+	echo 'Woah, async!' > $expect
+	printf 'Cheers then!' >> $expect
+	cmp $expect $a
+	cmp $expect $b
+	cmp $expect $c
+}
+
+t_done

data/t/t0401-em-async-tailer.sh

@@ -0,0 +1,74 @@
+#!/bin/sh
+nr=${nr-5}
+. ./test-lib.sh
+case $model in
+NeverBlock|EventMachine) ;;
+*)
+	t_info "skipping $T since it's not compatible with $model"
+	exit 0
+	;;
+esac
+
+t_plan 8 "async_tailer test for test for EM"
+
+CONFIG_RU=async_examples/async_tailer.ru
+
+t_begin "setup and start" && {
+	rainbows_setup
+	rtmpfiles a b c curl_err TAIL_LOG_FILE expect
+
+	printf '<h1>Async Tailer</h1><pre>' >> $expect
+
+	export TAIL_LOG_FILE
+
+	# this does not does not support Rack::Lint
+	rainbows -E deployment -D $CONFIG_RU -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "send async requests off in parallel" && {
+	t0=$(date +%s)
+	curl --no-buffer -sSf http://$listen/ > $a 2>> $curl_err &
+	curl_a=$!
+	curl --no-buffer -sSf http://$listen/ > $b 2>> $curl_err &
+	curl_b=$!
+	curl --no-buffer -sSf http://$listen/ > $c 2>> $curl_err &
+	curl_c=$!
+}
+
+t_begin "generate log output" && {
+	for i in $(awk "BEGIN {for(i=0;i<$nr;i++) print i}" < /dev/null)
+	do
+		date >> $TAIL_LOG_FILE
+		sleep 1
+	done
+	# sometimes tail(1) can be slow
+	sleep 2
+}
+
+t_begin "kill curls and wait for termination" && {
+	kill $curl_a $curl_b $curl_c
+	wait
+	t1=$(date +%s)
+	elapsed=$(( $t1 - $t0 ))
+	t_info "elapsed=$elapsed"
+}
+
+t_begin "termination signal sent" && {
+	kill $rainbows_pid
+}
+
+t_begin "no errors from curl" && {
+	test ! -s $curl_err
+}
+
+t_begin "no errors in stderr" && check_stderr
+
+t_begin "responses match expected" && {
+	cat $TAIL_LOG_FILE >> $expect
+	cmp $expect $a
+	cmp $expect $b
+	cmp $expect $c
+}
+
+t_done

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rainbows
 version: !ruby/object:Gem::Version 
-  version: 0.90.0
+  version: 0.90.1
 platform: ruby
 authors: 
 - Rainbows! hackers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-22 00:00:00 +00:00
+date: 2009-12-30 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,6 +21,9 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version 
         version: 0.95.0
+    - - <
+      - !ruby/object:Gem::Version 
+        version: 0.97.0
     version: 
 description: |-
   Rainbows! is an HTTP server for sleepy Rack applications.  It is based on
@@ -74,7 +77,6 @@ extra_rdoc_files:
 - lib/rainbows/thread_spawn.rb
 - LICENSE
 - NEWS
-- rainbows.1
 - README
 - SIGNALS
 - TODO
@@ -150,6 +152,9 @@ files:
 - t/README
 - t/async-response-no-autochunk.ru
 - t/async-response.ru
+- t/async_examples/README
+- t/async_examples/async_app.ru
+- t/async_examples/async_tailer.ru
 - t/async_sinatra.ru
 - t/bin/content-md5-put
 - t/bin/sha1sum.rb
@@ -193,18 +198,20 @@ files:
 - t/t0009.ru
 - t/t0010-keepalive-timeout-effective.sh
 - t/t0011-close-on-exec-set.sh
+- t/t0012-spurious-wakeups-quiet.sh
 - t/t0100-rack-input-hammer.sh
 - t/t0101-rack-input-trailer.sh
 - t/t0102-rack-input-short.sh
 - t/t0200-async-response.sh
 - t/t0201-async-response-no-autochunk.sh
 - t/t0300-async_sinatra.sh
+- t/t0400-em-async-app.sh
+- t/t0401-em-async-tailer.sh
 - t/t9000-rack-app-pool.sh
 - t/t9000.ru
 - t/test-lib.sh
 - t/worker-follows-master-to-death.ru
 - vs_Unicorn
-- rainbows.1
 has_rdoc: true
 homepage: http://rainbows.rubyforge.org/
 licenses: []