unicorn 0.99.0 → 0.990.0

data/.document

@@ -16,3 +16,4 @@ ext/unicorn_http/unicorn_http.c
 unicorn_1
 unicorn_rails_1
 ISSUES
+Sandbox

data/.gitignore

@@ -8,7 +8,8 @@
 /InstalledFiles
 /doc
 /local.mk
-/test/install-*
+/test/rbx-*
+/test/ruby-*
 ext/unicorn_http/Makefile
 ext/unicorn_http/unicorn_http.c
 log/
@@ -19,3 +20,4 @@ pkg/
 /.manifest
 /GIT-VERSION-FILE
 /man
+/tmp

data/Documentation/unicorn.1.txt

@@ -16,7 +16,7 @@ A rackup(1)-like command to launch Rack applications using Unicorn.
 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 Unicorn takes a myriad of command-line options for
+While unicorn takes a myriad of command-line options for
 compatibility with ruby(1) and rackup(1), it is recommended to stick
 to the few command-line options specified in the SYNOPSIS and use
 the CONFIG_FILE as much as possible.

data/FAQ

@@ -1,11 +1,12 @@
 = Frequently Asked Questions about Unicorn
 
-===  I've installed Rack 1.1.x, why can't Unicorn load Rails?
+===  I've installed Rack 1.1.x, why can't Unicorn load Rails (2.3.5)?
 
 Rails 2.3.5 is not compatible with Rack 1.1.x.  Unicorn is compatible
 with both Rack 1.1.x and Rack 1.0.x, and RubyGems will load the latest
 version of Rack installed on the system.  Uninstalling the Rack 1.1.x
-gem should solve gem loading issues with Rails 2.3.x.
+gem should solve gem loading issues with Rails 2.3.5.  Rails 2.3.6
+and later correctly support Rack 1.1.x.
 
 === Why are my redirects going to "http" URLs when my site uses https?
 

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -4,7 +4,7 @@ all:: test
 GIT_URL = git://git.bogomips.org/unicorn.git
 RLFLAGS = -G2
 
-# lower-case vars are deprecated
+MRI = ruby
 RUBY = ruby
 RAKE = rake
 RAGEL = ragel
@@ -21,20 +21,22 @@ ifeq ($(RUBY_VERSION),)
   RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
 endif
 
+RUBY_ENGINE := $(shell $(RUBY) -e 'puts((RUBY_ENGINE rescue "ruby"))')
+
 # dunno how to implement this as concisely in Ruby, and hell, I love awk
 awk_slow := awk '/def test_/{print FILENAME"--"$$2".n"}' 2>/dev/null
 
 rails_vers := $(subst test/rails/app-,,$(wildcard test/rails/app-*))
 slow_tests := test/unit/test_server.rb test/exec/test_exec.rb \
   test/unit/test_signals.rb test/unit/test_upload.rb
