unicorn 0.990.0.5.gbfb1 → 0.991.0

data/GIT-VERSION-GEN

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

data/GNUmakefile

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

data/README

@@ -1,10 +1,10 @@
-= Unicorn: Rack HTTP server for fast clients and Unix
+= \Unicorn: Rack HTTP server for fast clients and Unix
 
 \Unicorn is an HTTP server for Rack applications designed to only serve
 fast clients on low-latency, high-bandwidth connections and take
 advantage of features in Unix/Unix-like kernels.  Slow clients should
 only be served by placing a reverse proxy capable of fully buffering
-both the the request and response in between Unicorn and slow clients.
+both the the request and response in between \Unicorn and slow clients.
 
 == Features
 

data/Rakefile

@@ -179,7 +179,7 @@ begin
   if File.readable?(mk)
     warn "run 'gmake -C ext/unicorn_http clean' and\n" \
          "remove #{mk} before using rake-compiler"
-  else
+  elsif ENV['VERSION']
     unless File.readable?("ext/unicorn_http/unicorn_http.c")
       abort "run 'gmake ragel' or 'make ragel' to generate the Ragel source"
     end
@@ -192,21 +192,26 @@ end
 
 task :isolate do
   require 'isolate'
+  ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
   opts = {
     :system => false,
-    :path => "tmp/isolate/ruby-#{RUBY_VERSION}",
+    :path => "tmp/isolate/#{ruby_engine}-#{RUBY_VERSION}",
     :multiruby => false, # we want "1.8.7" instead of "1.8"
   }
+  fp = File.open(__FILE__, "rb")
+  fp.flock(File::LOCK_EX)
 
   # C extensions aren't binary-compatible across Ruby versions
-  fork { Isolate.now!(opts) { gem 'sqlite3-ruby', '1.2.5' } }
+  pid = fork { Isolate.now!(opts) { gem 'sqlite3-ruby', '1.2.5' } }
+  _, status = Process.waitpid2(pid)
+  status.success? or abort status.inspect
 
   # pure Ruby gems can be shared across all Rubies
-  %w(3.0.0.beta3).each do |rails_ver|
+  %w(3.0.0.beta4).each do |rails_ver|
     opts[:path] = "tmp/isolate/rails-#{rails_ver}"
-    fork { Isolate.now!(opts) { gem 'rails', rails_ver } }
+    pid = fork { Isolate.now!(opts) { gem 'rails', rails_ver } }
+    _, status = Process.waitpid2(pid)
+    status.success? or abort status.inspect
   end
-
-  failed = Process.waitall.delete_if { |(_,status)| status.success? }
-  abort failed.inspect unless failed.empty?
+  fp.flock(File::LOCK_UN)
 end

data/SIGNALS

@@ -14,7 +14,12 @@ Unicorn and nginx.
   will also pick up any application code changes when restarted.  If
   "preload_app" is true, then application code changes will have no
   effect; USR2 + QUIT (see below) must be used to load newer code in
-  this case.
+  this case.  When reloading the application, +Gem.refresh+ will
+  be called so updated code for your application can pick up newly
+  installed RubyGems.  It is not recommended that you uninstall
+  libraries your application depends on while Unicorn is running,
+  as respawned workers may enter a spawn loop when they fail to
+  load an uninstalled dependency.
 
 * INT/TERM - quick shutdown, kills all workers immediately
 

data/bin/unicorn

@@ -107,10 +107,7 @@ opts = OptionParser.new("", 24, '  ') do |opts|
   opts.parse! ARGV
 end
 
-ru = ARGV[0] || "config.ru"
-abort "configuration file #{ru} not found" unless File.exist?(ru)
-
-app = Unicorn.builder(ru, opts)
+app = Unicorn.builder(ARGV[0] || 'config.ru', opts)
 options[:listeners] << "#{host}:#{port}" if set_listener
 
 if $DEBUG

data/bin/unicorn_rails

@@ -107,8 +107,6 @@ opts = OptionParser.new("", 24, '  ') do |opts|
   opts.parse! ARGV
 end
 
-ru = ARGV[0] || (File.exist?('config.ru') ? 'config.ru' : nil)
-
 def rails_dispatcher
   if ::Rails::VERSION::MAJOR >= 3 && ::File.exist?('config/application.rb')
     if ::File.read('config/application.rb') =~ /^module\s+([\w:]+)\s*$/
