unicorn 0.94.0 → 0.95.0

data/.document

@@ -1,3 +1,4 @@
+FAQ
 README
 TUNING
 PHILOSOPHY

data/Documentation/unicorn.1.txt

@@ -138,6 +138,10 @@ All unrecognized values for RACK_ENV are assumed to be
 "none".  Production deployments are strongly encouraged to use
 "deployment" or "none" for maximum performance.
 
+As of Unicorn 0.94.0, RACK_ENV is exported as a process-wide environment
+variable as well.  While not current a part of the Rack specification as
+of Rack 1.0.1, this has become a de facto standard in the Rack world.
+
 Note that the Rack::ContentLength and Rack::Chunked middlewares
 are never loaded by default.  If needed, they should be
 individually specified in the RACKUP_FILE, some frameworks do
@@ -145,6 +149,7 @@ not require them.
 
 # ENVIRONMENT VARIABLES
 
+The RACK_ENV variable is set by the aforementioned \-E switch.
 All application or library-specific environment variables (e.g. TMPDIR)
 may always be set in the Unicorn CONFIG_FILE in addition to the spawning
 shell.  When transparently upgrading Unicorn, all environment variables

data/FAQ

@@ -0,0 +1,45 @@
+= Frequently Asked Questions about Unicorn
+
+=== Why are my redirects going to "http" URLs when my site uses https?
+
+If your site is entirely behind https, then Rack applications that use
+"rack.url_scheme" can set the following in the Unicorn config file:
+
+  HttpRequest::DEFAULTS["rack.url_scheme"] = "https"
+
+For frameworks that do not use "rack.url_scheme", you can also
+try setting one or both of the following:
+
+  HttpRequest::DEFAULTS["HTTPS"] = "on"
+  HttpRequest::DEFAULTS["HTTP_X_FORWARDED_PROTO"] = "https"
+
+Otherwise, you can configure your proxy (nginx) to send the
+"X-Forwarded-Proto: https" header only for parts of the site that use
+https.  For nginx, you can do it with the following line in appropriate
+"location" blocks of your nginx config file:
+
+  proxy_set_header X-Forwarded-Proto https;
+
+=== Why are log messages from Unicorn are unformatted when using Rails?
+
+Current versions of Rails unfortunately overrides the default Logger
+formatter.
+
+You can undo this behavior with the default logger in your Unicorn
+config file:
+
+  Configurator::DEFAULTS[:logger].formatter = Logger::Formatter.new
+
+Of course you can specify an entirely different logger as well
+with the "logger" directive described by Unicorn::Configurator.
+
+=== Why am I getting "connection refused"/502 errors under high load?
+
+Short answer: your application cannot keep up.
+
+You can increase the size of the :backlog parameter if your kernel
+supports a larger listen() queue, but keep in mind having a large listen
+queue makes failover to a different machine more difficult.
+
+See the TUNING and Unicorn::Configurator documents for more information
+on :backlog-related topics.

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -156,7 +156,7 @@ NEWS: GIT-VERSION-FILE
 	$(rake) -s news_rdoc > $@+
 	mv $@+ $@
 
-SINCE = 0.93.0
+SINCE = 0.94.0
 ChangeLog: log_range = $(shell test -n "$(SINCE)" && echo v$(SINCE)..)
 ChangeLog: GIT-VERSION-FILE
 	@echo "ChangeLog from $(GIT_URL) ($(SINCE)..$(GIT_VERSION))" > $@+

data/HACKING

@@ -16,6 +16,9 @@ Tests are good, but slow tests make development slow, so we make tests
 faster (in parallel) with GNU make (instead of Rake) and avoiding
 Rubygems.
 
+Users of GNU-based systems (such as GNU/Linux) usually have GNU make installed
+as "make" instead of "gmake".
+
 Since we don't load RubyGems by default, loading Rack properly requires
 setting up RUBYLIB to point to where Rack is located.  Not loading
 Rubygems drastically lowers the time to run the full test suite.  You
@@ -25,15 +28,15 @@ file is provided for reference.
 
 Running the entire test suite with 4 tests in parallel:
 
-  make -j4 test
+  gmake -j4 test
 
 Running just one unit test:
 
-  make test/unit/test_http_parser.rb
+  gmake test/unit/test_http_parser.rb
 
 Running just one test case in a unit test:
 
