unicorn 0.93.5 → 0.94.0

data/CONTRIBUTORS

@@ -2,6 +2,7 @@ Unicorn developers:
 * Eric Wong
 * Suraj N. Kurapati
 * Andrey Stikheev
+* Wayne Larsen
 * ... (help wanted)
 
 We would like to thank following folks for helping make Unicorn possible:

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -57,7 +57,8 @@ http: lib/unicorn_http.$(DLEXT)
 
 $(test_prefix)/.stamp: $(inst_deps)
 	mkdir -p $(test_prefix)/.ccache
-	tar c $(inst_deps) GIT-VERSION-GEN | (cd $(test_prefix) && tar x)
+	tar cf - $(inst_deps) GIT-VERSION-GEN | \
+	  (cd $(test_prefix) && tar xf -)
 	$(MAKE) -C $(test_prefix) clean
 	$(MAKE) -C $(test_prefix) http shebang
 	> $@
@@ -91,9 +92,13 @@ else
          rm $(stamp) 2>/dev/null && $(check_test)
 endif
 
+# not all systems have setsid(8), we need it because we spam signals
+# stupidly in some tests...
+rb_setsid := $(ruby) -e 'Process.setsid' -e 'exec *ARGV'
+
 # TRACER='strace -f -o $(t).strace -s 100000'
 run_test = $(quiet_pre) \
-  setsid $(TRACER) $(ruby) -w $(arg) $(TEST_OPTS) $(quiet_post) || \
+  $(rb_setsid) $(TRACER) $(ruby) -w $(arg) $(TEST_OPTS) $(quiet_post) || \
   (sed "s,^,$(extra): ," >&2 < $(t); exit 1)
 
 %.n: arg = $(subst .n,,$(subst --, -n ,$@))
@@ -151,7 +156,7 @@ NEWS: GIT-VERSION-FILE
 	$(rake) -s news_rdoc > $@+
 	mv $@+ $@
 
-SINCE = 0.92.0
+SINCE = 0.93.0
 ChangeLog: log_range = $(shell test -n "$(SINCE)" && echo v$(SINCE)..)
 ChangeLog: GIT-VERSION-FILE
 	@echo "ChangeLog from $(GIT_URL) ($(SINCE)..$(GIT_VERSION))" > $@+
@@ -249,8 +254,8 @@ $(pkgtgz): manifest fix-perms
 	@test -n "$(distdir)"
 	$(RM) -r $(distdir)
 	mkdir -p $(distdir)
-	tar c `cat .manifest` | (cd $(distdir) && tar x)
-	cd pkg && tar c $(basename $(@F)) | gzip -9 > $(@F)+
+	tar cf - `cat .manifest` | (cd $(distdir) && tar xf -)
+	cd pkg && tar cf - $(basename $(@F)) | gzip -9 > $(@F)+
 	mv $@+ $@
 
 package: $(pkgtgz) $(pkggem)

data/TODO

@@ -3,12 +3,6 @@
 * ensure test suite passes on non-GNU/Linux systems
   (likely that it already does)
 
-* consider adding "working_directory" directive to Configurator
-  since START_CTX is ugly...
-
-* consider adding user switching support (ugh...)
-  This makes more sense for Rainbows!, but some folks use it already...
-
 * fix const-correctness in HTTP parser
 
 * performance validation (esp. TeeInput)

data/bin/unicorn

@@ -3,7 +3,7 @@
 require 'unicorn/launcher'
 require 'optparse'
 
-env = "development"
+ENV["RACK_ENV"] ||= "development"
 daemonize = false
 listeners = []
 options = { :listeners => listeners }
@@ -58,7 +58,7 @@ opts = OptionParser.new("", 24, '  ') do |opts|
 
   opts.on("-E", "--env ENVIRONMENT",
           "use ENVIRONMENT for defaults (default: development)") do |e|
-    env = e
+    ENV["RACK_ENV"] = e
   end
 
   opts.on("-D", "--daemonize", "run daemonized in the background") do |d|
