rainbows 0.1.0

data/t/.gitignore

@@ -0,0 +1,4 @@
+/test-results-*
+/test-bin-*
+/*.code
+/*.log

data/t/GNUmakefile

@@ -0,0 +1,64 @@
+# we can run tests in parallel with GNU make
+
+all::
+
+ruby = ruby
+rainbows_lib := $(shell cd ../lib && pwd)
+-include ../local.mk
+ifeq ($(RUBY_VERSION),)
+  RUBY_VERSION := $(shell $(ruby) -e 'puts RUBY_VERSION')
+endif
+
+ifeq ($(RUBYLIB),)
+  RUBYLIB := $(rainbows_lib)
+else
+  RUBYLIB := $(rainbows_lib):$(RUBYLIB)
+endif
+export RUBYLIB
+
+T = $(wildcard t[0-9][0-9][0-9][0-9]-*.sh)
+
+all:: $(T)
+
+# can't rely on "set -o pipefail" since we don't require bash or ksh93 :<
+t_code = $@-$(RUBY_VERSION).code
+t_log = $@-$(RUBY_VERSION).log
+t_run = $(TRACER) $(SHELL) $(TEST_OPTS) $@
+
+# prefix stdout messages with ':', and stderr messages with '!'
+t_wrap = ( ( ( $(RM) $(t_code); \
+  $(t_run); \
+  echo $$? > $(t_code) ) \
+  | sed 's/^/$(pfx):/' 1>&3 ) 2>&1 \
+  | sed 's/^/$(pfx)!/' 1>&2 ) 3>&1
+
+ifndef V
+  quiet_pre = @echo '* $@';
+  quiet_post = > $(t_log) 2>&1; exit $$(cat $(t_code))
+  pfx =
+else
+  quiet_pre = @echo '* $@';
+  quiet_post = 2>&1 | tee $(t_log); exit $$(cat $(t_code))
+  pfx = $@
+endif
+
+# TRACER='strace -f -o $@.strace -s 100000'
+run_test = $(quiet_pre) ( $(t_wrap) ) $(quiet_post)
+
+test-bin-$(RUBY_VERSION)/rainbows: ruby_bin = $(shell which $(ruby))
+test-bin-$(RUBY_VERSION)/rainbows: ../bin/rainbows
+	mkdir -p $(@D)
+	install -m 755 $^ $@+
+	$(ruby) -i -p -e '$$_.gsub!(%r{^#!.*$$},"#!$(ruby_bin)")' $@+
+	cmp $@+ $@ || mv $@+ $@
+	$(RM) $@+
+
+$(T): export ruby := $(ruby)
+$(T): export PATH := $(CURDIR)/test-bin-$(RUBY_VERSION):$(PATH)
+$(T): test-bin-$(RUBY_VERSION)/rainbows
+	$(run_test)
+
+clean:
+	$(RM) -r *.log *.code test-bin-$(RUBY_VERSION)
+
+.PHONY: $(T) clean

data/t/bin/unused_listen

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# this is to remain compatible with the unused_port function in the
+# Unicorn test/test_helper.rb file
+require 'socket'
+require 'tmpdir'
+
+default_port = 8080
+addr = ENV['UNICORN_TEST_ADDR'] || '127.0.0.1'
+retries = 100
+base = 5000
+port = sock = lock_path = nil
+
+begin
+  begin
+    port = base + rand(32768 - base)
+    while port == default_port
+      port = base + rand(32768 - base)
+    end
+
+    sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+    sock.bind(Socket.pack_sockaddr_in(port, addr))
+    sock.listen(5)
+  rescue Errno::EADDRINUSE, Errno::EACCES
+    sock.close rescue nil
+    retry if (retries -= 1) >= 0
+  end
+
+  # since we'll end up closing the random port we just got, there's a race
+  # condition could allow the random port we just chose to reselect itself
+  # when running tests in parallel with gmake.  Create a lock file while
+  # we have the port here to ensure that does not happen.
+  lock_path = "#{Dir::tmpdir}/unicorn_test.#{addr}:#{port}.lock"
+  lock = File.open(lock_path, File::WRONLY|File::CREAT|File::EXCL, 0600)
+rescue Errno::EEXIST
+  sock.close rescue nil
+  retry
+end
+sock.close rescue nil
+puts "listen=#{addr}:#{port} lock_path=#{lock_path}"

data/t/sha1.ru

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

data/t/t0000-basic.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+. ./test-lib.sh
+
+eval $(unused_listen)
+config_ru=$(mktemp -t rainbows.$$.XXXXXXXX.config.ru)
+pid=$(mktemp -t rainbows.$$.XXXXXXXX.pid)
+TEST_RM_LIST="$TEST_RM_LIST $config_ru $lock_path"
+
+cat > $config_ru <<\EOF
+use Rack::ContentLength
+use Rack::ContentType
+run lambda { |env| [ 200, {}, [ env.inspect << "\n" ] ] }
+EOF
+
+rainbows $config_ru -l $listen --pid $pid &
+wait_for_pid $pid
+curl -sSfv http://$listen/
+kill $(cat $pid)

data/t/t1000-thread-pool-basic.sh

@@ -0,0 +1,53 @@
+#!/bin/sh
+. ./test-lib.sh
+
+eval $(unused_listen)
+config_ru=$(mktemp -t rainbows.$$.XXXXXXXX.config.ru)
+unicorn_config=$(mktemp -t rainbows.$$.XXXXXXXX.unicorn.rb)
+curl_out=$(mktemp -t rainbows.$$.XXXXXXXX.curl.out)
+curl_err=$(mktemp -t rainbows.$$.XXXXXXXX.curl.err)
+pid=$(mktemp -t rainbows.$$.XXXXXXXX.pid)
+TEST_RM_LIST="$TEST_RM_LIST $config_ru $unicorn_config $lock_path"
+TEST_RM_LIST="$TEST_RM_LIST $curl_out $curl_err"
+
+cat > $config_ru <<\EOF
+use Rack::ContentLength
+use Rack::ContentType
+run lambda { |env|
+  sleep 1
+  [ 200, {}, [ Thread.current.inspect << "\n" ] ]
+}
+EOF
+
+nr_client=30
+nr_thread=10
+
+cat > $unicorn_config <<EOF
+listen "$listen"
+pid "$pid"
+Rainbows! do
+  use :ThreadPool
+  worker_connections $nr_thread
+end
+EOF
+
+rainbows -D $config_ru -c $unicorn_config
+wait_for_pid $pid
+
+start=$(date +%s)
+for i in $(awk "BEGIN{for(i=0;i<$nr_client;++i) print i}" </dev/null)
+do
+	( curl -sSf http://$listen/$i >> $curl_out 2>> $curl_err ) &
+done
+wait
+echo elapsed=$(( $(date +%s) - $start ))
+
+kill $(cat $pid)
+
+! test -s $curl_err
+test x"$(wc -l < $curl_out)" = x$nr_client
+
+nr=$(sort < $curl_out | uniq | wc -l)
+
+test "$nr" -le $nr_thread
+test "$nr" -gt 1

data/t/t2000-thread-spawn-basic.sh

@@ -0,0 +1,50 @@
+#!/bin/sh
+. ./test-lib.sh
+
+eval $(unused_listen)
+config_ru=$(mktemp -t rainbows.$$.XXXXXXXX.config.ru)
+unicorn_config=$(mktemp -t rainbows.$$.XXXXXXXX.unicorn.rb)
+curl_out=$(mktemp -t rainbows.$$.XXXXXXXX.curl.out)
+curl_err=$(mktemp -t rainbows.$$.XXXXXXXX.curl.err)
+pid=$(mktemp -t rainbows.$$.XXXXXXXX.pid)
+TEST_RM_LIST="$TEST_RM_LIST $config_ru $unicorn_config $lock_path"
+TEST_RM_LIST="$TEST_RM_LIST $curl_out $curl_err"
+
+cat > $config_ru <<\EOF
+use Rack::ContentLength
+use Rack::ContentType
+run lambda { |env|
+  sleep 1
+  [ 200, {}, [ Thread.current.inspect << "\n" ] ]
+}
+EOF
+
+nr_client=30
+nr_thread=10
+
+cat > $unicorn_config <<EOF
+listen "$listen"
+pid "$pid"
+Rainbows! do
+  use :ThreadSpawn
+  worker_connections $nr_thread
+end
+EOF
+
+rainbows -D $config_ru -c $unicorn_config
+wait_for_pid $pid
+
+start=$(date +%s)
+for i in $(awk "BEGIN{for(i=0;i<$nr_client;++i) print i}" </dev/null)
+do
+	( curl -sSf http://$listen/$i >> $curl_out 2>> $curl_err ) &
+done
+wait
+echo elapsed=$(( $(date +%s) - $start ))
+
+kill $(cat $pid)
+
+! test -s $curl_err
+test x"$(wc -l < $curl_out)" = x$nr_client
+nr=$(sort < $curl_out | uniq | wc -l)
+test "$nr" -eq $nr_client

data/t/t3000-revactor-basic.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+. ./test-lib.sh
+require_revactor
+
+eval $(unused_listen)
+config_ru=$(mktemp -t rainbows.$$.XXXXXXXX.config.ru)
+unicorn_config=$(mktemp -t rainbows.$$.XXXXXXXX.unicorn.rb)
+curl_out=$(mktemp -t rainbows.$$.XXXXXXXX.curl.out)
+curl_err=$(mktemp -t rainbows.$$.XXXXXXXX.curl.err)
+pid=$(mktemp -t rainbows.$$.XXXXXXXX.pid)
+TEST_RM_LIST="$TEST_RM_LIST $config_ru $unicorn_config $lock_path"
+TEST_RM_LIST="$TEST_RM_LIST $curl_out $curl_err"
+
+cat > $config_ru <<\EOF
+use Rack::ContentLength
+use Rack::ContentType
+run lambda { |env|
+  Actor.sleep 1
+  [ 200, {}, [ Thread.current.inspect << "\n" ] ]
+}
+EOF
+
+nr_client=30
+nr_actor=10
+
+cat > $unicorn_config <<EOF
+listen "$listen"
+pid "$pid"
+Rainbows! do
+  use :Revactor
+  worker_connections $nr_actor
+end
+EOF
+
+rainbows -D $config_ru -c $unicorn_config
+wait_for_pid $pid
+
+start=$(date +%s)
+for i in $(awk "BEGIN{for(i=0;i<$nr_client;++i) print i}" </dev/null)
+do
+	( curl -sSf http://$listen/$i >> $curl_out 2>> $curl_err ) &
+done
+wait
+echo elapsed=$(( $(date +%s) - $start ))
+
+kill $(cat $pid)
+
+! test -s $curl_err
+test x"$(wc -l < $curl_out)" = x$nr_client
+nr=$(sort < $curl_out | uniq | wc -l)
+
+test "$nr" -eq 1

data/t/t3100-revactor-tee-input.sh

@@ -0,0 +1,49 @@
+#!/bin/sh
+nr_client=${nr_client-25}
+nr_actor=${nr_actor-50}
+
+. ./test-lib.sh
+require_revactor
+
+eval $(unused_listen)
+unicorn_config=$(mktemp -t rainbows.$$.unicorn.rb.XXXXXXXX)
+curl_out=$(mktemp -t rainbows.$$.curl.out.XXXXXXXX)
+curl_err=$(mktemp -t rainbows.$$.curl.err.XXXXXXXX)
+r_err=$(mktemp -t rainbows.$$.r.err.XXXXXXXX)
+r_out=$(mktemp -t rainbows.$$.r.out.XXXXXXXX)
+pid=$(mktemp -t rainbows.$$.pid.XXXXXXXX)
+blob=$(mktemp -t rainbows.$$.blob.XXXXXXXX)
+TEST_RM_LIST="$TEST_RM_LIST $unicorn_config $lock_path $r_err $r_out"
+TEST_RM_LIST="$TEST_RM_LIST $curl_out $curl_err $blob"
+
+cat > $unicorn_config <<EOF
+listen "$listen"
+pid "$pid"
+stderr_path "$r_err"
+stdout_path "$r_out"
+Rainbows! do
+  use :Revactor
+  worker_connections $nr_actor
+end
+EOF
+
+echo pid=$pid
+rainbows -D sha1.ru -c $unicorn_config
+wait_for_pid $pid
+
+dd if=/dev/urandom bs=1M count=10 of=$blob 2>/dev/null
+
+start=$(date +%s)
+for i in $(awk "BEGIN{for(i=0;i<$nr_client;++i) print i}" </dev/null)
+do
+	( curl -sSf -T- < $blob http://$listen/$i >> $curl_out 2>> $curl_err ) &
+done
+wait
+echo elapsed=$(( $(date +%s) - $start ))
+
+kill $(cat $pid)
+test $nr_client -eq $(wc -l < $curl_out)
+test 1 -eq $(sort < $curl_out | uniq | wc -l)
+blob_sha1=$( expr "$(sha1sum < $blob)" : '\([a-f0-9]\+\)')
+echo blob_sha1=$blob_sha1
+test x"$blob_sha1" = x"$(sort < $curl_out | uniq)"

data/t/test-lib.sh

@@ -0,0 +1,41 @@
+#!/bin/sh
+# Copyright (c) 2009 Eric Wong
+set -e
+set -u
+T=$(basename $0)
+ruby="${ruby-ruby}"
+
+# ensure a sane environment
+TZ=UTC LC_ALL=C LANG=C
+export LANG LC_ALL TZ
+unset CDPATH
+
+die () {
+	echo >&2 "$@"
+	exit 1
+}
+
+TEST_RM_LIST=""
+trap 'rm -f $TEST_RM_LIST' 0
+PATH=$PWD/bin:$PATH
+export PATH
+
+test -x $PWD/bin/unused_listen || die "must be run in 't' directory"
+
+wait_for_pid () {
+	path="$1"
+	nr=30
+	while ! test -s "$path" && test $nr -gt 0
+	do
+		nr=$(($nr - 1))
+		sleep 1
+	done
+}
+
+require_revactor () {
+	if ! $ruby -rrevactor -e "puts Revactor::VERSION" >/dev/null 2>&1
+	then
+		echo >&2 "skipping $T since we don't have Revactor"
+		exit 0
+	fi
+}

data/vs_Unicorn

@@ -0,0 +1,48 @@
+= \Rainbows! is like Unicorn, but Different...
+
+While \Rainbows! depends on Unicorn for its process/socket management,
+HTTP parser and configuration language; \Rainbows! is more ambitious.
+
+== Differences from Unicorn
+
+* log rotation is handled immediately in \Rainbows! whereas Unicorn has
+  the luxury of delaying it until the current request is finished
+  processing to prevent log entries for one request to be split across
+  files.
+
+* load balancing between workers is imperfect, certain worker processes
+  may be servicing more requests than others so it is important to not
+  set +worker_connections+ too high.  Unicorn worker processes can never
+  be servicing more than one request at once.
+
+* speculative, non-blocking accept() is not used, this is to help
+  load balance between multiple worker processes.
+
+* HTTP pipelining and keepalive may be used for GET and HEAD requests.
+
+* Less heavily-tested and inherently more complex.
+
+
+== Similarities with Unicorn
+
+While some similarities are obvious (we depend on and subclass of
+Unicorn code), some things are not:
+
+* Does not attempt to accept() connections when pre-configured limits
+  are hit (+worker_connections+).  This will first help balance load
+  to different worker processes, and if your listen() +:backlog+ is
+  overflowing: to other machines in your cluster.
+
+* Accepts the same {signals}[http://unicorn.bogomips.org/SIGNALS.html]
+  for process management, so you can share scripts to manage them (and
+  nginx, too).
+
+* supports per-process listeners, allowing an external load balancer
+  like haproxy or nginx to be used to balance between multiple
+  worker processes.
+
+* Exposes a streaming "rack.input" to the Rack application that reads
+  data off the socket as the application reads it (while retaining
+  rewindable semantics as required by Rack).  This allows Rack-compliant
+  apps/middleware to implement things such as real-time upload progress
+  monitoring.