-  make test/unit/test_http_parser.rb--test_parse_simple.n
+  gmake test/unit/test_http_parser.rb--test_parse_simple.n
 
 === HttpServer
 
@@ -103,11 +106,11 @@ It is easy to install the contents of your git working directory:
 
 Via RubyGems (RubyGems 1.3.5+ recommended for prerelease versions):
 
-  make install-gem
+  gmake install-gem
 
 Without RubyGems (via setup.rb):
 
-  make install
+  gmake install
 
 It is not at all recommended to mix a RubyGems installation with an
 installation done without RubyGems, however.

data/Rakefile

@@ -33,6 +33,7 @@ def tags
 end
 
 cgit_url = "http://git.bogomips.org/cgit/unicorn.git"
+git_url = ENV['GIT_URL'] || 'git://git.bogomips.org/unicorn.git'
 
 desc 'prints news as an Atom feed'
 task :news_atom do
@@ -93,8 +94,6 @@ desc "print release notes for Rubyforge"
 task :release_notes do
   require 'rubygems'
 
-  git_url = ENV['GIT_URL'] || 'git://git.bogomips.org/unicorn.git'
-
   spec = Gem::Specification.load('unicorn.gemspec')
   puts spec.description.strip
   puts ""
@@ -106,3 +105,41 @@ task :release_notes do
   print "\nChanges:\n\n"
   puts body
 end
+
+desc "post to RAA"
+task :raa_update do
+  require 'rubygems'
+  require 'net/http'
+  require 'net/netrc'
+  rc = Net::Netrc.locate('unicorn-raa') or abort "~/.netrc not found"
+  password = rc.password
+
+  s = Gem::Specification.load('unicorn.gemspec')
+  desc = [ s.description.strip ]
+  desc << ""
+  desc << "* #{s.email}"
+  desc << "* #{git_url}"
+  desc << "* #{cgit_url}"
+  desc = desc.join("\n")
+  uri = URI.parse('http://raa.ruby-lang.org/regist.rhtml')
+  form = {
+    :name => s.name,
+    :short_description => s.summary,
+    :version => s.version.to_s,
+    :status => 'stable',
+    :owner => s.authors.first,
+    :email => s.email,
+    :category_major => 'Library',
+    :category_minor => 'Web',
+    :url => s.homepage,
+    :download => "http://rubyforge.org/frs/?group_id=1306",
+    :license => "Ruby's",
+    :description_style => 'Plain',
+    :description => desc,
+    :pass => password,
+    :submit => "Update",
+  }
+  res = Net::HTTP.post_form(uri, form)
+  p res
+  puts res.body
+end

data/SIGNALS

@@ -50,6 +50,13 @@ automatically respawned.
   the current request, so multiple log lines for one request
   (as done by Rails) will not be split across multiple logs.
 
+  It is NOT recommended to send the USR1 signal directly to workers via
+  "killall -USR1 unicorn" if you are using user/group-switching support
+  in your workers.  You will encounter incorrect file permissions and
+  workers will need to be respawned.  Sending USR1 to the master process
+  first will ensure logs have the correct permissions before the master
+  forwards the USR1 signal to workers.
+
 === Procedure to replace a running unicorn executable
 
 You may replace a running instance of unicorn with a new one without

data/bin/unicorn_rails

@@ -171,7 +171,6 @@ app = lambda do ||
       $stderr.puts "LogTailer not available for Rails < 2.3" unless daemonize
       $stderr.puts "Debugger not available" if $DEBUG
       map(map_path) do
-        require 'unicorn/app/old_rails/static'
         use Unicorn::App::OldRails::Static
         run inner_app
       end

data/lib/unicorn.rb

@@ -8,6 +8,14 @@ autoload :Rack, 'rack'
 # a Unicorn web server.  It contains a minimalist HTTP server with just enough
 # functionality to service web application requests fast as possible.
 module Unicorn
+
+  # raised inside TeeInput when a client closes the socket inside the
+  # application dispatch.  This is always raised with an empty backtrace
+  # since there is nothing in the application stack that is responsible
+  # for client shutdowns/disconnects.
+  class ClientShutdown < EOFError
+  end
+
   autoload :Const, 'unicorn/const'
   autoload :HttpRequest, 'unicorn/http_request'
   autoload :HttpResponse, 'unicorn/http_response'