@@ -133,7 +133,7 @@ app = lambda do ||
     Object.const_get(File.basename(config, '.rb').capitalize)
   end
   pp({ :inner_app => inner_app }) if $DEBUG
-  case env
+  case ENV["RACK_ENV"]
   when "development"
     Rack::Builder.new do
       use Rack::CommonLogger, $stderr

data/ext/unicorn_http/unicorn_http.rl

@@ -25,14 +25,15 @@
 /* both of these flags need to be set for keepalive to be supported */
 #define UH_FL_KEEPALIVE (UH_FL_KAMETHOD | UH_FL_KAVERSION)
 
+/* keep this small for Rainbows! since every client has one */
 struct http_parser {
   int cs; /* Ragel internal state */
   unsigned int flags;
   size_t mark;
-  union { /* these 3 fields don't nest */
+  size_t offset;
+  union { /* these 2 fields don't nest */
     size_t field;
     size_t query;
-    size_t offset;
   } start;
   union {
     size_t field_len; /* only used during header processing */
@@ -349,7 +350,7 @@ static void http_parser_execute(struct http_parser *hp,
 {
   const char *p, *pe;
   int cs = hp->cs;
-  size_t off = hp->start.offset;
+  size_t off = hp->offset;
 
   if (cs == http_parser_first_final)
     return;
@@ -369,10 +370,10 @@ static void http_parser_execute(struct http_parser *hp,
 post_exec: /* "_out:" also goes here */
   if (hp->cs != http_parser_error)
     hp->cs = cs;
-  hp->start.offset = p - buffer;
+  hp->offset = p - buffer;
 
   assert(p <= pe && "buffer overflow after parsing execute");
-  assert(hp->start.offset <= len && "start.offset longer than length");
+  assert(hp->offset <= len && "offset longer than length");
 }
 
 static struct http_parser *data_get(VALUE self)
@@ -531,12 +532,12 @@ static VALUE HttpParser_headers(VALUE self, VALUE req, VALUE data)
   rb_str_update(data);
 
   http_parser_execute(hp, req, RSTRING_PTR(data), RSTRING_LEN(data));
-  VALIDATE_MAX_LENGTH(hp->start.offset, HEADER);
+  VALIDATE_MAX_LENGTH(hp->offset, HEADER);
 
   if (hp->cs == http_parser_first_final ||
       hp->cs == http_parser_en_ChunkedBody) {
-    advance_str(data, hp->start.offset + 1);
-    hp->start.offset = 0;
+    advance_str(data, hp->offset + 1);
+    hp->offset = 0;
 
     return req;
   }
@@ -637,9 +638,9 @@ static VALUE HttpParser_filter_body(VALUE self, VALUE buf, VALUE data)
       if (hp->cs == http_parser_error)
         rb_raise(eHttpParserError, "Invalid HTTP format, parsing fails.");
 
-      assert(hp->s.dest_offset <= hp->start.offset &&
+      assert(hp->s.dest_offset <= hp->offset &&
              "destination buffer overflow");
-      advance_str(data, hp->start.offset);
+      advance_str(data, hp->offset);
       rb_str_set_len(buf, hp->s.dest_offset);
 
       if (RSTRING_LEN(buf) == 0 && chunked_eof(hp)) {
@@ -663,7 +664,7 @@ static VALUE HttpParser_filter_body(VALUE self, VALUE buf, VALUE data)
       data = Qnil;
     }
   }
-  hp->start.offset = 0; /* for trailer parsing */
+  hp->offset = 0; /* for trailer parsing */
   return data;
 }
 

data/lib/unicorn.rb

@@ -92,9 +92,17 @@ module Unicorn
     #   Unicorn::HttpServer::START_CTX[0] = "/home/bofh/1.9.2/bin/unicorn"
     START_CTX = {
       :argv => ARGV.map { |arg| arg.dup },
-      # don't rely on Dir.pwd here since it's not symlink-aware, and
-      # symlink dirs are the default with Capistrano...
-      :cwd => `/bin/sh -c pwd`.chomp("\n"),
+      :cwd => lambda {
+          # favor ENV['PWD'] since it is (usually) symlink aware for
+          # Capistrano and like systems
+          begin
+            a = File.stat(pwd = ENV['PWD'])
+            b = File.stat(Dir.pwd)
+            a.ino == b.ino && a.dev == b.dev ? pwd : Dir.pwd
+          rescue
+            Dir.pwd
+          end
+        }.call,
       0 => $0.dup,
     }
 
@@ -105,10 +113,37 @@ module Unicorn
     # for examples.
     class Worker < Struct.new(:nr, :tmp)
 
+      autoload :Etc, 'etc'
+
       # worker objects may be compared to just plain numbers
       def ==(other_nr)
         self.nr == other_nr
       end
+
+      # Changes the worker process to the specified +user+ and +group+
+      # This is only intended to be called from within the worker
+      # process from the +after_fork+ hook.  This should be called in
+      # the +after_fork+ hook after any priviledged functions need to be
+      # run (e.g. to set per-worker CPU affinity, niceness, etc)
+      #
+      # Any and all errors raised within this method will be propagated
+      # directly back to the caller (usually the +after_fork+ hook.
+      # These errors commonly include ArgumentError for specifying an
+      # invalid user/group and Errno::EPERM for insufficient priviledges
+      def user(user, group = nil)
+        # we do not protect the caller, checking Process.euid == 0 is
+        # insufficient because modern systems have fine-grained
+        # capabilities.  Let the caller handle any and all errors.
+        uid = Etc.getpwnam(user).uid
+        gid = Etc.getgrnam(group).gid if group
+        tmp.chown(uid, gid)
+        if gid && Process.egid != gid
+          Process.initgroups(user, gid)
+          Process::GID.change_privilege(gid)
+        end
+        Process.euid != uid and Process::UID.change_privilege(uid)
+      end
+
     end
 
     # Creates a working server on host:port (strange things happen if
@@ -471,16 +506,8 @@ module Unicorn
     # is stale for >timeout seconds, then we'll kill the corresponding
     # worker.
     def murder_lazy_workers
-      diff = stat = nil
       WORKERS.dup.each_pair do |wpid, worker|
-        stat = begin
-          worker.tmp.stat
-        rescue => e
-          logger.warn "worker=#{worker.nr} PID:#{wpid} stat error: #{e.inspect}"
-          kill_worker(:QUIT, wpid)
-          next
-        end
-        (diff = (Time.now - stat.ctime)) <= timeout and next
+        (diff = (Time.now - worker.tmp.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
@@ -490,13 +517,6 @@ module Unicorn
     def spawn_missing_workers
       (0...worker_processes).each do |worker_nr|
         WORKERS.values.include?(worker_nr) and next
-        begin
-          Dir.chdir(START_CTX[:cwd])
-        rescue Errno::ENOENT => err
-          logger.fatal "#{err.inspect} (#{START_CTX[:cwd]})"
-          SIG_QUEUE << :QUIT # forcibly emulate SIGQUIT
-          return
-        end
         worker = Worker.new(worker_nr, Unicorn::Util.tmpio)
         before_fork.call(self, worker)
         WORKERS[fork { worker_loop(worker) }] = worker
@@ -511,6 +531,27 @@ module Unicorn
       }
     end
 
+    # 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.write_nonblock(msg)
+      client.close
+      rescue
+        nil
+    end
+
     # once a client is accepted, it is processed in its entirety here
     # in 3 easy steps: read request, call app, write app response
     def process_client(client)
@@ -523,21 +564,8 @@ module Unicorn
         response = app.call(env)
       end
       HttpResponse.write(client, response, HttpRequest::PARSER.headers?)
-    # 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
-      client.write_nonblock(Const::ERROR_500_RESPONSE) rescue nil
-      client.close rescue nil
-    rescue HttpParserError # try to tell the client they're bad
-      client.write_nonblock(Const::ERROR_400_RESPONSE) rescue nil
-      client.close rescue nil
-    rescue Object => e
-      client.write_nonblock(Const::ERROR_500_RESPONSE) rescue nil
-      client.close rescue nil
-      logger.error "Read error: #{e.inspect}"
-      logger.error e.backtrace.join("\n")
+    rescue => e
+      handle_error(client, e)
     end
 
     # gets rid of stuff the worker has no business keeping track of

data/lib/unicorn/configurator.rb

@@ -9,6 +9,7 @@ module Unicorn
   #
   # 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
   #   listen 9292, :tcp_nopush => true
   #   timeout 10
@@ -93,6 +94,15 @@ module Unicorn
 
     def reload #:nodoc:
       instance_eval(File.read(config_file), config_file) if config_file
+
+      # 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|
+        String === (path = set[var]) or next
+        path = File.expand_path(path)
+        test(?w, path) || test(?w, File.dirname(path)) or \
+              raise ArgumentError, "directory for #{var}=#{path} not writable"
+      end
     end
 
     def commit!(server, options = {}) #:nodoc:
@@ -137,16 +147,7 @@ module Unicorn
     #    # drop permissions to "www-data" in the worker
     #    # generally there's no reason to start Unicorn as a priviledged user
     #    # as it is not recommended to expose Unicorn to public clients.
-    #    uid, gid = Process.euid, Process.egid
-    #    user, group = 'www-data', 'www-data'
-    #    target_uid = Etc.getpwnam(user).uid
-    #    target_gid = Etc.getgrnam(group).gid
-    #    worker.tmp.chown(target_uid, target_gid)
-    #    if uid != target_uid || gid != target_gid
-    #      Process.initgroups(user, target_gid)
-    #      Process::GID.change_privilege(target_gid)
-    #      Process::UID.change_privilege(target_uid)
-    #    end
+    #    worker.user('www-data', 'www-data') if Process.euid == 0
     #  end
     def after_fork(*args, &block)
       set_hook(:after_fork, block_given? ? block : args[0])
@@ -345,6 +346,16 @@ module Unicorn
       set_path(:stdout_path, path)
     end
 
+    # sets the working directory for Unicorn.  This ensures USR2 will
+    # start a new instance of Unicorn in this directory.  This may be
+    # a symlink.
+    def working_directory(path)
+      # just let chdir raise errors
+      path = File.expand_path(path)
+      Dir.chdir(path)
+      HttpServer::START_CTX[:cwd] = ENV["PWD"] = path
+    end
+
     # expands "unix:path/to/foo" to a socket relative to the current path
     # expands pathnames of sockets if relative to "~" or "~username"
     # expands "*:port and ":port" to "0.0.0.0:port"
@@ -372,15 +383,11 @@ module Unicorn
 
     def set_path(var, path) #:nodoc:
       case path
-      when NilClass
-      when String
-        path = File.expand_path(path)
-        File.writable?(File.dirname(path)) or \
-               raise ArgumentError, "directory for #{var}=#{path} not writable"
+      when NilClass, String
+        set[var] = path
       else
         raise ArgumentError
       end
-      set[var] = path
     end
 
     def set_hook(var, my_proc, req_arity = 2) #:nodoc:

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.93.5"
+    UNICORN_VERSION="0.94.0"
 
     DEFAULT_HOST = "0.0.0.0" # default TCP listen host address
     DEFAULT_PORT = 8080      # default TCP listen port

data/lib/unicorn/tee_input.rb

@@ -38,7 +38,7 @@ module Unicorn
         @tmp.seek(pos)
       end
 
-      @size = tmp_size
+      @size = @tmp.size
     end
 
     # call-seq:
@@ -73,7 +73,7 @@ module Unicorn
         rv
       else
         rv = args.shift || @buf2.dup
-        diff = tmp_size - @tmp.pos
+        diff = @tmp.size - @tmp.pos
         if 0 == diff
           ensure_length(tee(length, rv), length)
         else
@@ -87,7 +87,7 @@ module Unicorn
       socket or return @tmp.gets
       nil == $/ and return read
 
-      orig_size = tmp_size
+      orig_size = @tmp.size
       if @tmp.pos == orig_size
         tee(Const::CHUNK_SIZE, @buf2) or return nil
         @tmp.seek(orig_size)
@@ -142,15 +142,11 @@ module Unicorn
 
     def finalize_input
       while parser.trailers(req, buf).nil?
-        buf << socket.readpartial(Const::CHUNK_SIZE, @buf2)
+        buf << socket.readpartial(Const::CHUNK_SIZE)
       end
       self.socket = nil
     end
 
-    def tmp_size
-      StringIO === @tmp ? @tmp.size : @tmp.stat.size
-    end
-
     # tee()s into +buf+ 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)

data/lib/unicorn/util.rb

@@ -4,6 +4,16 @@ require 'fcntl'
 require 'tmpdir'
 
 module Unicorn
+
+  class TmpIO < ::File
+
+    # for easier env["rack.input"] compatibility
+    def size
+      # flush if sync
+      stat.size
+    end
+  end
+
   class Util
     class << self
 
@@ -21,7 +31,7 @@ module Unicorn
 
         ObjectSpace.each_object(File) do |fp|
           next if fp.closed?
-          next unless (fp.sync && fp.path[0..0] == "/")
+          next unless (fp.sync && fp.path[0] == ?/)
           next unless (fp.fcntl(Fcntl::F_GETFL) & append_flags) == append_flags
 
           begin
@@ -47,8 +57,8 @@ module Unicorn
       # buffering is disabled
       def tmpio
         fp = begin
-          File.open("#{Dir::tmpdir}/#{rand}",
-                    File::RDWR|File::CREAT|File::EXCL, 0600)
+          TmpIO.open("#{Dir::tmpdir}/#{rand}",
+                     File::RDWR|File::CREAT|File::EXCL, 0600)
         rescue Errno::EEXIST
           retry
         end

data/test/exec/test_exec.rb

@@ -28,6 +28,13 @@ use Rack::ContentLength
 run proc { |env| [ 200, { 'Content-Type' => 'text/plain' }, [ "HI\\n" ] ] }
   EOS
 
+  SHOW_RACK_ENV = <<-EOS
+use Rack::ContentLength
+run proc { |env|
+  [ 200, { 'Content-Type' => 'text/plain' }, [ ENV['RACK_ENV'] ] ]
+}
+  EOS
+
   HELLO = <<-EOS
 class Hello
   def call(env)
@@ -75,6 +82,91 @@ end
     end
   end
 
+  def test_working_directory
+    other = Tempfile.new('unicorn.wd')
+    File.unlink(other.path)
+    Dir.mkdir(other.path)
+    File.open("config.ru", "wb") do |fp|
+      fp.syswrite <<EOF
+use Rack::ContentLength
+run proc { |env| [ 200, { 'Content-Type' => 'text/plain' }, [ Dir.pwd ] ] }
+EOF
+    end
+    FileUtils.cp("config.ru", other.path + "/config.ru")
+    tmp = Tempfile.new('unicorn.config')
+    tmp.syswrite <<EOF
+working_directory '#@tmpdir'
+listen '#@addr:#@port'
+EOF
+    pid = xfork { redirect_test_io { exec($unicorn_bin, "-c#{tmp.path}") } }
+    wait_workers_ready("test_stderr.#{pid}.log", 1)
+    results = hit(["http://#@addr:#@port/"])
+    assert_equal @tmpdir, results.first
+    File.truncate("test_stderr.#{pid}.log", 0)
+
+    tmp.sysseek(0)
+    tmp.truncate(0)
+    tmp.syswrite <<EOF
+working_directory '#{other.path}'
+listen '#@addr:#@port'
+EOF
+
+    Process.kill(:HUP, pid)
+    wait_workers_ready("test_stderr.#{pid}.log", 1)
+    results = hit(["http://#@addr:#@port/"])
+    assert_equal other.path, results.first
+
+    Process.kill(:QUIT, pid)
+    ensure
+      FileUtils.rmtree(other.path)
+  end
+
+  def test_working_directory_controls_relative_paths
+    other = Tempfile.new('unicorn.wd')
+    File.unlink(other.path)
+    Dir.mkdir(other.path)
+    File.open("config.ru", "wb") do |fp|
+      fp.syswrite <<EOF
+use Rack::ContentLength
+run proc { |env| [ 200, { 'Content-Type' => 'text/plain' }, [ Dir.pwd ] ] }
+EOF
+    end
+    FileUtils.cp("config.ru", other.path + "/config.ru")
+    system('mkfifo', "#{other.path}/fifo")
+    tmp = Tempfile.new('unicorn.config')
+    tmp.syswrite <<EOF
+pid "pid_file_here"
+stderr_path "stderr_log_here"
+stdout_path "stdout_log_here"
+working_directory '#{other.path}'
+listen '#@addr:#@port'
+after_fork do |server, worker|
+  File.open("fifo", "wb").close
+end
+EOF
+    pid = xfork { redirect_test_io { exec($unicorn_bin, "-c#{tmp.path}") } }
+    File.open("#{other.path}/fifo", "rb").close
+
+    assert ! File.exist?("stderr_log_here")
+    assert ! File.exist?("stdout_log_here")
+    assert ! File.exist?("pid_file_here")
+
+    assert ! File.exist?("#@tmpdir/stderr_log_here")
+    assert ! File.exist?("#@tmpdir/stdout_log_here")
+    assert ! File.exist?("#@tmpdir/pid_file_here")
+
+    assert File.exist?("#{other.path}/pid_file_here")
+    assert_equal "#{pid}\n", File.read("#{other.path}/pid_file_here")
+    assert File.exist?("#{other.path}/stderr_log_here")
+    assert File.exist?("#{other.path}/stdout_log_here")
+    wait_master_ready("#{other.path}/stderr_log_here")
+
+    Process.kill(:QUIT, pid)
+    ensure
+      FileUtils.rmtree(other.path)
+  end
+
+
   def test_exit_signals
     %w(INT TERM QUIT).each do |sig|
       File.open("config.ru", "wb") { |fp| fp.syswrite(HI) }
@@ -102,6 +194,46 @@ end
     assert_shutdown(pid)
   end
 
+  def test_rack_env_unset
+    File.open("config.ru", "wb") { |fp| fp.syswrite(SHOW_RACK_ENV) }
+    pid = fork { redirect_test_io { exec($unicorn_bin, "-l#@addr:#@port") } }
+    results = retry_hit(["http://#{@addr}:#{@port}/"])
+    assert_equal "development", results.first
+    assert_shutdown(pid)
+  end
+
+  def test_rack_env_cli_set
+    File.open("config.ru", "wb") { |fp| fp.syswrite(SHOW_RACK_ENV) }
+    pid = fork {
+      redirect_test_io { exec($unicorn_bin, "-l#@addr:#@port", "-Easdf") }
+    }
+    results = retry_hit(["http://#{@addr}:#{@port}/"])
+    assert_equal "asdf", results.first
+    assert_shutdown(pid)
+  end
+
+  def test_rack_env_ENV_set
+    File.open("config.ru", "wb") { |fp| fp.syswrite(SHOW_RACK_ENV) }
+    pid = fork {
+      ENV["RACK_ENV"] = "foobar"
+      redirect_test_io { exec($unicorn_bin, "-l#@addr:#@port") }
+    }
+    results = retry_hit(["http://#{@addr}:#{@port}/"])
+    assert_equal "foobar", results.first
+    assert_shutdown(pid)
+  end
+
+  def test_rack_env_cli_override_ENV
+    File.open("config.ru", "wb") { |fp| fp.syswrite(SHOW_RACK_ENV) }
+    pid = fork {
+      ENV["RACK_ENV"] = "foobar"
+      redirect_test_io { exec($unicorn_bin, "-l#@addr:#@port", "-Easdf") }
+    }
+    results = retry_hit(["http://#{@addr}:#{@port}/"])
+    assert_equal "asdf", results.first
+    assert_shutdown(pid)
+  end
+
   def test_ttin_ttou
     File.open("config.ru", "wb") { |fp| fp.syswrite(HI) }
     pid = fork { redirect_test_io { exec($unicorn_bin, "-l#@addr:#@port") } }

data/test/test_helper.rb

@@ -145,7 +145,7 @@ def retry_hit(uris = [])
   tries = DEFAULT_TRIES
   begin
     hit(uris)
-  rescue Errno::ECONNREFUSED => err
+  rescue Errno::EINVAL, Errno::ECONNREFUSED => err
     if (tries -= 1) > 0
       sleep DEFAULT_RES
       retry

data/test/unit/test_http_parser_ng.rb

@@ -12,6 +12,24 @@ class HttpParserNgTest < Test::Unit::TestCase
     @parser = HttpParser.new
   end
 
+  def test_identity_byte_headers
+    req = {}
+    str = "PUT / HTTP/1.1\r\n"
+    str << "Content-Length: 123\r\n"
+    str << "\r"
+    hdr = ""
+    str.each_byte { |byte|
+      assert_nil @parser.headers(req, hdr << byte.chr)
+    }
+    hdr << "\n"
+    assert_equal req.object_id, @parser.headers(req, hdr).object_id
+    assert_equal '123', req['CONTENT_LENGTH']
+    assert_equal 0, hdr.size
+    assert ! @parser.keepalive?
+    assert @parser.headers?
+    assert 123, @parser.content_length
+  end
+
   def test_identity_step_headers
     req = {}
     str = "PUT / HTTP/1.1\r\n"
@@ -172,6 +190,26 @@ class HttpParserNgTest < Test::Unit::TestCase
     assert ! @parser.keepalive?
   end
 
+  def test_chunks_bytewise
+    chunked = "10\r\nabcdefghijklmnop\r\n11\r\n0123456789abcdefg\r\n0\r\n"
+    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n#{chunked}"
+    req = {}
+    assert_equal req, @parser.headers(req, str)
+    assert_equal chunked, str
+    tmp = ''
+    buf = ''
+    body = ''
+    str = str[0..-2]
+    str.each_byte { |byte|
+      assert_nil @parser.filter_body(tmp, buf << byte.chr)
+      body << tmp
+    }
+    assert_equal 'abcdefghijklmnop0123456789abcdefg', body
+    rv = @parser.filter_body(tmp, buf << "\n")
+    assert_equal rv.object_id, buf.object_id
+    assert ! @parser.keepalive?
+  end
+
   def test_trailers
     str = "PUT / HTTP/1.1\r\n" \
           "Trailer: Content-MD5\r\n" \
@@ -199,6 +237,34 @@ class HttpParserNgTest < Test::Unit::TestCase
     assert ! @parser.keepalive?
   end
 
+  def test_trailers_slowly
+    str = "PUT / HTTP/1.1\r\n" \
+          "Trailer: Content-MD5\r\n" \
+          "transfer-Encoding: chunked\r\n\r\n" \
+          "1\r\na\r\n2\r\n..\r\n0\r\n"
+    req = {}
+    assert_equal req, @parser.headers(req, str)
+    assert_equal 'Content-MD5', req['HTTP_TRAILER']
+    assert_nil req['HTTP_CONTENT_MD5']
+    tmp = ''
+    assert_nil @parser.filter_body(tmp, str)
+    assert_equal 'a..', tmp
+    md5_b64 = [ Digest::MD5.digest(tmp) ].pack('m').strip.freeze
+    rv = @parser.filter_body(tmp, str)
+    assert_equal rv.object_id, str.object_id
+    assert_equal '', str
+    assert_nil @parser.trailers(req, str)
+    md5_hdr = "Content-MD5: #{md5_b64}\r\n".freeze
+    md5_hdr.each_byte { |byte|
+      str << byte.chr
+      assert_nil @parser.trailers(req, str)
+    }
+    assert_equal md5_b64, req['HTTP_CONTENT_MD5']
+    assert_equal "CONTENT_MD5: #{md5_b64}\r\n", str
+    assert_nil @parser.trailers(req, str << "\r")
+    assert_equal req, @parser.trailers(req, str << "\n")
+  end
+
   def test_max_chunk
     str = "PUT / HTTP/1.1\r\n" \
           "transfer-Encoding: chunked\r\n\r\n" \

data/test/unit/test_signals.rb

@@ -26,14 +26,15 @@ class SignalsTest < Test::Unit::TestCase
     @bs = 1 * 1024 * 1024
     @count = 100
     @port = unused_port
-    tmp = @tmp = Tempfile.new('unicorn.sock')
+    @sock = Tempfile.new('unicorn.sock')
+    @tmp = Tempfile.new('unicorn.write')
+    @tmp.sync = true
+    File.unlink(@sock.path)
     File.unlink(@tmp.path)
-    n = 0
-    tmp.chmod(0)
     @server_opts = {
-      :listeners => [ "127.0.0.1:#@port", @tmp.path ],
+      :listeners => [ "127.0.0.1:#@port", @sock.path ],
       :after_fork => lambda { |server,worker|
-        trap(:HUP) { tmp.chmod(n += 1) }
+        trap(:HUP) { @tmp.syswrite('.') }
       },
     }
     @server = nil
@@ -143,7 +144,7 @@ class SignalsTest < Test::Unit::TestCase
     end
     assert pid > 0, "pid not positive: #{pid.inspect}"
     read = buf.size
-    mode_before = @tmp.stat.mode
+    size_before = @tmp.stat.size
     assert_raises(EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,
                   Errno::EBADF) do
       loop do
@@ -156,8 +157,10 @@ class SignalsTest < Test::Unit::TestCase
 
     redirect_test_io { @server.stop(true) }
     # can't check for == since pending signals get merged
-    assert mode_before < @tmp.stat.mode
-    assert_equal(read - header_len, @bs * @count)
+    assert size_before < @tmp.stat.size
+    got = read - header_len
+    expect = @bs * @count
+    assert_equal(expect, got, "expect=#{expect} got=#{got}")
     assert_nothing_raised { sock.close }
   end
 
@@ -183,7 +186,7 @@ class SignalsTest < Test::Unit::TestCase
     sock.syswrite("PUT / HTTP/1.0\r\n")
     sock.syswrite("Content-Length: #{@bs * @count}\r\n\r\n")
     1000.times { Process.kill(:HUP, pid) }
-    mode_before = @tmp.stat.mode
+    size_before = @tmp.stat.size
     killer = fork { loop { Process.kill(:HUP, pid); sleep(0.0001) } }
     buf = ' ' * @bs
     @count.times { sock.syswrite(buf) }
@@ -191,7 +194,7 @@ class SignalsTest < Test::Unit::TestCase
     Process.waitpid2(killer)
     redirect_test_io { @server.stop(true) }
     # can't check for == since pending signals get merged
-    assert mode_before < @tmp.stat.mode
+    assert size_before < @tmp.stat.size
     assert_equal pid, sock.sysread(4096)[/\r\nX-Pid: (\d+)\r\n/, 1].to_i
     sock.close
   end

data/test/unit/test_tee_input.rb

@@ -127,7 +127,7 @@ class TestTeeInput < Test::Unit::TestCase
     assert ! @parser.body_eof?
     assert_kind_of File, ti.instance_eval { @tmp }
     assert_equal 0, ti.instance_eval { @tmp.pos }
-    assert_equal 1, ti.instance_eval { tmp_size }
+    assert_equal 1, ti.instance_eval { @tmp.size }
     assert_equal Unicorn::Const::MAX_BODY + 1, ti.size
     nr = Unicorn::Const::MAX_BODY / 4
     pid = fork {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: unicorn
 version: !ruby/object:Gem::Version 
-  version: 0.93.5
+  version: 0.94.0
 platform: ruby
 authors: 
 - Unicorn developers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-29 00:00:00 -07:00
+date: 2009-11-05 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency