rainbows 0.5.0 → 0.6.0

data/lib/rainbows/revactor.rb

@@ -57,18 +57,8 @@ module Rainbows
         HttpResponse.write(client, response, out)
       end while alive and hp.reset.nil? and env.clear
       client.close
-    # if we get any error, try to write something back to the client
-    # assuming we haven't closed the socket, but don't get hung up
-    # if the socket is already closed or broken.  We'll always ensure
-    # the socket is closed at the end of this function
-    rescue EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
-      emergency_response(client, Const::ERROR_500_RESPONSE)
-    rescue HttpParserError # try to tell the client they're bad
-      buf.empty? or emergency_response(client, Const::ERROR_400_RESPONSE)
-    rescue Object => e
-      emergency_response(client, Const::ERROR_500_RESPONSE)
-      logger.error "Read error: #{e.inspect}"
-      logger.error e.backtrace.join("\n")
+    rescue => e
+      handle_error(client, e)
     end
 
     # runs inside each forked worker, this sits around and waits
@@ -101,35 +91,41 @@ module Rainbows
         end
       end
 
-      m = 0
-      check_quit = lambda do
-        worker.tmp.chmod(m = 0 == m ? 1 : 0)
-        G.alive = false if master_pid != Process.ppid
-      end
-
       begin
         Actor.receive do |filter|
-          filter.after(1, &check_quit)
+          filter.after(1) { G.tick }
           filter.when(Case[:exit, Actor, Object]) do |_,actor,_|
             orig = clients.size
             clients.delete(actor.object_id)
             orig >= limit and listeners.each { |l| l << :resume }
-            check_quit.call
+            G.tick
           end
         end
       end while G.alive || clients.size > 0
     end
 
-  private
-
-    # write a response without caring if it went out or not
-    # This is in the case of untrappable errors
-    def emergency_response(client, response_str)
+    # if we get any error, try to write something back to the client
+    # assuming we haven't closed the socket, but don't get hung up
+    # if the socket is already closed or broken.  We'll always ensure
+    # the socket is closed at the end of this function
+    def handle_error(client, e)
+      msg = case e
+      when EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
+        Const::ERROR_500_RESPONSE
+      when HttpParserError # try to tell the client they're bad
+        Const::ERROR_400_RESPONSE
+      else
+        logger.error "Read error: #{e.inspect}"
+        logger.error e.backtrace.join("\n")
+        Const::ERROR_500_RESPONSE
+      end
       client.instance_eval do
         # this is Revactor implementation dependent
-        @_io.write_nonblock(response_str) rescue nil
+        @_io.write_nonblock(msg)
+        close
       end
-      client.close rescue nil
+      rescue
+        nil
     end
 
     def revactorize_listeners!

data/lib/rainbows/revactor/tee_input.rb

@@ -21,19 +21,27 @@ module Rainbows
       # returns nil if reading from the input returns nil
       def tee(length, dst)
         unless parser.body_eof?
-          begin
-            if parser.filter_body(dst, buf << socket.read).nil?
-              @tmp.write(dst)
-              return dst
+          if parser.filter_body(dst, buf << socket.read).nil?
+            @tmp.write(dst)
+            diff = dst.size - length
+            if diff > 0
+              dst.replace(dst[0,length])
+              @tmp.seek(-diff, IO::SEEK_CUR)
             end
-          rescue EOFError
+            return dst
           end
         end
         finalize_input
+        rescue => e
+          client_error(e)
       end
 
       def finalize_input
         while parser.trailers(req, buf).nil?
+          # Don't worry about raising ClientShutdown here on EOFError, tee()
+          # will catch EOFError when app is processing it, otherwise in
+          # initialize we never get any chance to enter the app so the
+          # EOFError will just get trapped by Unicorn and not the Rack app
           buf << socket.read
         end
         self.socket = nil

data/lib/rainbows/thread_pool.rb

@@ -28,16 +28,15 @@ module Rainbows
     def worker_loop(worker)
       init_worker_process(worker)
       pool = (1..worker_connections).map { new_worker_thread }
-      m = 0
 
-      while G.alive && master_pid == Process.ppid
+      while G.alive
+        # if any worker dies, something is serious wrong, bail
         pool.each do |thr|
-          worker.tmp.chmod(m = 0 == m ? 1 : 0)
-          # if any worker dies, something is serious wrong, bail
-          thr.join(1) and break
+          G.tick
+          thr.join(1) and G.quit!
         end
       end