@@ -136,6 +144,7 @@ module Unicorn
         # capabilities.  Let the caller handle any and all errors.
         uid = Etc.getpwnam(user).uid
         gid = Etc.getgrnam(group).gid if group
+        Unicorn::Util.chown_logs(uid, gid)
         tmp.chown(uid, gid)
         if gid && Process.egid != gid
           Process.initgroups(user, gid)
@@ -368,7 +377,7 @@ module Unicorn
         end
       rescue Errno::EINTR
         retry
-      rescue Object => e
+      rescue => e
         logger.error "Unhandled master loop exception #{e.inspect}."
         logger.error e.backtrace.join("\n")
         retry
@@ -470,7 +479,7 @@ module Unicorn
           logger.error "old PID:#{valid_pid?(old_pid)} running with " \
                        "existing pid=#{old_pid}, refusing rexec"
           return
-        rescue Object => e
+        rescue => e
           logger.error "error writing pid=#{old_pid} #{e.class} #{e.message}"
           return
         end
@@ -507,7 +516,10 @@ module Unicorn
     # worker.
     def murder_lazy_workers
       WORKERS.dup.each_pair do |wpid, worker|
-        (diff = (Time.now - worker.tmp.stat.ctime)) <= timeout and next
+        stat = worker.tmp.stat
+        # skip workers that disable fchmod or have never fchmod-ed
+        stat.mode == 0100600 and next
+        (diff = (Time.now - stat.ctime)) <= timeout and next
         logger.error "worker=#{worker.nr} PID:#{wpid} timeout " \
                      "(#{diff}s > #{timeout}s), killing"
         kill_worker(:KILL, wpid) # take no prisoners for timeout violations
@@ -653,7 +665,7 @@ module Unicorn
         rescue Errno::EBADF
           nr < 0 or return
         end
-      rescue Object => e
+      rescue => e
         if alive
           logger.error "Unhandled listen loop exception #{e.inspect}."
           logger.error e.backtrace.join("\n")
@@ -709,7 +721,7 @@ module Unicorn
         self.app = orig_app
         build_app! if preload_app
         logger.info "done reloading config_file=#{config.config_file}"
-      rescue Object => e
+      rescue => e
         logger.error "error reloading config_file=#{config.config_file}: " \
                      "#{e.class} #{e.message}"
       end
@@ -722,6 +734,10 @@ module Unicorn
 
     def build_app!
       if app.respond_to?(:arity) && app.arity == 0
+        # exploit COW in case of preload_app.  Also avoids race
+        # conditions in Rainbows! since load/require are not thread-safe
+        Unicorn.constants.each { |x| Unicorn.const_get(x) }
+
         if defined?(Gem) && Gem.respond_to?(:refresh)
           logger.info "Refreshing Gem list"
           Gem.refresh

data/lib/unicorn/app/old_rails.rb

@@ -13,13 +13,15 @@ module Unicorn; module App; end; end
 # Implements a handler that can run Rails.
 class Unicorn::App::OldRails
 
+  autoload :Static, "unicorn/app/old_rails/static"
+
   def call(env)
     cgi = Unicorn::CGIWrapper.new(env)
     begin
       Dispatcher.dispatch(cgi,
           ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS,
           cgi.body)
-    rescue Object => e
+    rescue => e
       err = env['rack.errors']
       err.write("#{e} #{e.message}\n")
       e.backtrace.each { |line| err.write("#{line}\n") }

data/lib/unicorn/app/old_rails/static.rb

@@ -21,9 +21,11 @@
 # fast as if you use a static server like nginx).
 class Unicorn::App::OldRails::Static < Struct.new(:app, :root, :file_server)
   FILE_METHODS = { 'GET' => true, 'HEAD' => true }
-  REQUEST_METHOD = 'REQUEST_METHOD'.freeze
-  REQUEST_URI = 'REQUEST_URI'.freeze
-  PATH_INFO = 'PATH_INFO'.freeze
+
+  # avoid allocating new strings for hash lookups
+  REQUEST_METHOD = 'REQUEST_METHOD'
+  REQUEST_URI = 'REQUEST_URI'
+  PATH_INFO = 'PATH_INFO'
 
   def initialize(app)
     self.app = app

data/lib/unicorn/configurator.rb

@@ -7,7 +7,7 @@ module Unicorn
 
   # Implements a simple DSL for configuring a Unicorn server.
   #