@@ -127,9 +125,20 @@ def rails_dispatcher
   result || abort("Unable to locate the application dispatcher class")
 end
 
-def rails_builder(daemonize)
+def rails_builder(ru, opts, daemonize)
+  return Unicorn.builder(ru, opts) if ru
+
+  # allow Configurator to parse cli switches embedded in the ru file
+  Unicorn::Configurator::RACKUP.update(:file => :rails, :optparse => opts)
+
   # this lambda won't run until after forking if preload_app is false
+  # this runs after config file reloading
   lambda do ||
+    # Rails 3 includes a config.ru, use it if we find it after
+    # working_directory is bound.
+    ::File.exist?('config.ru') and
+      return Unicorn.builder('config.ru', opts).call
+
     # Load Rails and (possibly) the private version of Rack it bundles.
     begin
       require ::File.expand_path('config/boot')
@@ -154,10 +163,10 @@ def rails_builder(daemonize)
         if map_path != '/'
           # patches + tests welcome, but I really cbf to deal with this
           # since all apps I've ever dealt with just use "/" ...
-          $stderr.puts "relative URL roots may not work for older Rails"
+          warn "relative URL roots may not work for older Rails"
         end
-        $stderr.puts "LogTailer not available for Rails < 2.3" unless daemonize
-        $stderr.puts "Debugger not available" if $DEBUG
+        warn "LogTailer not available for Rails < 2.3" unless daemonize
+        warn "Debugger not available" if $DEBUG
         require 'unicorn/app/old_rails'
         map(map_path) do
           use Unicorn::App::OldRails::Static
@@ -167,9 +176,7 @@ def rails_builder(daemonize)
         use Rails::Rack::LogTailer unless daemonize
         use Rails::Rack::Debugger if $DEBUG
         map(map_path) do
-          if defined?(ActionDispatch::Static)
-            use ActionDispatch::Static, "#{Rails.root}/public"
-          else
+          unless defined?(ActionDispatch::Static)
             use Rails::Rack::Static
           end
           run rails_dispatcher
@@ -179,7 +186,7 @@ def rails_builder(daemonize)
   end
 end
 
-app = ru ? Unicorn.builder(ru, opts) : rails_builder(daemonize)
+app = rails_builder(ARGV[0], opts, daemonize)
 options[:listeners] << "#{host}:#{port}" if set_listener
 
 if $DEBUG

data/examples/init.sh

@@ -4,6 +4,7 @@ set -e
 # since nginx and unicorn accept the same signals
 
 # Feel free to change any of the following variables for your app:
+TIMEOUT=${TIMEOUT-60}
 APP_ROOT=/home/x/my_app/current
 PID=$APP_ROOT/tmp/pids/unicorn.pid
 CMD="/usr/bin/unicorn -D -c $APP_ROOT/config/unicorn.rb"
@@ -44,7 +45,22 @@ restart|reload)
 	$CMD
 	;;
 upgrade)
-	sig USR2 && sleep 2 && sig 0 && oldsig QUIT && exit 0
+	if sig USR2 && sleep 2 && sig 0 && oldsig QUIT
+	then
+		n=$TIMEOUT
+		while test -s $old_pid && test $n -ge 0
+		do
+			printf '.' && sleep 1 && n=$(( $n - 1 ))
+		done
+		echo
+
+		if test $n -lt 0 && test -s $old_pid
+		then
+			echo >&2 "$old_pid still exists after $TIMEOUT seconds"
+			exit 1
+		fi
+		exit 0
+	fi
 	echo >&2 "Couldn't upgrade, starting '$CMD' instead"
 	$CMD
 	;;

data/ext/unicorn_http/ext_help.h

@@ -10,22 +10,18 @@
 
 #ifndef RUBINIUS
 #  define rb_str_update(x) do {} while (0)
-#  define rb_str_flush(x) do {} while (0)
 #endif /* !RUBINIUS */
 
 #ifndef HAVE_RB_STR_SET_LEN
 #  ifdef RUBINIUS
