unicorn 0.96.1 → 0.97.0

data/ext/unicorn_http/c_util.h

@@ -29,6 +29,19 @@
 #  error off_t size unknown for this platform!
 #endif /* SIZEOF_OFF_T check */
 
+/*
+ * ragel enforces fpc as a const, and merely casting can make picky
+ * compilers unhappy, so we have this little helper do our dirty work
+ */
+static inline void *deconst(const void *in)
+{
+  union { const void *in; void *out; } tmp;
+
+  tmp.in = in;
+
+  return tmp.out;
+}
+
 /*
  * capitalizes all lower-case ASCII characters and converts dashes
  * to underscores for HTTP headers.  Locale-agnostic.

data/ext/unicorn_http/common_field_optimization.h

@@ -67,7 +67,7 @@ static void init_common_fields(void)
   char tmp[64];
   memcpy(tmp, HTTP_PREFIX, HTTP_PREFIX_LEN);
 
-  for(i = 0; i < ARRAY_SIZE(common_http_fields); cf++, i++) {
+  for(i = ARRAY_SIZE(common_http_fields); --i >= 0; cf++) {
     /* Rack doesn't like certain headers prefixed with "HTTP_" */
     if (!strcmp("CONTENT_LENGTH", cf->name) ||
         !strcmp("CONTENT_TYPE", cf->name)) {
@@ -87,8 +87,8 @@ static VALUE find_common_field(const char *field, size_t flen)
   int i;
   struct common_field *cf = common_http_fields;
 
-  for(i = 0; i < ARRAY_SIZE(common_http_fields); i++, cf++) {
-    if (cf->len == flen && !memcmp(cf->name, field, flen))
+  for(i = ARRAY_SIZE(common_http_fields); --i >= 0; cf++) {
+    if (cf->len == (long)flen && !memcmp(cf->name, field, flen))
       return cf->value;
   }
   return Qnil;

data/ext/unicorn_http/ext_help.h

@@ -47,7 +47,7 @@ static void rb_18_str_set_len(VALUE str, long len)
 #  define rb_str_modify(x) do {} while (0)
 #endif /* ! defined(HAVE_RB_STR_MODIFY) */
 
-static inline int str_cstr_eq(VALUE val, const char *ptr, size_t len)
+static inline int str_cstr_eq(VALUE val, const char *ptr, long len)
 {
   return (RSTRING_LEN(val) == len && !memcmp(ptr, RSTRING_PTR(val), len));
 }
@@ -56,7 +56,7 @@ static inline int str_cstr_eq(VALUE val, const char *ptr, size_t len)
   str_cstr_eq(val, const_str, sizeof(const_str) - 1)
 
 /* strcasecmp isn't locale independent */
-static int str_cstr_case_eq(VALUE val, const char *ptr, size_t len)
+static int str_cstr_case_eq(VALUE val, const char *ptr, long len)
 {
   if (RSTRING_LEN(val) == len) {
     const char *v = RSTRING_PTR(val);

data/ext/unicorn_http/global_variables.h

@@ -1,7 +1,5 @@
 #ifndef global_variables_h
 #define global_variables_h
-static VALUE mUnicorn;
-static VALUE cHttpParser;
 static VALUE eHttpParserError;
 
 static VALUE g_rack_url_scheme;
@@ -61,7 +59,7 @@ DEF_MAX_LENGTH(REQUEST_PATH, 1024);
 DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
 DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
 
-void init_globals(void)
+static void init_globals(void)
 {
   DEF_GLOBAL(rack_url_scheme, "rack.url_scheme");
   DEF_GLOBAL(request_method, "REQUEST_METHOD");

data/ext/unicorn_http/unicorn_http.rl

@@ -136,7 +136,7 @@ static inline void hp_invalid_if_trailer(struct http_parser *hp)
 }
 
 static void write_cont_value(struct http_parser *hp,
-                             const char *buffer, const char *p)
+                             char *buffer, const char *p)
 {
   char *vptr;
 
@@ -154,7 +154,7 @@ static void write_cont_value(struct http_parser *hp,
   if (RSTRING_LEN(hp->cont) > 0)
     --hp->mark;
 
-  vptr = (char *)PTR_TO(mark);
+  vptr = PTR_TO(mark);
 
   if (RSTRING_LEN(hp->cont) > 0) {
     assert((' ' == *vptr || '\t' == *vptr) && "invalid leading white space");
@@ -220,8 +220,8 @@ static void write_value(VALUE req, struct http_parser *hp,
   action mark {MARK(mark, fpc); }
 
   action start_field { MARK(start.field, fpc); }
-  action snake_upcase_field { snake_upcase_char((char *)fpc); }
-  action downcase_char { downcase_char((char *)fpc); }
+  action snake_upcase_field { snake_upcase_char(deconst(fpc)); }
+  action downcase_char { downcase_char(deconst(fpc)); }
   action write_field { hp->s.field_len = LEN(start.field, fpc); }
   action start_value { MARK(mark, fpc); }
   action write_value { write_value(req, hp, buffer, fpc); }
@@ -236,10 +236,9 @@ static void write_value(VALUE req, struct http_parser *hp,
     rb_hash_aset(req, g_http_host, STR_NEW(mark, fpc));
   }
   action request_uri {
-    size_t len = LEN(mark, fpc);
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(len, REQUEST_URI);
+    VALIDATE_MAX_LENGTH(LEN(mark, fpc), REQUEST_URI);
     str = rb_hash_aset(req, g_request_uri, STR_NEW(mark, fpc));
     /*
      * "OPTIONS * HTTP/1.1\r\n" is a valid request, but we can't have '*'
@@ -263,9 +262,8 @@ static void write_value(VALUE req, struct http_parser *hp,
   action http_version { http_version(hp, req, PTR_TO(mark), LEN(mark, fpc)); }
   action request_path {
     VALUE val;
-    size_t len = LEN(mark, fpc);
 
-    VALIDATE_MAX_LENGTH(len, REQUEST_PATH);
+    VALIDATE_MAX_LENGTH(LEN(mark, fpc), REQUEST_PATH);
     val = rb_hash_aset(req, g_request_path, STR_NEW(mark, fpc));
 
     /* rack says PATH_INFO must start with "/" or be empty */
@@ -314,13 +312,13 @@ static void write_value(VALUE req, struct http_parser *hp,
 
   action skip_chunk_data {
   skip_chunk_data_hack: {
-    size_t nr = MIN(hp->len.chunk, REMAINING);
+    size_t nr = MIN((size_t)hp->len.chunk, REMAINING);
     memcpy(RSTRING_PTR(req) + hp->s.dest_offset, fpc, nr);
     hp->s.dest_offset += nr;
     hp->len.chunk -= nr;
     p += nr;
     assert(hp->len.chunk >= 0 && "negative chunk length");
-    if (hp->len.chunk > REMAINING) {
+    if ((size_t)hp->len.chunk > REMAINING) {
       HP_FL_SET(hp, INCHUNK);
       goto post_exec;
     } else {
@@ -346,7 +344,7 @@ static void http_parser_init(struct http_parser *hp)
 
 /** exec **/
 static void http_parser_execute(struct http_parser *hp,
-  VALUE req, const char *buffer, size_t len)
+  VALUE req, char *buffer, size_t len)
 {
   const char *p, *pe;
   int cs = hp->cs;
@@ -360,7 +358,8 @@ static void http_parser_execute(struct http_parser *hp,
   p = buffer+off;
   pe = buffer+len;
 
-  assert(pe - p == len - off && "pointers aren't same distance");
+  assert((void *)(pe - p) == (void *)(len - off) &&
+         "pointers aren't same distance");
 
   if (HP_FL_TEST(hp, INCHUNK)) {
     HP_FL_UNSET(hp, INCHUNK);
@@ -675,10 +674,13 @@ static VALUE HttpParser_filter_body(VALUE self, VALUE buf, VALUE data)
 
 void Init_unicorn_http(void)
 {
+  VALUE mUnicorn, cHttpParser;
+
   mUnicorn = rb_define_module("Unicorn");
+  cHttpParser = rb_define_class_under(mUnicorn, "HttpParser", rb_cObject);
   eHttpParserError =
          rb_define_class_under(mUnicorn, "HttpParserError", rb_eIOError);
-  cHttpParser = rb_define_class_under(mUnicorn, "HttpParser", rb_cObject);
+
   init_globals();
   rb_define_alloc_func(cHttpParser, HttpParser_alloc);
   rb_define_method(cHttpParser, "initialize", HttpParser_init,0);

data/lib/unicorn.rb

@@ -2,6 +2,7 @@
 
 require 'fcntl'
 require 'unicorn/socket_helper'
+require 'etc'
 autoload :Rack, 'rack'
 
 # Unicorn module containing all of the classes (include C extensions) for running
@@ -27,6 +28,49 @@ module Unicorn
     def run(app, options = {})
       HttpServer.new(app, options).start.join
     end
+
+    # This returns a lambda to pass in as the app, this does not "build" the
+    # app (which we defer based on the outcome of "preload_app" in the
+    # 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
+
+      lambda do ||
+        inner_app = case ru
+        when /\.ru$/
+          raw = File.read(ru)
+          raw.sub!(/^__END__\n.*/, '')
+          eval("Rack::Builder.new {(#{raw}\n)}.to_app", TOPLEVEL_BINDING, ru)
+        else
+          require ru
+          Object.const_get(File.basename(ru, '.rb').capitalize)
+        end
+
+        pp({ :inner_app => inner_app }) if $DEBUG
+
+        # return value, matches rackup defaults based on env
+        case ENV["RACK_ENV"]
+        when "development"
+          Rack::Builder.new do
+            use Rack::CommonLogger, $stderr
+            use Rack::ShowExceptions
+            use Rack::Lint
+            run inner_app
+          end.to_app
+        when "deployment"
+          Rack::Builder.new do
+            use Rack::CommonLogger, $stderr
+            run inner_app
+          end.to_app
+        else
+          inner_app
+        end
+      end
+    end
   end
 
   # This is the process manager of Unicorn. This manages worker
@@ -34,11 +78,11 @@ module Unicorn
   # Listener sockets are started in the master process and shared with
   # forked worker children.
 
-  class HttpServer < Struct.new(:listener_opts, :timeout, :worker_processes,
+  class HttpServer < Struct.new(:app, :timeout, :worker_processes,
                                 :before_fork, :after_fork, :before_exec,
-                                :logger, :pid, :app, :preload_app,
+                                :logger, :pid, :listener_opts, :preload_app,
                                 :reexec_pid, :orig_app, :init_listeners,
-                                :master_pid, :config, :ready_pipe)
+                                :master_pid, :config, :ready_pipe, :user)
     include ::Unicorn::SocketHelper
 
     # prevents IO objects in here from being GC-ed
@@ -119,9 +163,7 @@ module Unicorn
     # releases of Unicorn.  You may need to access it in the
     # before_fork/after_fork hooks.  See the Unicorn::Configurator RDoc
     # for examples.
-    class Worker < Struct.new(:nr, :tmp)
-
-      autoload :Etc, 'etc'
+    class Worker < Struct.new(:nr, :tmp, :switched)
 
       # worker objects may be compared to just plain numbers
       def ==(other_nr)
@@ -151,6 +193,7 @@ module Unicorn
           Process::GID.change_privilege(gid)
         end
         Process.euid != uid and Process::UID.change_privilege(uid)
+        self.switched = true
       end
 
     end
@@ -210,7 +253,18 @@ module Unicorn
       end
       config_listeners.each { |addr| listen(addr) }
       raise ArgumentError, "no listeners" if LISTENERS.empty?
+
+      # this pipe is used to wake us up from select(2) in #join when signals
+      # are trapped.  See trap_deferred.
+      init_self_pipe!
+
+      # setup signal handlers before writing pid file in case people get
+      # trigger happy and send signals as soon as the pid file exists.
+      # Note that signals don't actually get handled until the #join method
+      QUEUE_SIGS.each { |sig| trap_deferred(sig) }
+      trap(:CHLD) { |_| awaken_master }
       self.pid = config[:pid]
+
       self.master_pid = $$
       build_app! if preload_app
       maintain_worker_count
@@ -322,14 +376,9 @@ module Unicorn
     # one-at-a-time time and we'll happily drop signals in case somebody
     # is signalling us too often.
     def join
-      # this pipe is used to wake us up from select(2) in #join when signals
-      # are trapped.  See trap_deferred
-      init_self_pipe!
       respawn = true
       last_check = Time.now
 
-      QUEUE_SIGS.each { |sig| trap_deferred(sig) }
-      trap(:CHLD) { |sig_nr| awaken_master }
       proc_name 'master'
       logger.info "master process ready" # test_exec.rb relies on this message
       if ready_pipe
@@ -610,6 +659,7 @@ module Unicorn
       LISTENERS.each { |sock| sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
       worker.tmp.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
       after_fork.call(self, worker) # can drop perms
+      worker.user(*user) if user.kind_of?(Array) && ! worker.switched
       self.timeout /= 2.0 # halve it for select()
       build_app! unless preload_app
     end
@@ -725,6 +775,7 @@ module Unicorn
     end
 
     def load_config!
+      loaded_app = app
       begin
         logger.info "reloading config_file=#{config.config_file}"
         config[:listeners].replace(init_listeners)
@@ -735,9 +786,10 @@ module Unicorn
         self.app = orig_app
         build_app! if preload_app
         logger.info "done reloading config_file=#{config.config_file}"
-      rescue => e
+      rescue StandardError, LoadError, SyntaxError => e
         logger.error "error reloading config_file=#{config.config_file}: " \
                      "#{e.class} #{e.message}"
+        self.app = loaded_app
       end
     end
 

data/lib/unicorn/configurator.rb

@@ -10,7 +10,7 @@ module Unicorn
   # See http://unicorn.bogomips.org/examples/unicorn.conf.rb for an
   # example config file.  An example config file for use with nginx is
   # also available at http://unicorn.bogomips.org/examples/nginx.conf
-  class Configurator < Struct.new(:set, :config_file)
+  class Configurator < Struct.new(:set, :config_file, :after_reload)
 
     # Default settings for Unicorn
     DEFAULTS = {
@@ -34,6 +34,10 @@ module Unicorn
       self.set = Hash.new(:unset)
       use_defaults = defaults.delete(:use_defaults)
       self.config_file = defaults.delete(:config_file)
+
+      # after_reload is only used by unicorn_rails, unsupported otherwise
+      self.after_reload = defaults.delete(:after_reload)
+
       set.merge!(DEFAULTS) if use_defaults
       defaults.each { |key, value| self.send(key, value) }
       Hash === set[:listener_opts] or
@@ -53,6 +57,9 @@ module Unicorn
         test(?w, path) || test(?w, 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:
@@ -329,6 +336,17 @@ module Unicorn
       HttpServer::START_CTX[:cwd] = ENV["PWD"] = path
     end
 
+    # Runs worker processes as the specified +user+ and +group+.
+    # The master process always stays running as the user who started it.
+    # This switch will occur after calling the after_fork hook, and only
+    # if the Worker#user method is not called in the after_fork hook
+    def user(user, group = nil)
+      # raises ArgumentError on invalid user/group
+      Etc.getpwnam(user)
+      Etc.getgrnam(group) if group
+      set[:user] = [ user, group ]
+    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"

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.96.1"
+    UNICORN_VERSION="0.97.0"
 
     DEFAULT_HOST = "0.0.0.0" # default TCP listen host address
     DEFAULT_PORT = 8080      # default TCP listen port
@@ -16,12 +16,9 @@ module Unicorn
     # The basic max request size we'll try to read.
     CHUNK_SIZE=(16 * 1024)
 
-    # This is the maximum header that is allowed before a client is booted.  The parser detects
-    # this, but we'd also like to do this as well.
-    MAX_HEADER=1024 * (80 + 32)
-
-    # Maximum request body size before it is moved out of memory and into a tempfile for reading.
-    MAX_BODY=MAX_HEADER
+    # Maximum request body size before it is moved out of memory and into a
+    # temporary file for reading (112 kilobytes).
+    MAX_BODY=1024 * 112
 
     # common errors we'll send back
     ERROR_400_RESPONSE = "HTTP/1.1 400 Bad Request\r\n\r\n"

data/lib/unicorn/http_request.rb

@@ -24,7 +24,7 @@ module Unicorn
 
     # Being explicitly single-threaded, we have certain advantages in
     # not having to worry about variables being clobbered :)
-    BUF = ' ' * Const::CHUNK_SIZE # initial size, may grow
+    BUF = ""
     PARSER = HttpParser.new
     REQ = {}
 

data/lib/unicorn/tee_input.rb

@@ -13,19 +13,19 @@ module Unicorn
   #
   # When processing uploads, Unicorn exposes a TeeInput object under
   # "rack.input" of the Rack environment.
-  class TeeInput < Struct.new(:socket, :req, :parser, :buf)
+  class TeeInput < Struct.new(:socket, :req, :parser, :buf, :len, :tmp, :buf2)
 
     # Initializes a new TeeInput object.  You normally do not have to call
     # this unless you are writing an HTTP server.
     def initialize(*args)
       super(*args)
-      @size = parser.content_length
-      @tmp = @size && @size < Const::MAX_BODY ? StringIO.new("") : Util.tmpio
-      @buf2 = buf.dup
+      self.len = parser.content_length
+      self.tmp = len && len < Const::MAX_BODY ? StringIO.new("") : Util.tmpio
+      self.buf2 = ""
       if buf.size > 0
-        parser.filter_body(@buf2, buf) and finalize_input
-        @tmp.write(@buf2)
-        @tmp.seek(0)
+        parser.filter_body(buf2, buf) and finalize_input
+        tmp.write(buf2)
+        tmp.seek(0)
       end
     end
 
@@ -40,16 +40,16 @@ module Unicorn
     # all of the input stream before returning since there's no other
     # way to determine the size of the request body beforehand.
     def size
-      @size and return @size
+      len and return len
 
       if socket
-        pos = @tmp.pos
-        while tee(Const::CHUNK_SIZE, @buf2)
+        pos = tmp.pos
+        while tee(Const::CHUNK_SIZE, buf2)
         end
-        @tmp.seek(pos)
+        tmp.seek(pos)
       end
 
-      @size = @tmp.size
+      self.len = tmp.size
     end
 
     # :call-seq:
@@ -72,22 +72,22 @@ module Unicorn
     # any data and only block when nothing is available (providing
     # IO#readpartial semantics).
     def read(*args)
-      socket or return @tmp.read(*args)
+      socket or return tmp.read(*args)
 
       length = args.shift
       if nil == length
-        rv = @tmp.read || ""
-        while tee(Const::CHUNK_SIZE, @buf2)
-          rv << @buf2
+        rv = tmp.read || ""
+        while tee(Const::CHUNK_SIZE, buf2)
+          rv << buf2
         end
         rv
       else
-        rv = args.shift || @buf2.dup
-        diff = @tmp.size - @tmp.pos
+        rv = args.shift || ""
+        diff = tmp.size - tmp.pos
         if 0 == diff
           ensure_length(tee(length, rv), length)
         else
-          ensure_length(@tmp.read(diff > length ? length : diff, rv), length)
+          ensure_length(tmp.read(diff > length ? length : diff, rv), length)
         end
       end
     end
@@ -102,26 +102,26 @@ module Unicorn
     # This takes zero arguments for strict Rack::Lint compatibility,
     # unlike IO#gets.
     def gets
-      socket or return @tmp.gets
+      socket or return tmp.gets
       nil == $/ and return read
 
-      orig_size = @tmp.size
-      if @tmp.pos == orig_size
-        tee(Const::CHUNK_SIZE, @buf2) or return nil
-        @tmp.seek(orig_size)
+      orig_size = tmp.size
+      if tmp.pos == orig_size
+        tee(Const::CHUNK_SIZE, buf2) or return nil
+        tmp.seek(orig_size)
       end
 
-      line = @tmp.gets # cannot be nil here since size > pos
+      line = tmp.gets # cannot be nil here since size > pos
       $/ == line[-$/.size, $/.size] and return line
 
-      # unlikely, if we got here, then @tmp is at EOF
+      # unlikely, if we got here, then tmp is at EOF
       begin
-        orig_size = @tmp.pos
-        tee(Const::CHUNK_SIZE, @buf2) or break
-        @tmp.seek(orig_size)
-        line << @tmp.gets
+        orig_size = tmp.pos
+        tee(Const::CHUNK_SIZE, buf2) or break
+        tmp.seek(orig_size)
+        line << tmp.gets
         $/ == line[-$/.size, $/.size] and return line
-        # @tmp is at EOF again here, retry the loop
+        # tmp is at EOF again here, retry the loop
       end while true
 
       line
@@ -147,7 +147,7 @@ module Unicorn
     # the offset (zero) of the +ios+ pointer.  Subsequent reads will
     # start from the beginning of the previously-buffered input.
     def rewind
-      @tmp.rewind # Rack does not specify what the return value is here
+      tmp.rewind # Rack does not specify what the return value is here
     end
 
   private
@@ -160,7 +160,7 @@ module Unicorn
         # _entire_ request has been sent, and those will not have
         # raised EOFError on us.
         socket.close if socket
-        raise ClientShutdown, "bytes_read=#{@tmp.size}", []
+        raise ClientShutdown, "bytes_read=#{tmp.size}", []
       when HttpParserError
         e.set_backtrace([])
       end
@@ -173,8 +173,8 @@ module Unicorn
     def tee(length, dst)
       unless parser.body_eof?
         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
+          tmp.write(dst)
+          tmp.seek(0, IO::SEEK_END) # workaround FreeBSD/OSX + MRI 1.8.x bug
           return dst
         end
       end
@@ -201,13 +201,13 @@ module Unicorn
     # streaming input bodies, this is a no-op for
     # "Transfer-Encoding: chunked" requests.
     def ensure_length(dst, length)
-      # @size is nil for chunked bodies, so we can't ensure length for those
+      # len 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 dst if dst.nil? || @size.nil?
+      return dst if dst.nil? || len.nil?
 
-      while dst.size < length && tee(length - dst.size, @buf2)
-        dst << @buf2
+      while dst.size < length && tee(length - dst.size, buf2)
+        dst << buf2
       end
 
       dst