-  # Example (when used with the unicorn config file):
+  # Example (when used with the Unicorn config file):
   #   worker_processes 4
   #   working_directory "/path/to/deploy/app/current"
   #   listen '/tmp/my_app.sock', :backlog => 1
@@ -22,12 +22,16 @@ module Unicorn
   #     GC.copy_on_write_friendly = true
   #
   #   before_fork do |server, worker|
-  #     # the following is recomended for Rails + "preload_app true"
+  #     # the following is highly recomended for Rails + "preload_app true"
   #     # as there's no need for the master process to hold a connection
   #     defined?(ActiveRecord::Base) and
   #       ActiveRecord::Base.connection.disconnect!
   #
-  #     # the following allows a new master process to incrementally
+  #     # The following is only recommended for memory/DB-constrained
+  #     # installations.  It is not needed if your system can house
+  #     # twice as many worker_processes as you have configured.
+  #
+  #     # This allows a new master process to incrementally
   #     # phase out the old master process with SIGTTOU to avoid a
   #     # thundering herd (especially in the "preload_app false" case)
   #     # when doing a transparent upgrade.  The last worker spawned
@@ -41,7 +45,7 @@ module Unicorn
   #       end
   #     end
   #
-  #     # optionally throttle the master from forking too quickly by sleeping
+  #     # *optionally* throttle the master from forking too quickly by sleeping
   #     sleep 1
   #   end
   #
@@ -50,7 +54,7 @@ module Unicorn
   #     addr = "127.0.0.1:#{9293 + worker.nr}"
   #     server.listen(addr, :tries => -1, :delay => 5, :tcp_nopush => true)
   #
-  #     # the following is required for Rails + "preload_app true",
+  #     # the following is *required* for Rails + "preload_app true",
   #     defined?(ActiveRecord::Base) and
   #       ActiveRecord::Base.establish_connection
   #
@@ -203,7 +207,11 @@ module Unicorn
     end
 
     # sets the current number of worker_processes to +nr+.  Each worker
-    # process will serve exactly one client at a time.
+    # process will serve exactly one client at a time.  You can
+    # increment or decrement this value at runtime by sending SIGTTIN
+    # or SIGTTOU respectively to the master process without reloading
+    # the rest of your Unicorn configuration.  See the SIGNALS document
+    # for more information.
     def worker_processes(nr)
       Integer === nr or raise ArgumentError,
                              "not an integer: worker_processes=#{nr.inspect}"
@@ -283,10 +291,22 @@ module Unicorn
     # +:delay+: seconds to wait between successive +tries+
     #
     # Default: 0.5 seconds
+    #
+    # +:umask+: sets the file mode creation mask for UNIX sockets
+    #
+    # Typically UNIX domain sockets are created with more liberal
+    # file permissions than the rest of the application.  By default,
+    # we create UNIX domain sockets to be readable and writable by
+    # all local users to give them the same accessibility as
+    # locally-bound TCP listeners.
+    #
+    # This has no effect on TCP listeners.
+    #
+    # Default: 0 (world read/writable)
     def listen(address, opt = {})
       address = expand_addr(address)
       if String === address
-        [ :backlog, :sndbuf, :rcvbuf, :tries ].each do |key|
+        [ :umask, :backlog, :sndbuf, :rcvbuf, :tries ].each do |key|
           value = opt[key] or next
           Integer === value or
             raise ArgumentError, "not an integer: #{key}=#{value.inspect}"

data/lib/unicorn/const.rb

@@ -7,7 +7,7 @@ module Unicorn
   # gave about a 3% to 10% performance improvement over using the strings directly.
   # Symbols did not really improve things much compared to constants.
   module Const
-    UNICORN_VERSION="0.94.0"
+    UNICORN_VERSION="0.95.0"
 
     DEFAULT_HOST = "0.0.0.0" # default TCP listen host address
     DEFAULT_PORT = 8080      # default TCP listen port
@@ -30,8 +30,8 @@ module Unicorn
 
     # A frozen format for this is about 15% faster
     REMOTE_ADDR="REMOTE_ADDR".freeze
-    HTTP_EXPECT="HTTP_EXPECT".freeze
     RACK_INPUT="rack.input".freeze
+    HTTP_EXPECT="HTTP_EXPECT"
   end
 
 end

data/lib/unicorn/socket_helper.rb