-#    define rb_str_set_len(str,len) rb_str_resize(str,len)
-#  else /* 1.8.6 optimized version */
+#    error we should never get here with current Rubinius (1.x)
+#  endif
 /* this is taken from Ruby 1.8.7, 1.8.6 may not have it */
 static void rb_18_str_set_len(VALUE str, long len)
 {
   RSTRING(str)->len = len;
   RSTRING(str)->ptr[len] = '\0';
-  rb_str_flush(str);
 }
-#    define rb_str_set_len(str,len) rb_18_str_set_len(str,len)
-#  endif /* ! RUBINIUS */
 #endif /* !defined(HAVE_RB_STR_SET_LEN) */
 
 /* not all Ruby implementations support frozen objects (Rubinius does not) */

data/ext/unicorn_http/extconf.rb

@@ -6,9 +6,5 @@ dir_config("unicorn_http")
 have_macro("SIZEOF_OFF_T", "ruby.h") or check_sizeof("off_t", "sys/types.h")
 have_macro("SIZEOF_LONG", "ruby.h") or check_sizeof("long", "sys/types.h")
 have_func("rb_str_set_len", "ruby.h")
-have_func("rb_str_modify", "ruby.h")
 
-# -fPIC is needed for Rubinius, MRI already uses it regardless
-with_cflags($CFLAGS + " -fPIC ") do
-  create_makefile("unicorn_http")
-end
+create_makefile("unicorn_http")

data/lib/unicorn.rb

@@ -33,11 +33,10 @@ module Unicorn
     # Unicorn config).  The returned lambda will be called when it is
     # time to build the app.
     def builder(ru, opts)
-      if ru =~ /\.ru\z/
-        # parse embedded command-line options in config.ru comments
-        /^#\\(.*)/ =~ File.read(ru) and opts.parse!($1.split(/\s+/))
-      end
+      # allow Configurator to parse cli switches embedded in the ru file
+      Unicorn::Configurator::RACKUP.update(:file => ru, :optparse => opts)
 
+      # always called after config file parsing, may be called after forking
       lambda do ||
         inner_app = case ru
         when /\.ru$/

data/lib/unicorn/configurator.rb

@@ -13,6 +13,12 @@ module Unicorn
   # nginx is also available at
   # http://unicorn.bogomips.org/examples/nginx.conf
   class Configurator < Struct.new(:set, :config_file, :after_reload)