-      join_threads(pool, worker)
+      join_threads(pool)
     end
 
     def new_worker_thread

data/lib/rainbows/thread_spawn.rb

@@ -22,21 +22,18 @@ module Rainbows
     def worker_loop(worker)
       init_worker_process(worker)
       threads = ThreadGroup.new
-      alive = worker.tmp
-      m = 0
       limit = worker_connections
 
       begin
-        G.alive && master_pid == Process.ppid or break
         ret = begin
-          alive.chmod(m = 0 == m ? 1 : 0)
+          G.tick or break
           IO.select(LISTENERS, nil, nil, 1) or next
         rescue Errno::EINTR
           retry
         rescue Errno::EBADF, TypeError
           break
         end
-        alive.chmod(m = 0 == m ? 1 : 0)
+        G.tick
 
         ret.first.each do |l|
           # Sleep if we're busy, another less busy worker process may
@@ -57,7 +54,7 @@ module Rainbows
       rescue Object => e
         listen_loop_error(e)
       end while true
-      join_threads(threads.list, worker)
+      join_threads(threads.list)
     end
 
   end

data/local.mk.sample

@@ -6,7 +6,7 @@
 
 DLEXT := so
 gems := rack-1.0.1
-# gems += unicorn-0.93.5 # installed via setup.rb
+# gems += unicorn-0.95.0 # installed via setup.rb
 gems += rev-0.3.1 iobuffer-0.1.1
 gems += eventmachine-0.12.10
 gems += async_sinatra-0.1.5 sinatra-0.9.4

data/rainbows.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
   s.name = %q{rainbows}
   s.version = ENV["VERSION"]
 
-  s.authors = ["Rainbows! developers"]
+  s.authors = ["Rainbows! hackers"]
   s.date = Time.now.utc.strftime('%Y-%m-%d')
   s.description = File.read("README").split(/\n\n/)[1]
   s.email = %q{rainbows-talk@rubyforge.org}
@@ -41,7 +41,8 @@ Gem::Specification.new do |s|
   s.test_files = test_files
 
   # we need Unicorn for the HTTP parser and process management
-  s.add_dependency(%q<unicorn>, ["~> 0.94.0"])
+  # Unicorn 0.95.0 should be released on or around Nov 13/14/15, 2009
+  s.add_dependency(%q<unicorn>, ["~> 0.95.0"])
 
   # Unicorn already depends on Rack
   # s.add_dependency(%q<rack>)

data/t/GNUmakefile

@@ -19,6 +19,7 @@ endif
 export RUBYLIB RUBY_VERSION
 
 models := ThreadPool ThreadSpawn Rev EventMachine
+models += RevThreadSpawn
 ifeq ($(RUBY_VERSION),1.9.1) # 1.9.2-preview1 was broken
   models += Revactor
 endif

data/t/bin/sha1sum.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+
+# Reads from stdin and outputs the SHA1 hex digest of the input this is
+# ONLY used as a last resort, our test code will try to use sha1sum(1),
+# openssl(1), or gsha1sum(1) before falling back to using this.  We try
+# all options first because we have a strong and healthy distrust of our
+# Ruby abilities in general, and *especially* when it comes to
+# understanding (and trusting the implementation of) Ruby 1.9 encoding.
+
+require 'digest/sha1'
+$stdout.sync = $stderr.sync = true
+$stdout.binmode
+$stdin.binmode
+bs = 16384
+digest = Digest::SHA1.new
+if buf = $stdin.read(bs)
+  begin
+    digest.update(buf)
+  end while $stdin.read(bs, buf)
+end
+
+$stdout.syswrite("#{digest.hexdigest}\n")

data/t/heartbeat-timeout.ru

@@ -1,12 +1,10 @@
 use Rack::ContentLength