@@ -11,16 +11,23 @@ module Unicorn
     when /linux/
       # from /usr/include/linux/tcp.h
       TCP_DEFER_ACCEPT = 9 unless defined?(TCP_DEFER_ACCEPT)
+
+      # do not send out partial frames (Linux)
       TCP_CORK = 3 unless defined?(TCP_CORK)
     when /freebsd(([1-4]\..{1,2})|5\.[0-4])/
       # Do nothing for httpready, just closing a bug when freebsd <= 5.4
-      TCP_NOPUSH = 4 unless defined?(TCP_NOPUSH)
+      TCP_NOPUSH = 4 unless defined?(TCP_NOPUSH) # :nodoc:
     when /freebsd/
+      # do not send out partial frames (FreeBSD)
       TCP_NOPUSH = 4 unless defined?(TCP_NOPUSH)
+
       # Use the HTTP accept filter if available.
       # The struct made by pack() is defined in /usr/include/sys/socket.h
       # as accept_filter_arg
       unless `/sbin/sysctl -nq net.inet.accf.http`.empty?
+        # set set the "httpready" accept filter in FreeBSD if available
+        # if other protocols are to be supported, this may be
+        # String#replace-d with "dataready" arguments instead
         FILTER_ARG = ['httpready', nil].pack('a16a240')
       end
     end
@@ -29,23 +36,23 @@ module Unicorn
 
       # highly portable, but off by default because we don't do keepalive
       if defined?(TCP_NODELAY) && ! (val = opt[:tcp_nodelay]).nil?
-        sock.setsockopt(IPPROTO_TCP, TCP_NODELAY, val ? 1 : 0) rescue nil
+        sock.setsockopt(IPPROTO_TCP, TCP_NODELAY, val ? 1 : 0)
       end
 
       unless (val = opt[:tcp_nopush]).nil?
         val = val ? 1 : 0
         if defined?(TCP_CORK) # Linux
-          sock.setsockopt(IPPROTO_TCP, TCP_CORK, val) rescue nil
+          sock.setsockopt(IPPROTO_TCP, TCP_CORK, val)
         elsif defined?(TCP_NOPUSH) # TCP_NOPUSH is untested (FreeBSD)
-          sock.setsockopt(IPPROTO_TCP, TCP_NOPUSH, val) rescue nil
+          sock.setsockopt(IPPROTO_TCP, TCP_NOPUSH, val)
         end
       end
 
       # No good reason to ever have deferred accepts off
       if defined?(TCP_DEFER_ACCEPT)
-        sock.setsockopt(SOL_TCP, TCP_DEFER_ACCEPT, 1) rescue nil
+        sock.setsockopt(SOL_TCP, TCP_DEFER_ACCEPT, 1)
       elsif defined?(SO_ACCEPTFILTER) && defined?(FILTER_ARG)
-        sock.setsockopt(SOL_SOCKET, SO_ACCEPTFILTER, FILTER_ARG) rescue nil
+        sock.setsockopt(SOL_SOCKET, SO_ACCEPTFILTER, FILTER_ARG)
       end
     end
 
@@ -61,6 +68,11 @@ module Unicorn
         log_buffer_sizes(sock, " after: ")
       end
       sock.listen(opt[:backlog] || 1024)
+      rescue => e
+        if respond_to?(:logger)
+          logger.error "error setting socket options: #{e.inspect}"
+          logger.error e.backtrace.join("\n")
+        end
     end
 
     def log_buffer_sizes(sock, pfx = '')
@@ -88,7 +100,7 @@ module Unicorn
                   "socket=#{address} specified but it is not a socket!"
           end
         end
-        old_umask = File.umask(0)
+        old_umask = File.umask(opt[:umask] || 0)
         begin
           UNIXServer.new(address)
         ensure

data/lib/unicorn/tee_input.rb

@@ -123,47 +123,65 @@ module Unicorn
 
   private
 
+    def client_error(e)
+      case e
+      when EOFError
+        # in case client only did a premature shutdown(SHUT_WR)
+        # we do support clients that shutdown(SHUT_WR) after the
+        # _entire_ request has been sent, and those will not have
+        # raised EOFError on us.
+        socket.close if socket
+        raise ClientShutdown, "bytes_read=#{@tmp.size}", []
+      when HttpParserError
+        e.set_backtrace([])
+      end
+      raise e
+    end
+
     # tees off a +length+ chunk of data from the input into the IO