+    # :stopdoc:
+    # used to stash stuff for deferred processing of cli options in
+    # config.ru after "working_directory" is bound.  Do not rely on
+    # this being around later on...
+    RACKUP = {}
+    # :startdoc:
 
     # Default settings for Unicorn
     DEFAULTS = {
@@ -51,6 +57,11 @@ module Unicorn
     def reload #:nodoc:
       instance_eval(File.read(config_file), config_file) if config_file
 
+      parse_rackup_file
+
+      # unicorn_rails creates dirs here after working_directory is bound
+      after_reload.call if after_reload
+
       # working_directory binds immediately (easier error checking that way),
       # now ensure any paths we changed are correctly set.
       [ :pid, :stderr_path, :stdout_path ].each do |var|
@@ -59,13 +70,13 @@ module Unicorn
         File.writable?(path) || File.writable?(File.dirname(path)) or \
               raise ArgumentError, "directory for #{var}=#{path} not writable"
       end
-
-      # unicorn_rails creates dirs here after working_directory is bound
-      after_reload.call if after_reload
     end
 
     def commit!(server, options = {}) #:nodoc:
       skip = options[:skip] || []
+      if ready_pipe = RACKUP.delete(:ready_pipe)
+        server.ready_pipe = ready_pipe
+      end
       set.each do |key, value|
         value == :unset and next
         skip.include?(key) and next
@@ -300,7 +311,22 @@ module Unicorn
     #
     # In addition to reloading the unicorn-specific config settings,
     # SIGHUP will reload application code in the working
-    # directory/symlink when workers are gracefully restarted.
+    # directory/symlink when workers are gracefully restarted when
+    # preload_app=false (the default).  As reloading the application
+    # sometimes requires RubyGems updates, +Gem.refresh+ is always
+    # called before the application is loaded (for RubyGems users).
+    #
+    # During deployments, care should _always_ be taken to ensure your
+    # applications are properly deployed and running.  Using
+    # preload_app=false (the default) means you _must_ check if
+    # your application is responding properly after a deployment.
+    # Improperly deployed applications can go into a spawn loop
+    # if the application fails to load.  While your children are
+    # in a spawn loop, it is is possible to fix an application
+    # by properly deploying all required code and dependencies.
+    # Using preload_app=true means any application load error will
+    # cause the master process to exit with an error.
+
     def preload_app(bool)
       case bool
       when TrueClass, FalseClass
@@ -333,9 +359,9 @@ module Unicorn
       set_path(:stdout_path, path)
     end
 
-    # sets the working directory for Unicorn.  This ensures USR2 will
+    # sets the working directory for Unicorn.  This ensures SIGUSR2 will
     # start a new instance of Unicorn in this directory.  This may be
-    # a symlink.
+    # a symlink, a common scenario for Capistrano users.
     def working_directory(path)
       # just let chdir raise errors
       path = File.expand_path(path)
@@ -411,5 +437,47 @@ module Unicorn
       set[var] = my_proc
     end
 
+    # this is called _after_ working_directory is bound.  This only
+    # parses the embedded switches in .ru files
+    # (for "rackup" compatibility)
+    def parse_rackup_file # :nodoc:
+      ru = RACKUP[:file] or return # we only return here in unit tests
+
+      # :rails means use (old) Rails autodetect
+      if ru == :rails
+        File.readable?('config.ru') or return
+        ru = 'config.ru'
+      end
+
+      File.readable?(ru) or
+        raise ArgumentError, "rackup file (#{ru}) not readable"
+
+      # it could be a .rb file, too, we don't parse those manually
+      ru =~ /\.ru\z/ or return
+
+      /^#\\(.*)/ =~ File.read(ru) or return
+      RACKUP[:optparse].parse!($1.split(/\s+/))
+
+      # XXX ugly as hell, WILL FIX in 2.x (along with Rainbows!/Zbatery)
+      host, port, set_listener, options, daemonize =
+                      eval("[ host, port, set_listener, options, daemonize ]",
+                           TOPLEVEL_BINDING)
+
+      # XXX duplicate code from bin/unicorn{,_rails}
+      set[:listeners] << "#{host}:#{port}" if set_listener
+
+      if daemonize
+        # unicorn_rails wants a default pid path, (not plain 'unicorn')
+        if after_reload
+          spid = set[:pid]
+          pid('tmp/pids/unicorn.pid') if spid.nil? || spid == :unset
+        end
+        unless RACKUP[:daemonized]
+          Unicorn::Launcher.daemonize!(options)
+          RACKUP[:ready_pipe] = options.delete(:ready_pipe)
+        end
+      end
+    end
+
   end
 end

data/lib/unicorn/const.rb

@@ -8,8 +8,8 @@ module Unicorn
   # Symbols did not really improve things much compared to constants.
   module Const
 
-    # The current version of Unicorn, currently 0.990.0
-    UNICORN_VERSION="0.990.0"
+    # The current version of Unicorn, currently 0.991.0
+    UNICORN_VERSION="0.991.0"
 
     DEFAULT_HOST = "0.0.0.0" # default TCP listen host address
     DEFAULT_PORT = 8080      # default TCP listen port

data/lib/unicorn/launcher.rb

@@ -19,47 +19,46 @@ class Unicorn::Launcher
   #     the directory it was started in when being re-executed
   #     to pickup code changes if the original deployment directory
   #     is a symlink or otherwise got replaced.
-  def self.daemonize!(options = nil)
+  def self.daemonize!(options)
     $stdin.reopen("/dev/null")
 
     # We only start a new process group if we're not being reexecuted
     # and inheriting file descriptors from our parent
-    unless ENV['UNICORN_FD']
-      if options
-        # grandparent - reads pipe, exits when master is ready
-        #  \_ parent  - exits immediately ASAP
-        #      \_ unicorn master - writes to pipe when ready
+    if ENV['UNICORN_FD']
+      exit if fork
+      Process.setsid
+      exit if fork
+    else
+      # grandparent - reads pipe, exits when master is ready
+      #  \_ parent  - exits immediately ASAP
+      #      \_ unicorn master - writes to pipe when ready
 
-        rd, wr = IO.pipe
-        grandparent = $$
-        if fork
-          wr.close # grandparent does not write
-        else
-          rd.close # unicorn master does not read
-          Process.setsid
-          exit if fork # parent dies now
-        end
+      rd, wr = IO.pipe
+      grandparent = $$
+      if fork
+        wr.close # grandparent does not write
+      else
+        rd.close # unicorn master does not read
+        Process.setsid
+        exit if fork # parent dies now
+      end
 
-        if grandparent == $$
-          # this will block until HttpServer#join runs (or it dies)
-          master_pid = (rd.readpartial(16) rescue nil).to_i
-          unless master_pid > 1
-            warn "master failed to start, check stderr log for details"
-            exit!(1)
-          end
-          exit 0
-        else # unicorn master process
-          options[:ready_pipe] = wr
+      if grandparent == $$
+        # this will block until HttpServer#join runs (or it dies)
+        master_pid = (rd.readpartial(16) rescue nil).to_i
+        unless master_pid > 1
+          warn "master failed to start, check stderr log for details"
+          exit!(1)
         end
-      else # backwards compat
-        exit if fork
-        Process.setsid
-        exit if fork
+        exit 0
+      else # unicorn master process
+        options[:ready_pipe] = wr
       end
-      # $stderr/$stderr can/will be redirected separately in the Unicorn config
-      Unicorn::Configurator::DEFAULTS[:stderr_path] = "/dev/null"
-      Unicorn::Configurator::DEFAULTS[:stdout_path] = "/dev/null"
     end
+    # $stderr/$stderr can/will be redirected separately in the Unicorn config
+    Unicorn::Configurator::DEFAULTS[:stderr_path] ||= "/dev/null"
+    Unicorn::Configurator::DEFAULTS[:stdout_path] ||= "/dev/null"
+    Unicorn::Configurator::RACKUP[:daemonized] = true
   end
 
 end

data/t/my-tap-lib.sh

@@ -188,9 +188,10 @@ then
 
 	(
 		# use a subshell so seds are not waitable
-		$SED -e 's/^/#: /' $t_stdout &
-		$SED -e 's/^/#! /' $t_stderr &
+		$SED -e 's/^/#: /' < $t_stdout &
+		$SED -e 's/^/#! /' < $t_stderr &
 	) &
+	wait
 	exec > $t_stdout 2> $t_stderr
 else
 	exec > /dev/null 2> /dev/null

data/t/t0003-working_directory.sh

@@ -0,0 +1,56 @@
+#!/bin/sh
+if test -n "$RBX_SKIP"
+then
+	echo "$0 is broken under Rubinius for now"
+	exit 0
+fi
+. ./test-lib.sh
+
+t_plan 4 "config.ru inside alt working_directory"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	rtmpfiles unicorn_config_tmp
+	rm -rf $t_pfx.app
+	mkdir $t_pfx.app
+
+	cat > $t_pfx.app/config.ru <<EOF
+#\--daemonize --host $host --port $port
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+run lambda { |env| [ 200, {}, [ "#{\$master_ppid}\\n" ] ] }
+EOF
+	# we have --host/--port in config.ru instead
+	grep -v ^listen $unicorn_config > $unicorn_config_tmp
+
+	# the whole point of this exercise
+	echo "working_directory '$t_pfx.app'" >> $unicorn_config_tmp
+
+	# allows ppid to be 1 in before_fork
+	echo "preload_app true" >> $unicorn_config_tmp
+	cat >> $unicorn_config_tmp <<\EOF
+before_fork do |server,worker|
+  $master_ppid = Process.ppid # should be zero to detect daemonization
+end
+EOF
+
+	mv $unicorn_config_tmp $unicorn_config
+
+	# rely on --daemonize switch, no & or -D
+	unicorn -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "hit with curl" && {
+	body=$(curl -sSf http://$listen/)
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "response body ppid == 1 (daemonized)" && {
+	test "$body" -eq 1
+}
+
+t_done

data/t/t0004-working_directory_broken.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 3 "config.ru is missing inside alt working_directory"
+
+t_begin "setup" && {
+	unicorn_setup
+	rtmpfiles unicorn_config_tmp ok
+	rm -rf $t_pfx.app
+	mkdir $t_pfx.app
+
+	# the whole point of this exercise
+	echo "working_directory '$t_pfx.app'" >> $unicorn_config_tmp
+}
+
+t_begin "fails to start up w/o config.ru" && {
+	unicorn -c $unicorn_config_tmp || echo ok > $ok
+}
+
+t_begin "fallback code was run" && {
+	test x"$(cat $ok)" = xok
+}
+
+t_done

data/t/t0005-working_directory_app.rb.sh

@@ -0,0 +1,37 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 4 "fooapp.rb inside alt working_directory"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	rm -rf $t_pfx.app
+	mkdir $t_pfx.app
+
+	cat > $t_pfx.app/fooapp.rb <<\EOF
+class Fooapp
+  def self.call(env)
+    [ 200, [%w(Content-Type text/plain), %w(Content-Length 2)], %w(HI) ]
+  end
+end
+EOF
+	# the whole point of this exercise
+	echo "working_directory '$t_pfx.app'" >> $unicorn_config
+	cd /
+	unicorn -D -c $unicorn_config fooapp.rb
+	unicorn_wait_start
+}
+
+t_begin "hit with curl" && {
+	body=$(curl -sSf http://$listen/)
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "response body expected" && {
+	test x"$body" = xHI
+}
+
+t_done

data/t/t0300-rails3-basic.sh

@@ -18,7 +18,7 @@ t_begin "setup and start" && {
 
 # add more tests here
 t_begin "hit with curl" && {
-	curl -v http://$listen/ || :
+	test xHELLO = x"$(curl -sSf http://$listen/x.txt)"
 }
 
 t_begin "killing succeeds" && {

data/t/t0302-rails3-alt-working_directory.sh

@@ -0,0 +1,32 @@
+#!/bin/sh
+. ./test-rails3.sh
+
+t_plan 3 "Rails 3 (beta) inside alt working_directory (no config.ru)"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	rails3_app=$(cd rails3-app && pwd)
+	rm -rf $t_pfx.app
+	mkdir $t_pfx.app
+	cd $t_pfx.app
+	( cd $rails3_app && tar cf - . ) | tar xf -
+	rm config.ru
+	$RAKE db:sessions:create
+	$RAKE db:migrate
+	unicorn_setup
+	rm $pid
+	echo "working_directory '$t_pfx.app'" >> $unicorn_config
+	cd /
+	unicorn_rails -D -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "static file serving works" && {
+	test x"$(curl -sSf http://$listen/x.txt)" = xHELLO
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_done

data/t/t0303-rails3-alt-working_directory_config.ru.sh

@@ -0,0 +1,58 @@
+#!/bin/sh
+if test -n "$RBX_SKIP"
+then
+	echo "$0 is broken under Rubinius for now"
+	exit 0
+fi
+. ./test-rails3.sh
+
+t_plan 5 "Rails 3 (beta) inside alt working_directory (w/ config.ru)"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	rtmpfiles unicorn_config_tmp usock
+	rm -f $usock
+	rails3_app=$(cd rails3-app && pwd)
+	rm -rf $t_pfx.app
+	mkdir $t_pfx.app
+	cd $t_pfx.app
+	( cd $rails3_app && tar cf - . ) | tar xf -
+	$RAKE db:sessions:create
+	$RAKE db:migrate
+	unicorn_setup
+	rm $pid
+
+	echo "#\\--daemonize --host $host --port $port -l $usock" \
+	     >> $t_pfx.app/config.ru
+
+	# we have --host/--port in config.ru instead
+	grep -v ^listen $unicorn_config |
+	  grep -v ^pid > $unicorn_config_tmp
+	echo "working_directory '$t_pfx.app'" >> $unicorn_config_tmp
+	cd /
+	unicorn_rails -c $unicorn_config_tmp
+}
+
+t_begin "pids in the right place" && {
+	if test -e $pid
+	then
+		die "pid=$pid not expected"
+	fi
+
+	unicorn_rails_pid="$t_pfx.app/tmp/pids/unicorn.pid"
+	unicorn_pid=$(cat $unicorn_rails_pid)
+}
+
+t_begin "static file serving works" && {
+	test x"$(curl -sSf http://$listen/x.txt)" = xHELLO
+}
+
+t_begin "socket created" && {
+	test -S $usock
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_done

data/t/test-lib.sh

@@ -4,6 +4,12 @@
 . ./my-tap-lib.sh
 
 set +u
+
+# sometimes we rely on http_proxy to avoid wasting bandwidth with Isolate
+# and multiple Ruby versions
+NO_PROXY=${UNICORN_TEST_ADDR-127.0.0.1}
+export NO_PROXY
+
 set -e
 RUBY="${RUBY-ruby}"
 RUBY_VERSION=${RUBY_VERSION-$($RUBY -e 'puts RUBY_VERSION')}
@@ -76,6 +82,9 @@ check_stderr () {
 # unicorn_setup
 unicorn_setup () {
 	eval $(unused_listen)
+	port=$(expr $listen : '[^:]*:\([0-9]\+\)')
+	host=$(expr $listen : '\([^:]*\):[0-9]\+')
+
 	rtmpfiles unicorn_config pid r_err r_out fifo tmp ok
 	cat > $unicorn_config <<EOF
 listen "$listen"
@@ -97,5 +106,5 @@ 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\}\)'
 }

data/t/test-rails3.sh

@@ -1,5 +1,5 @@
 . ./test-lib.sh
-RAILS_VERSION=${RAILS_VERSION-3.0.0.beta3}
+RAILS_VERSION=${RAILS_VERSION-3.0.0.beta4}
 case $RUBY_VERSION in
 1.8.7|1.9.2) ;;
 *)

data/test/test_helper.rb

@@ -8,6 +8,9 @@
 
 STDIN.sync = STDOUT.sync = STDERR.sync = true # buffering makes debugging hard
 
+# FIXME: move curl-dependent tests into t/
+ENV['NO_PROXY'] ||= ENV['UNICORN_TEST_ADDR'] || '127.0.0.1'
+
 # Some tests watch a log file or a pid file to spring up to check state
 # Can't rely on inotify on non-Linux and logging to a pipe makes things
 # more complicated

data/unicorn.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
 
   s.authors = ["Unicorn hackers"]
   s.date = Time.now.utc.strftime('%Y-%m-%d')
-  s.description = File.read("README").split(/\n\n/)[1]
+  s.description = File.read("README").split(/\n\n/)[1].delete('/')
   s.email = %q{mongrel-unicorn@rubyforge.org}
   s.executables = %w(unicorn unicorn_rails)
   s.extensions = %w(ext/unicorn_http/extconf.rb)

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: unicorn
 version: !ruby/object:Gem::Version 
-  version: 0.990.0.5.gbfb1
+  hash: 3939
+  prerelease: false
+  segments: 
+  - 0
+  - 991
+  - 0
+  version: 0.991.0
 platform: ruby
 authors: 
 - Unicorn hackers
@@ -9,35 +15,45 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-08 00:00:00 +00:00
+date: 2010-06-11 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rack
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: isolate
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 0
+        - 2
         version: 2.0.2
-    version: 
+  type: :development
+  version_requirements: *id002
 description: |-
   \Unicorn is an HTTP server for Rack applications designed to only serve
   fast clients on low-latency, high-bandwidth connections and take
-  advantage of features in Unix/Unix-like kernels.  Slow clients should
+  advantage of features in UnixUnix-like kernels.  Slow clients should
   only be served by placing a reverse proxy capable of fully buffering
-  both the the request and response in between Unicorn and slow clients.
+  both the the request and response in between \Unicorn and slow clients.
 email: mongrel-unicorn@rubyforge.org
 executables: 
 - unicorn
@@ -187,8 +203,13 @@ files:
 - t/t0000-http-basic.sh
 - t/t0001-reload-bad-config.sh
 - t/t0002-config-conflict.sh
+- t/t0003-working_directory.sh
+- t/t0004-working_directory_broken.sh
+- t/t0005-working_directory_app.rb.sh
 - t/t0300-rails3-basic.sh
 - t/t0301-rails3-missing-config-ru.sh
+- t/t0302-rails3-alt-working_directory.sh
+- t/t0303-rails3-alt-working_directory_config.ru.sh
 - t/test-lib.sh
 - t/test-rails3.sh
 - test/aggregate.rb
@@ -299,21 +320,27 @@ require_paths:
 - lib
 - ext
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
-      version: 1.3.1
-  version: 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: mongrel
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Rack HTTP server for fast clients and Unix