-fifo = ENV['FIFO_PATH'] or abort "FIFO_PATH not defined"
 headers = { 'Content-Type' => 'text/plain' }
 run lambda { |env|
   case env['PATH_INFO']
   when "/block-forever"
-    # one of these should block forever
     Process.kill(:STOP, $$)
-    ::File.open(fifo, "rb") { |fp| fp.syswrite("NEVER\n") }
+    sleep # in case STOP signal is not received in time
     [ 500, headers, [ "Should never get here\n" ] ]
   else
     [ 200, headers, [ "#$$\n" ] ]

data/t/sha1-random-size.ru

@@ -0,0 +1,19 @@
+# SHA1 checksum generator
+require 'digest/sha1'
+use Rack::ContentLength
+cap = 16384
+app = lambda do |env|
+  /\A100-continue\z/i =~ env['HTTP_EXPECT'] and
+    return [ 100, {}, [] ]
+  digest = Digest::SHA1.new
+  input = env['rack.input']
+  if buf = input.read(rand(cap))
+    begin
+      raise "#{buf.size} > #{cap}" if buf.size > cap
+      digest.update(buf)
+    end while input.read(rand(cap), buf)
+  end
+
+  [ 200, {'Content-Type' => 'text/plain'}, [ digest.hexdigest << "\n" ] ]
+end
+run app

data/t/sha1.ru

@@ -1,5 +1,5 @@
 # SHA1 checksum generator
-bs = ENV['bs'] ? ENV['bs'].to_i : 4096
+bs = ENV['bs'] ? ENV['bs'].to_i : 16384
 require 'digest/sha1'
 use Rack::ContentLength
 app = lambda do |env|
@@ -7,10 +7,11 @@ app = lambda do |env|
     return [ 100, {}, [] ]
   digest = Digest::SHA1.new
   input = env['rack.input']
-  buf = input.read(bs)
-  begin
-    digest.update(buf)
-  end while input.read(bs, buf)
+  if buf = input.read(bs)
+    begin
+      digest.update(buf)
+    end while input.read(bs, buf)
+  end
 
   [ 200, {'Content-Type' => 'text/plain'}, [ digest.hexdigest << "\n" ] ]
 end

data/t/simple-http_RevThreadSpawn.ru

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

data/t/t0003-reopen-logs.sh

@@ -3,7 +3,7 @@
 nr_client=${nr_client-2}
 . ./test-lib.sh
 
-t_plan 18 "reopen rotated logs"
+t_plan 19 "reopen rotated logs"
 
 t_begin "setup and startup" && {
 	rtmpfiles curl_out curl_err r_rot
@@ -44,6 +44,16 @@ t_begin "wait for rotated log to reappear" && {
 	done
 }
 
+t_begin "wait for worker to reopen logs" && {
+	nr=60
+	re="worker=.* done reopening logs"
+	while ! grep "$re" < $r_err >/dev/null && test $nr -ge 0
+	do
+		sleep 1
+		nr=$(( $nr - 1 ))
+	done
+}
+
 dbgcat r_rot
 dbgcat r_err
 

data/t/t0004-heartbeat-timeout.sh

@@ -7,7 +7,7 @@ t_begin "setup and startup" && {
 	rainbows_setup $model
         echo timeout 3 >> $unicorn_config
         echo preload_app true >> $unicorn_config
-	FIFO_PATH=$fifo rainbows -D heartbeat-timeout.ru -c $unicorn_config
+	rainbows -D heartbeat-timeout.ru -c $unicorn_config
 	rainbows_wait_start
 }
 
@@ -37,7 +37,7 @@ t_begin "ensure timeout took 3-6 seconds" && {
 }
 
 t_begin "wait for new worker to start up" && {
-	test x = x"$(cat $fifo)"
+	test xSTART = x"$(cat $fifo)"
 }
 
 t_begin "we get a fresh new worker process" && {

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

@@ -0,0 +1,50 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 7 "ensure worker follows master to death"
+
+t_begin "setup" && {
+	rtmpfiles curl_err curl_out
+	rainbows_setup
+        echo timeout 3 >> $unicorn_config
+	rainbows -D -c $unicorn_config worker-follows-master-to-death.ru
+	rainbows_wait_start
+}
+
+t_begin "read worker PID" && {
+	worker_pid=$(curl -sSf http://$listen/pid)
+	t_info "worker_pid=$worker_pid"
+}
+
+t_begin "start a long sleeping request" && {
+	curl -sSfv -T- </dev/null http://$listen/sleep/2 >$curl_out 2> $fifo &
+	curl_pid=$!
+	t_info "curl_pid=$curl_pid"
+}
+
+t_begin "nuke the master once we're connected" && {
+	awk -v rainbows_pid=$rainbows_pid '
+{ print $0 }
+/100 Continue/ {
+	print "awk: sending SIGKILL to", rainbows_pid
+	system("kill -9 "rainbows_pid)
+}' < $fifo > $curl_err
+	wait
+}
+
+t_begin "worker is no longer running" && {
+	sleep 6
+	kill -0 $worker_pid 2> $tmp && false
+	test -s $tmp
+}
+
+t_begin "sleepy curl request is no longer running" && {
+	kill -0 $curl_pid 2> $tmp && false
+	test -s $tmp
+}
+
+t_begin "sleepy curl request completed gracefully" && {
+	test x$(cat $curl_out) = x$worker_pid
+	dbgcat curl_err
+}
+
+t_done

data/t/t0008-ensure-usable-after-limit.sh

@@ -0,0 +1,181 @@
+#!/bin/sh
+. ./test-lib.sh
+test -r random_blob || die "random_blob required, run with 'make $0'"
+
+t_plan 14 "ensure we're accounting worker_connections properly"
+nr=2
+
+t_begin "setup" && {
+	rtmpfiles a b c d
+	rainbows_setup $model $nr
+	rainbows -D sha1.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+null_sha1=da39a3ee5e6b4b0d3255bfef95601890afd80709
+
+t_begin "fire off concurrent processes" && {
+
+	req='POST / HTTP/1.1\r\n'
+	req="$req"'Host: example.com\r\n'
+	req="$req"'Transfer-Encoding: chunked\r\n\r\n'
+
+	for i in a b c d
+	do
+		rtmpfiles ${i}_fifo ${i}_tmp
+		eval 'i_fifo=$'${i}_fifo
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		(
+			(
+				cat $i_fifo > $i_tmp &
+				# need a full HTTP request to get around
+				# httpready
+				printf "$req"
+				sleep 5
+				printf '0\r\n\r\n'
+				wait
+				echo ok > $i
+			) | socat - TCP:$listen > $i_fifo
+		) &
+	done
+	wait
+}
+
+t_begin "check results" && {
+	for i in a b c d
+	do
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		test xok = x$(cat $i)
+		test x$null_sha1 = x$(tail -1 $i_tmp)
+	done
+}
+
+t_begin "repeat concurrent tests with faster clients" && {
+	for i in a b c d
+	do
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		curl -sSf -T- </dev/null http://$listen/ > $i 2> $i_tmp &
+	done
+	wait
+}
+
+t_begin "check results" && {
+	for i in a b c d
+	do
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		test ! -s $i_tmp
+		test x$null_sha1 = x$(cat $i)
+	done
+}
+
+t_begin "fire off truncated concurrent requests" && {
+
+	req='POST / HTTP/1.1\r\n'
+	req="$req"'Host: example.com\r\n'
+	req="$req"'Transfer-Encoding: chunked\r\n'
+
+	for i in a b c d
+	do
+		rtmpfiles ${i}_tmp
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		(
+			(
+				# need a full HTTP request to get around
+				# httpready
+				printf "$req"
+				echo ok > $i
+			) | socat - TCP:$listen > $i_tmp
+		) &
+	done
+	wait
+}
+
+t_begin "check broken results" && {
+	for i in a b c d
+	do
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		test xok = x$(cat $i)
+		dbgcat i_tmp
+	done
+}
+
+t_begin "repeat concurrent tests with faster clients" && {
+	for i in a b c d
+	do
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		curl -sSf -T- </dev/null http://$listen/ > $i 2> $i_tmp &
+	done
+	wait
+}
+
+t_begin "check results" && {
+	for i in a b c d
+	do
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		test ! -s $i_tmp
+		test x$null_sha1 = x$(cat $i)
+	done
+}
+
+t_begin "fire off garbage" && {
+	for i in a b c d
+	do
+		rtmpfiles ${i}_fifo ${i}_tmp
+		eval 'i_fifo=$'${i}_fifo
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		(
+			(
+				cat $i_fifo > $i_tmp &
+				dd if=random_blob bs=4096 count=1
+				wait
+				echo ok > $i
+			) | socat - TCP:$listen > $i_fifo
+		) &
+	done
+	wait
+}
+
+t_begin "check broken results" && {
+	for i in a b c d
+	do
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		test xok = x$(cat $i)
+		grep -F 'HTTP/1.1 400 Bad Request' $i_tmp
+	done
+}
+
+t_begin "repeat concurrent tests with faster clients" && {
+	for i in a b c d
+	do
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		curl -sSf -T- </dev/null http://$listen/ > $i 2> $i_tmp &
+	done
+	wait
+}
+
+t_begin "check results" && {
+	for i in a b c d
+	do
+		eval 'i_tmp=$'${i}_tmp
+		eval "i=$"$i
+		test ! -s $i_tmp
+		test x$null_sha1 = x$(cat $i)
+	done
+}
+
+t_begin "teardown" && {
+	kill $rainbows_pid
+}
+
+t_done