-    # backing store as well as returning it.  +buf+ must be specified.
+    # backing store as well as returning it.  +dst+ must be specified.
     # returns nil if reading from the input returns nil
     def tee(length, dst)
       unless parser.body_eof?
-        begin
-          if parser.filter_body(dst, socket.readpartial(length, buf)).nil?
-            @tmp.write(dst)
-            @tmp.seek(0, IO::SEEK_END) # workaround FreeBSD/OSX + MRI 1.8.x bug
-            return dst
-          end
-        rescue EOFError
+        if parser.filter_body(dst, socket.readpartial(length, buf)).nil?
+          @tmp.write(dst)
+          @tmp.seek(0, IO::SEEK_END) # workaround FreeBSD/OSX + MRI 1.8.x bug
+          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.readpartial(Const::CHUNK_SIZE)
       end
       self.socket = nil
     end
 
-    # tee()s into +buf+ until it is of +length+ bytes (or until
+    # tee()s into +dst+ until it is of +length+ bytes (or until
     # we've reached the Content-Length of the request body).
-    # Returns +buf+ (the exact object, not a duplicate)
+    # Returns +dst+ (the exact object, not a duplicate)
     # To continue supporting applications that need near-real-time
     # streaming input bodies, this is a no-op for
     # "Transfer-Encoding: chunked" requests.
-    def ensure_length(buf, length)
+    def ensure_length(dst, length)
       # @size is nil for chunked bodies, so we can't ensure length for those
       # since they could be streaming bidirectionally and we don't want to
       # block the caller in that case.
-      return buf if buf.nil? || @size.nil?
+      return dst if dst.nil? || @size.nil?
 
-      while buf.size < length && @size != @tmp.pos
-        buf << tee(length - buf.size, @buf2)
+      while dst.size < length && tee(length - dst.size, @buf2)
+        dst << @buf2
       end
 
-      buf
+      dst
     end
 
   end

data/lib/unicorn/util.rb

@@ -17,6 +17,22 @@ module Unicorn
   class Util
     class << self
 
+      def is_log?(fp)
+        append_flags = File::WRONLY | File::APPEND
+
+        ! fp.closed? &&
+          fp.sync &&
+          fp.path[0] == ?/ &&
+          (fp.fcntl(Fcntl::F_GETFL) & append_flags) == append_flags
+      end
+
+      def chown_logs(uid, gid)
+        ObjectSpace.each_object(File) do |fp|
+          is_log?(fp) or next
+          fp.chown(uid, gid)
+        end
+      end
+
       # This reopens ALL logfiles in the process that have been rotated
       # using logrotate(8) (without copytruncate) or similar tools.
       # A +File+ object is considered for reopening if it is:
@@ -27,16 +43,13 @@ module Unicorn
       # Returns the number of files reopened
       def reopen_logs
         nr = 0
-        append_flags = File::WRONLY | File::APPEND
 
         ObjectSpace.each_object(File) do |fp|
-          next if fp.closed?
-          next unless (fp.sync && fp.path[0] == ?/)
-          next unless (fp.fcntl(Fcntl::F_GETFL) & append_flags) == append_flags
-
+          is_log?(fp) or next
+          orig_st = fp.stat
           begin
-            a, b = fp.stat, File.stat(fp.path)
-            next if a.ino == b.ino && a.dev == b.dev
+            b = File.stat(fp.path)
+            next if orig_st.ino == b.ino && orig_st.dev == b.dev
           rescue Errno::ENOENT
           end
 
@@ -47,6 +60,10 @@ module Unicorn
           end
           fp.reopen(fp.path, open_arg)
           fp.sync = true
+          new_st = fp.stat
+          if orig_st.uid != new_st.uid || orig_st.gid != new_st.gid
+            fp.chown(orig_st.uid, orig_st.gid)
+          end
           nr += 1
         end # each_object
         nr

data/local.mk.sample

@@ -5,27 +5,36 @@
 # This is depends on a bunch of GNU-isms from bash, sed, touch.
 
 DLEXT := so
-rack_ver := 1.0.0
+gems := rack-1.0.1
 
 # Avoid loading rubygems to speed up tests because gmake is
 # fork+exec heavy with Ruby.
+prefix = $(HOME)
 ifeq ($(r19),)