-log_suffix = .$(RUBY_VERSION).log
+log_suffix = .$(RUBY_ENGINE).$(RUBY_VERSION).log
 T_r := $(wildcard test/rails/test*.rb)
 T := $(filter-out $(slow_tests) $(T_r), $(wildcard test/*/test*.rb))
 T_n := $(shell $(awk_slow) $(slow_tests))
 T_log := $(subst .rb,$(log_suffix),$(T))
 T_n_log := $(subst .n,$(log_suffix),$(T_n))
 T_r_log := $(subst .r,$(log_suffix),$(T_r))
-test_prefix = $(CURDIR)/test/install-$(RUBY_VERSION)
+test_prefix = $(CURDIR)/test/$(RUBY_ENGINE)-$(RUBY_VERSION)
 
 ext := ext/unicorn_http
 c_files := $(ext)/unicorn_http.c $(wildcard $(ext)/*.h)
@@ -65,16 +67,16 @@ $(test_prefix)/.stamp: $(inst_deps)
 	tar cf - $(inst_deps) GIT-VERSION-GEN | \
 	  (cd $(test_prefix) && tar xf -)
 	$(MAKE) -C $(test_prefix) clean
-	$(MAKE) -C $(test_prefix) http shebang
+	$(MAKE) -C $(test_prefix) http shebang RUBY="$(RUBY)"
 	> $@
 
 # this is only intended to be run within $(test_prefix)
 shebang: $(bins)
-	$(RUBY) -i -p -e '$$_.gsub!(%r{^#!.*$$},"#!$(ruby_bin)")' $^
+	$(MRI) -i -p -e '$$_.gsub!(%r{^#!.*$$},"#!$(ruby_bin)")' $^
 
 t_log := $(T_log) $(T_n_log)
 test: $(T) $(T_n)
-	@cat $(t_log) | $(RUBY) test/aggregate.rb
+	@cat $(t_log) | $(MRI) test/aggregate.rb
 	@$(RM) $(t_log)
 
 test-exec: $(wildcard test/exec/test_*.rb)
@@ -82,6 +84,11 @@ test-unit: $(wildcard test/unit/test_*.rb)
 $(slow_tests): $(test_prefix)/.stamp
 	@$(MAKE) $(shell $(awk_slow) $@)
 
+test-integration: $(test_prefix)/.stamp
+	$(MAKE) -C t
+
+test-all: test test-rails test-integration
+
 TEST_OPTS = -v
 check_test = grep '0 failures, 0 errors' $(t) >/dev/null
 ifndef V
@@ -161,7 +168,7 @@ NEWS: GIT-VERSION-FILE .manifest
 	$(RAKE) -s news_rdoc > $@+
 	mv $@+ $@
 
-SINCE = 0.97.1
+SINCE = 0.99.0
 ChangeLog: LOG_VERSION = \
   $(shell git rev-parse -q "$(GIT_VERSION)" >/dev/null 2>&1 && \
           echo $(GIT_VERSION) || git describe)
@@ -202,12 +209,40 @@ doc: .document $(ext)/unicorn_http.c NEWS ChangeLog
 	cd doc && ln README.html tmp && mv tmp index.html
 	$(RM) $(man1_rdoc)
 
+# publishes docs to http://unicorn.bogomips.org
+publish_doc:
+	-git set-file-times
+	$(RM) -r doc ChangeLog NEWS
+	$(MAKE) doc LOG_VERSION=$(shell git tag -l | tail -1)
+	@awk 'BEGIN{RS="=== ";ORS=""}NR==2{sub(/\n$$/,"");print RS""$$0 }' \
+	 < NEWS > doc/LATEST
+	find doc/images doc/js -type f | \
+		TZ=UTC xargs touch -d '1970-01-01 00:00:00' doc/rdoc.css
+	$(MAKE) doc_gz
+	tar cf - $$(git ls-files examples/) | (cd doc && tar xf -)
+	chmod 644 $$(find doc -type f)
+	rsync -av doc/ unicorn.bogomips.org:/srv/unicorn/
+	git ls-files | xargs touch
+
+# Create gzip variants of the same timestamp as the original so nginx
+# "gzip_static on" can serve the gzipped versions directly.
+doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.\(gif\|jpg\|png\|gz\)$$')
+doc_gz:
+	touch doc/NEWS.atom.xml -d "$$(awk 'NR==1{print $$4,$$5,$$6}' NEWS)"
+	for i in $(docs); do \
+	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
+
 rails_git_url = git://github.com/rails/rails.git
 rails_git := vendor/rails.git
 $(rails_git)/info/cloned-stamp:
 	git clone --mirror -q $(rails_git_url) $(rails_git)
 	> $@
 
+$(rails_git)/info/v2.3.8-stamp: $(rails_git)/info/cloned-stamp
+	cd $(rails_git) && git fetch
+	cd $(rails_git) && git rev-parse --verify refs/tags/v2.3.8
+	> $@
+
 rails_tests := $(addsuffix .r,$(addprefix $(T_r).,$(rails_vers)))
 test-rails: $(rails_tests)
 $(T_r).%.r: t = $(addsuffix $(log_suffix),$@)
@@ -218,7 +253,7 @@ $(T_r).%.r: export PATH := $(test_prefix)/bin:$(PATH)
 $(T_r).%.r: export RUBYLIB := $(test_prefix):$(test_prefix)/lib:$(RUBYLIB)
 $(T_r).%.r: export UNICORN_RAILS_TEST_VERSION = $(rv)
 $(T_r).%.r: export RAILS_GIT_REPO = $(CURDIR)/$(rails_git)
-$(T_r).%.r: $(test_prefix)/.stamp $(rails_git)/info/cloned-stamp
+$(T_r).%.r: $(test_prefix)/.stamp $(rails_git)/info/v2.3.8-stamp
 	$(run_test)
 
 ifneq ($(VERSION),)

data/KNOWN_ISSUES

@@ -3,6 +3,9 @@
 Occasionally odd {issues}[link:ISSUES.html] arise without a transparent or
 acceptable solution.  Those issues are documented here.
 
+* For notes on sandboxing tools such as Bundler or Isolate,
+  see the {Sandbox}[link:Sandbox.html] page.
+
 * Under Ruby 1.9.1, methods like Array#shuffle and Array#sample will
   segfault if called after forking.  This is fixed in trunk (r26936) and
   should be backported to the next 1.9.1 stable release (after p378).
@@ -32,30 +35,6 @@ acceptable solution.  Those issues are documented here.
   Note: the workaround described in the article above only made
   the issue more subtle and we didn't notice them immediately.
 
-* Installing "unicorn" as a system-wide Rubygem and using the
-  {isolate}[http://github.com/jbarnette/isolate] gem may cause issues if
-  you're using any of the bundled application-level libraries in
-  unicorn/app/* (for compatibility with CGI-based applications, Rails <=
-  2.2.2, or ExecCgi).  For now workarounds include:
-
-  * installing the same version of unicorn as a system-wide Rubygem
-    _and_ isolating unicorn as well.
-  * explicitly setting RUBYLIB or $LOAD_PATH to include any gem path
-    where the unicorn gem is installed (e.g.
-    /usr/lib/ruby/gems/1.8/gems/unicorn-VERSION/lib)
-
-  With current versions of isolate, it is also recommended that you
-  disable it with the <tt>before_exec</tt> hook prevent the PATH and
-  RUBYOPT environment variable modifications from propagating between
-  upgrades in your Unicorn config file:
-
-        before_exec do |server|
-          Isolate.disable
-        end
-
-  Future versions (unreleased as of 2010.04.20) of isolate will not
-  require this as environment variable modifications will be idempotent.
-
 * WONTFIX: code reloading and restarts with Sinatra 0.3.x (and likely older
   versions) apps is broken.  The workaround is to force production
   mode to disable code reloading as well as disabling "run" in your

data/PHILOSOPHY

@@ -140,5 +140,6 @@ Unicorn may still outweigh the drawbacks for these applications.
 
 The {Rainbows!}[http://rainbows.rubyforge.org/] aims to fill the gap for
 odd corner cases where the nginx + Unicorn combination is not enough.
-Keep in mind that Rainbows! is still very new (as of October 2009), far
-more ambitious, and far less tested than Unicorn.
+While Rainbows! management/administration is largely identical to
+Unicorn, Rainbows! is far more ambitious and has seen little real-world
+usage.

data/Rakefile

@@ -176,11 +176,11 @@ end
 # optional rake-compiler support in case somebody needs to cross compile
 begin
   mk = "ext/unicorn_http/Makefile"
-  if test ?r, mk
+  if File.readable?(mk)
     warn "run 'gmake -C ext/unicorn_http clean' and\n" \
          "remove #{mk} before using rake-compiler"
   else
-    unless test ?r, "ext/unicorn_http/unicorn_http.c"
+    unless File.readable?("ext/unicorn_http/unicorn_http.c")
       abort "run 'gmake ragel' or 'make ragel' to generate the Ragel source"
     end
     spec = Gem::Specification.load('unicorn.gemspec')
@@ -189,3 +189,24 @@ begin
   end
 rescue LoadError
 end
+
+task :isolate do
+  require 'isolate'
+  opts = {
+    :system => false,
+    :path => "tmp/isolate/ruby-#{RUBY_VERSION}",
+    :multiruby => false, # we want "1.8.7" instead of "1.8"
+  }
+
+  # C extensions aren't binary-compatible across Ruby versions
+  fork { Isolate.now!(opts) { gem 'sqlite3-ruby', '1.2.5' } }
+
+  # pure Ruby gems can be shared across all Rubies
+  %w(3.0.0.beta3).each do |rails_ver|
+    opts[:path] = "tmp/isolate/rails-#{rails_ver}"
+    fork { Isolate.now!(opts) { gem 'rails', rails_ver } }
+  end
+
+  failed = Process.waitall.delete_if { |(_,status)| status.success? }
+  abort failed.inspect unless failed.empty?
+end

data/Sandbox

@@ -0,0 +1,78 @@
+= Tips for using \Unicorn with Sandbox installation tools
+
+Since unicorn includes executables and is usually used to start a Ruby
+process, there are certain caveats to using it with tools that sandbox
+RubyGems installations such as
+{Bundler}[http://github.com/carlhuda/bundler] or
+{Isolate}[http://github.com/jbarnette/isolate].
+
+== General deployment
+
+If you're sandboxing your unicorn installation and using Capistrano (or
+similar), it's required that you sandbox your RubyGems in a per-application
+shared directory that can be used between different revisions.
+
+unicorn will stash its original command-line at startup for the USR2
+upgrades, and cleaning up old revisions will cause revision-specific
+installations of unicorn to go missing and upgrades to fail.   If you
+find yourself in this situation and can't afford downtime, you can
+override the existing unicorn executable path in the config file like
+this:
+
+        Unicorn::HttpServer::START_CTX[0] = "/some/path/to/bin/unicorn"
+
+Then use HUP to reload, and then continue with the USR2+QUIT upgrade
+sequence.
+
+== Bundler
+
+=== Running
+
+If you're bundling unicorn, use "bundle exec unicorn" (or "bundle exec
+unicorn_rails") to start unicorn with the correct environment variables
+
+ref: http://mid.gmane.org/9ECF07C4-5216-47BE-961D-AFC0F0C82060@internetfamo.us
+
+Otherwise (if you choose to not sandbox your unicorn installation), we
+expect the tips for Isolate (below) apply, too.
+
+=== RUBYOPT pollution from SIGUSR2 upgrades
+
+This is no longer be an issue as of bundler 0.9.17
+
+ref: http://mid.gmane.org/8FC34B23-5994-41CC-B5AF-7198EF06909E@tramchase.com
+
+== Isolate
+
+=== Running
+
+Installing "unicorn" as a system-wide Rubygem and using the
+isolate gem may cause issues if you're using any of the bundled
+application-level libraries in unicorn/app/* (for compatibility
+with CGI-based applications, Rails <= 2.2.2, or ExecCgi).
+For now workarounds include doing one of the following:
+
+1. Isolating unicorn, setting GEM_HOME to your Isolate path,
+   and running the isolated version of unicorn.  You *must* set
+   GEM_HOME before running your isolated unicorn install in this way.
+
+2.  Installing the same version of unicorn as a system-wide Rubygem
+    *and* isolating unicorn as well.
+
+3. Explicitly setting RUBYLIB or $LOAD_PATH to include any gem path
+   where the unicorn gem is installed
+   (e.g. /usr/lib/ruby/gems/1.9.1/gems/unicorn-VERSION/lib)
+
+=== RUBYOPT pollution from SIGUSR2 upgrades
+
+If you are using Isolate, using Isolate 2.x is strongly recommended as
+environment modifications are idempotent.
+
+If you are stuck with 1.x versions of Isolate, it is recommended that
+you disable it with the <tt>before_exec</tt> hook prevent the PATH and
+RUBYOPT environment variable modifications from propagating between
+upgrades in your Unicorn config file:
+
+        before_exec do |server|
+          Isolate.disable
+        end

data/bin/unicorn_rails

@@ -109,53 +109,30 @@ end
 
 ru = ARGV[0] || (File.exist?('config.ru') ? 'config.ru' : nil)
 
-if ru && ru =~ /\.ru\z/
-  # parse embedded command-line options in config.ru comments
-  /^#\\(.*)/ =~ File.read(ru) and opts.parse!($1.split(/\s+/))
-end
-
-def rails_builder(ru, daemonize)
+def rails_builder(daemonize)
   # this lambda won't run until after forking if preload_app is false
   lambda do ||
     # Load Rails and (possibly) the private version of Rack it bundles.
     begin
       require 'config/boot'
+      require 'config/environment'
     rescue LoadError => err
       abort "#$0 must be run inside RAILS_ROOT: #{err.inspect}"
     end
 
-    inner_app = case ru
-    when nil
-      require 'config/environment'
-
-      defined?(::Rails::VERSION::STRING) or
-        abort "Rails::VERSION::STRING not defined by config/{boot,environment}"
-      # it seems Rails >=2.2 support Rack, but only >=2.3 requires it
-      old_rails = case ::Rails::VERSION::MAJOR
-      when 0, 1 then true
-      when 2 then Rails::VERSION::MINOR < 3 ? true : false
-      else
-        false
-      end
-
-      if old_rails
-        require 'unicorn/app/old_rails'
-        Unicorn::App::OldRails.new
-      else
-        ActionController::Dispatcher.new
-      end
-    when /\.ru$/
-      raw = File.read(ru)
-      raw.sub!(/^__END__\n.*/, '')
-      eval("Rack::Builder.new {(#{raw}\n)}.to_app", TOPLEVEL_BINDING, ru)
+    defined?(::Rails::VERSION::STRING) or
+      abort "Rails::VERSION::STRING not defined by config/{boot,environment}"
+    # it seems Rails >=2.2 support Rack, but only >=2.3 requires it
+    old_rails = case ::Rails::VERSION::MAJOR
+    when 0, 1 then true
+    when 2 then Rails::VERSION::MINOR < 3 ? true : false
     else
-      require ru
-      Object.const_get(File.basename(ru, '.rb').capitalize)
+      false
     end
 
     Rack::Builder.new do
       map_path = ENV['RAILS_RELATIVE_URL_ROOT'] || '/'
-      if inner_app.class.to_s == "Unicorn::App::OldRails"
+      if old_rails
         if map_path != '/'
           # patches + tests welcome, but I really cbf to deal with this
           # since all apps I've ever dealt with just use "/" ...
@@ -163,23 +140,24 @@ def rails_builder(ru, daemonize)
         end
         $stderr.puts "LogTailer not available for Rails < 2.3" unless daemonize
         $stderr.puts "Debugger not available" if $DEBUG
+        require 'unicorn/app/old_rails'
         map(map_path) do
           use Unicorn::App::OldRails::Static
-          run inner_app
+          run Unicorn::App::OldRails.new
         end
       else
         use Rails::Rack::LogTailer unless daemonize
         use Rails::Rack::Debugger if $DEBUG
         map(map_path) do
           use Rails::Rack::Static
-          run inner_app
+          run ActionController::Dispatcher.new
         end
       end
     end.to_app
   end
 end
 
-app = rails_builder(ru, daemonize)
+app = ru ? Unicorn.builder(ru, opts) : rails_builder(daemonize)
 options[:listeners] << "#{host}:#{port}" if set_listener
 
 if $DEBUG

data/examples/big_app_gc.rb

@@ -0,0 +1,33 @@
+# Run GC after every request, before attempting to accept more connections.
+#
+# You could customize this patch to read REQ["PATH_INFO"] and only
+# call GC.start after expensive requests.
+#
+# We could have this wrap the response body.close as middleware, but the
+# scannable stack is would still be bigger than it would be here.
+#
+# This shouldn't hurt overall performance as long as the server cluster
+# is at <=50% CPU capacity, and improves the performance of most memory
+# intensive requests.  This serves to improve _client-visible_
+# performance (possibly at the cost of overall performance).
+#
+# We'll call GC after each request is been written out to the socket, so
+# the client never sees the extra GC hit it. It's ideal to call the GC
+# inside the HTTP server (vs middleware or hooks) since the stack is
+# smaller at this point, so the GC will both be faster and more
+# effective at releasing unused memory.
+#
+# This monkey patch is _only_ effective for applications that use a lot
+# of memory, and will hurt simpler apps/endpoints that can process
+# multiple requests before incurring GC.
+
+class Unicorn::HttpServer
+  REQ = Unicorn::HttpRequest::REQ
+  alias _process_client process_client
+  undef_method :process_client
+  def process_client(client)
+    _process_client(client)
+    REQ.clear
+    GC.start
+  end
+end if defined?(Unicorn)