-  ruby := $(HOME)/bin/ruby
-  RUBYLIB := $(HOME)/lib/ruby/gems/1.8/gems/rack-$(rack_ver)/lib
+  ruby := $(prefix)/bin/ruby
+  gem_paths := $(addprefix $(prefix)/lib/ruby/gems/1.8/gems/,$(gems))
 else
-  export PATH := $(HOME)/ruby-1.9/bin:$(PATH)
-  ruby := $(HOME)/ruby-1.9/bin/ruby --disable-gems
-  RUBYLIB := $(HOME)/ruby-1.9/lib/ruby/gems/1.9.1/gems/rack-$(rack_ver)/lib
+  prefix := $(prefix)/ruby-1.9
+  export PATH := $(prefix)/bin:$(PATH)
+  ruby := $(prefix)/bin/ruby --disable-gems
+  gem_paths := $(addprefix $(prefix)/lib/ruby/gems/1.9.1/gems/,$(gems))
 endif
 
-# pipefail is THE reason to use bash (v3+)
-SHELL := /bin/bash -e -o pipefail
+ifdef gem_paths
+  sp :=
+  sp +=
+  export RUBYLIB := $(subst $(sp),:,$(addsuffix /lib,$(gem_paths)))
+endif
+
+# pipefail is THE reason to use bash (v3+) or never revisions of ksh93
+# SHELL := /bin/bash -e -o pipefail
+SHELL := /bin/ksh93 -e -o pipefail
 
 full-test: test-18 test-19
 test-18:
-	$(MAKE) test test-rails 2>&1 | sed -u -e 's!^!1.8 !'
+	$(MAKE) test test-rails 2>&1 | sed -e 's!^!1.8 !'
 test-19:
-	$(MAKE) test test-rails r19=1 2>&1 | sed -u -e 's!^!1.9 !'
+	$(MAKE) test test-rails r19=1 2>&1 | sed -e 's!^!1.9 !'
 
 latest: NEWS
 	@awk 'BEGIN{RS="=== ";ORS=""}NR==2{sub(/\n$$/,"");print RS""$$0 }' < $<

data/test/unit/test_server.rb

@@ -12,11 +12,13 @@ include Unicorn
 
 class TestHandler 
 
-  def call(env) 
-  #   response.socket.write("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nhello!\n")
+  def call(env)
     while env['rack.input'].read(4096)
     end
     [200, { 'Content-Type' => 'text/plain' }, ['hello!\n']]
+    rescue Unicorn::ClientShutdown, Unicorn::HttpParserError => e
+      $stderr.syswrite("#{e.class}: #{e.message} #{e.backtrace.empty?}\n")
+      raise e
    end
 end
 
@@ -103,6 +105,92 @@ class WebServerTest < Test::Unit::TestCase
     assert_equal 'hello!\n', results[0], "Handler didn't really run"
   end
 
+  def test_client_shutdown_writes
+    sock = nil
+    buf = nil
+    bs = 15609315 * rand
+    assert_nothing_raised do
+      sock = TCPSocket.new('127.0.0.1', @port)
+      sock.syswrite("PUT /hello HTTP/1.1\r\n")
+      sock.syswrite("Host: example.com\r\n")
+      sock.syswrite("Transfer-Encoding: chunked\r\n")
+      sock.syswrite("Trailer: X-Foo\r\n")
+      sock.syswrite("\r\n")
+      sock.syswrite("%x\r\n" % [ bs ])
+      sock.syswrite("F" * bs)
+      sock.syswrite("\r\n0\r\nX-")
+      "Foo: bar\r\n\r\n".each_byte do |x|
+        sock.syswrite x.chr
+        sleep 0.05
+      end
+      # we wrote the entire request before shutting down, server should
+      # continue to process our request and never hit EOFError on our sock
+      sock.shutdown(Socket::SHUT_WR)
+      buf = sock.read
+    end
+    assert_equal 'hello!\n', buf.split(/\r\n\r\n/).last
+    next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
+    assert_equal 'hello!\n', next_client
+    lines = File.readlines("test_stderr.#$$.log")
+    assert lines.grep(/^Unicorn::ClientShutdown: /).empty?
+    assert_nothing_raised { sock.close }
+  end
+
+  def test_client_shutdown_write_truncates
+    sock = nil
+    buf = nil
+    bs = 15609315 * rand
+    assert_nothing_raised do
+      sock = TCPSocket.new('127.0.0.1', @port)
+      sock.syswrite("PUT /hello HTTP/1.1\r\n")
+      sock.syswrite("Host: example.com\r\n")
+      sock.syswrite("Transfer-Encoding: chunked\r\n")
+      sock.syswrite("Trailer: X-Foo\r\n")
+      sock.syswrite("\r\n")
+      sock.syswrite("%x\r\n" % [ bs ])
+      sock.syswrite("F" * (bs / 2.0))
+
+      # shutdown prematurely, this will force the server to abort
+      # processing on us even during app dispatch
+      sock.shutdown(Socket::SHUT_WR)
+      IO.select([sock], nil, nil, 60) or raise "Timed out"
+      buf = sock.read
+    end
+    assert_equal "", buf
+    next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
+    assert_equal 'hello!\n', next_client
+    lines = File.readlines("test_stderr.#$$.log")
+    lines = lines.grep(/^Unicorn::ClientShutdown: bytes_read=\d+/)
+    assert_equal 1, lines.size
+    assert_match %r{\AUnicorn::ClientShutdown: bytes_read=\d+ true$}, lines[0]
+    assert_nothing_raised { sock.close }
+  end
+
+  def test_client_malformed_body
+    sock = nil
+    buf = nil
+    bs = 15653984
+    assert_nothing_raised do
+      sock = TCPSocket.new('127.0.0.1', @port)
+      sock.syswrite("PUT /hello HTTP/1.1\r\n")
+      sock.syswrite("Host: example.com\r\n")
+      sock.syswrite("Transfer-Encoding: chunked\r\n")
+      sock.syswrite("Trailer: X-Foo\r\n")
+      sock.syswrite("\r\n")
+      sock.syswrite("%x\r\n" % [ bs ])
+      sock.syswrite("F" * bs)
+    end
+    begin
+      File.open("/dev/urandom", "rb") { |fp| sock.syswrite(fp.sysread(16384)) }
+    rescue
+    end
+    assert_nothing_raised { sock.close }
+    next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
+    assert_equal 'hello!\n', next_client
+    lines = File.readlines("test_stderr.#$$.log")
+    lines = lines.grep(/^Unicorn::HttpParserError: .* true$/)
+    assert_equal 1, lines.size
+  end
 
   def do_test(string, chunk, close_after=nil, shutdown_delay=0)
     # Do not use instance variables here, because it needs to be thread safe

data/test/unit/test_socket_helper.rb

@@ -63,6 +63,20 @@ class TestSocketHelper < Test::Unit::TestCase
       File.umask(old_umask)
   end
 
+  def test_bind_listen_unix_umask
+    old_umask = File.umask(0777)
+    tmp = Tempfile.new 'unix.sock'
+    @unix_listener_path = tmp.path
+    File.unlink(@unix_listener_path)
+    @unix_listener = bind_listen(@unix_listener_path, :umask => 077)
+    assert UNIXServer === @unix_listener
+    assert_equal @unix_listener_path, sock_name(@unix_listener)
+    assert_equal 0140700, File.stat(@unix_listener_path).mode
+    assert_equal 0777, File.umask
+    ensure
+      File.umask(old_umask)
+  end
+
   def test_bind_listen_unix_idempotent
     test_bind_listen_unix
     a = bind_listen(@unix_listener)

data/unicorn.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
   s.name = %q{unicorn}
   s.version = ENV["VERSION"]
 
-  s.authors = ["Unicorn developers"]
+  s.authors = ["Unicorn hackers"]
   s.date = Time.now.utc.strftime('%Y-%m-%d')
   s.description = File.read("README").split(/\n\n/)[1]
   s.email = %q{mongrel-unicorn@rubyforge.org}

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: unicorn
 version: !ruby/object:Gem::Version 
-  version: 0.94.0
+  version: 0.95.0
 platform: ruby
 authors: 
-- Unicorn developers
+- Unicorn hackers
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-11-05 00:00:00 -08:00
+date: 2009-11-15 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -35,6 +35,7 @@ executables:
 extensions: 
 - ext/unicorn_http/extconf.rb
 extra_rdoc_files: 
+- FAQ
 - README
 - TUNING
 - PHILOSOPHY
@@ -76,6 +77,7 @@ files:
 - Documentation/GNUmakefile
 - Documentation/unicorn.1.txt
 - Documentation/unicorn_rails.1.txt
+- FAQ
 - GIT-VERSION-FILE
 - GIT-VERSION-GEN
 - GNUmakefile