unicorn 0.2.3 → 0.4.1

data/ext/unicorn/http11/http11_parser.h

@@ -36,10 +36,8 @@ typedef struct http_parser {
 
 int http_parser_init(http_parser *parser);
 int http_parser_finish(http_parser *parser);
-size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off);
+size_t http_parser_execute(http_parser *parser, const char *data, size_t len);
 int http_parser_has_error(http_parser *parser);
 int http_parser_is_finished(http_parser *parser);
 
-#define http_parser_nread(parser) (parser)->nread 
-
 #endif

data/ext/unicorn/http11/http11_parser.rl

@@ -105,9 +105,10 @@ int http_parser_init(http_parser *parser)  {
 
 
 /** exec **/
-size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  {
+size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len)  {
   const char *p, *pe;
   int cs = parser->cs;
+  size_t off = parser->nread;
 
   assert(off <= len && "offset past end of buffer");
 

data/lib/unicorn.rb

@@ -59,6 +59,7 @@ module Unicorn
       @request = @rd_sig = @wr_sig = nil
       @reexec_pid = 0
       @config = Configurator.new(options.merge(:use_defaults => true))
+      @listener_opts = {}
       @config.commit!(self, :skip => [:listeners, :pid])
       @listeners = []
     end
@@ -85,6 +86,9 @@ module Unicorn
       # share the same OS-level file descriptor as the higher-level *Server
       # objects; we need to prevent Socket objects from being garbage-collected
       config_listeners -= listener_names
+      if config_listeners.empty? && @listeners.empty?
+        config_listeners << Unicorn::Const::DEFAULT_LISTEN
+      end
       config_listeners.each { |addr| listen(addr) }
       raise ArgumentError, "no listeners" if @listeners.empty?
       self.pid = @config[:pid]
@@ -123,19 +127,19 @@ module Unicorn
           raise ArgumentError, "Already running on PID:#{x} " \
                                "(or pid=#{path} is stale)"
         end
-        File.open(path, 'wb') { |fp| fp.syswrite("#{$$}\n") }
       end
-      unlink_pid_safe(@pid) if @pid && @pid != path
+      unlink_pid_safe(@pid) if @pid
+      File.open(path, 'wb') { |fp| fp.syswrite("#$$\n") } if path
       @pid = path
     end
 
     # add a given address to the +listeners+ set, idempotently
     # Allows workers to add a private, per-process listener via the
     # @after_fork hook.  Very useful for debugging and testing.
-    def listen(address)
+    def listen(address, opt = {}.merge(@listener_opts[address] || {}))
       return if String === address && listener_names.include?(address)
 
-      if io = bind_listen(address, @backlog)
+      if io = bind_listen(address, opt)
         if Socket == io.class
           @io_purgatory << io
           io = server_cast(io)
@@ -157,12 +161,11 @@ module Unicorn
       # this pipe is used to wake us up from select(2) in #join when signals
       # are trapped.  See trap_deferred
       @rd_sig, @wr_sig = IO.pipe unless (@rd_sig && @wr_sig)
-      @rd_sig.nonblock = @wr_sig.nonblock = true
       mode = nil
       respawn = true
 
       QUEUE_SIGS.each { |sig| trap_deferred(sig) }
-      trap('CHLD') { |sig_nr| awaken_master }
+      trap(:CHLD) { |sig_nr| awaken_master }
       $0 = "unicorn master"
       logger.info "master process ready" # test_exec.rb relies on this message
       begin
@@ -173,27 +176,27 @@ module Unicorn
             murder_lazy_workers
             spawn_missing_workers if respawn
             master_sleep
-          when 'QUIT' # graceful shutdown
+          when :QUIT # graceful shutdown
             break
-          when 'TERM', 'INT' # immediate shutdown
+          when :TERM, :INT # immediate shutdown
             stop(false)
             break
-          when 'USR1' # rotate logs
+          when :USR1 # rotate logs
             logger.info "master rotating logs..."
             Unicorn::Util.reopen_logs
             logger.info "master done rotating logs"
-            kill_each_worker('USR1')
-          when 'USR2' # exec binary, stay alive in case something went wrong
+            kill_each_worker(:USR1)
+          when :USR2 # exec binary, stay alive in case something went wrong
             reexec
-          when 'WINCH'
+          when :WINCH
             if Process.ppid == 1 || Process.getpgrp != $$
               respawn = false
               logger.info "gracefully stopping all workers"
-              kill_each_worker('QUIT')
+              kill_each_worker(:QUIT)
             else
               logger.info "SIGWINCH ignored because we're not daemonized"
             end
-          when 'HUP'
+          when :HUP
             respawn = true
             if @config.config_file
               load_config!
@@ -221,7 +224,7 @@ module Unicorn
 
     # Terminates all workers, but does not exit master process
     def stop(graceful = true)
-      kill_each_worker(graceful ? 'QUIT' : 'TERM')
+      kill_each_worker(graceful ? :QUIT : :TERM)
       timeleft = @timeout
       step = 0.2
       reap_all_workers
@@ -229,7 +232,7 @@ module Unicorn
         sleep(step)
         reap_all_workers
         (timeleft -= step) > 0 and next
-        kill_each_worker('KILL')
+        kill_each_worker(:KILL)
       end
     ensure
       self.listeners = []
@@ -238,8 +241,7 @@ module Unicorn
     private
 
     # list of signals we care about and trap in master.
-    QUEUE_SIGS =
-      %w(WINCH QUIT INT TERM USR1 USR2 HUP).map { |x| x.freeze }.freeze
+    QUEUE_SIGS = [ :WINCH, :QUIT, :INT, :TERM, :USR1, :USR2, :HUP ].freeze
 
     # defer a signal for later processing in #join (master process)
     def trap_deferred(signal)
@@ -259,16 +261,16 @@ module Unicorn
       begin
         ready = IO.select([@rd_sig], nil, nil, 1)
         ready && ready[0] && ready[0][0] or return
-        loop { @rd_sig.sysread(Const::CHUNK_SIZE) }
+        loop { @rd_sig.read_nonblock(Const::CHUNK_SIZE) }
       rescue Errno::EAGAIN, Errno::EINTR
       end
     end
 
     def awaken_master
       begin
-        @wr_sig.syswrite('.') # wakeup master process from IO.select
-      rescue Errno::EAGAIN # pipe is full, master should wake up anyways
-      rescue Errno::EINTR
+        @wr_sig.write_nonblock('.') # wakeup master process from IO.select
+      rescue Errno::EAGAIN, Errno::EINTR
+        # pipe is full, master should wake up anyways
         retry
       end
     end
@@ -350,7 +352,7 @@ module Unicorn
       @workers.each_pair do |pid, worker|
         (now - worker.tempfile.ctime) <= @timeout and next
         logger.error "worker=#{worker.nr} PID:#{pid} is too old, killing"
-        kill_worker('KILL', pid) # take no prisoners for @timeout violations
+        kill_worker(:KILL, pid) # take no prisoners for @timeout violations
         worker.tempfile.close rescue nil
       end
     end
@@ -363,7 +365,7 @@ module Unicorn
           Dir.chdir(@start_ctx[:cwd])
         rescue Errno::ENOENT => err
           logger.fatal "#{err.inspect} (#{@start_ctx[:cwd]})"
-          @sig_queue << 'QUIT' # forcibly emulate SIGQUIT
+          @sig_queue << :QUIT # forcibly emulate SIGQUIT
           return
         end
         tempfile = Tempfile.new('') # as short as possible to save dir space
@@ -379,12 +381,21 @@ module Unicorn
     # 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)
-      env = @request.read(client) or return
+      client.nonblock = false
+      set_client_sockopt(client) if TCPSocket === client
+      env = @request.read(client)
       app_response = @app.call(env)
       HttpResponse.write(client, app_response)
+    # 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.closed? or client.close rescue nil
+      client.write_nonblock(Const::ERROR_500_RESPONSE) rescue nil
+    rescue HttpParserError # try to tell the client they're bad
+      client.write_nonblock(Const::ERROR_400_RESPONSE) rescue nil
     rescue Object => e
+      client.write_nonblock(Const::ERROR_500_RESPONSE) rescue nil
       logger.error "Read error: #{e.inspect}"
       logger.error e.backtrace.join("\n")
     ensure
@@ -405,12 +416,7 @@ module Unicorn
       build_app! unless @preload_app
       @sig_queue.clear
       QUEUE_SIGS.each { |sig| trap(sig, 'IGNORE') }
-      trap('CHLD', 'DEFAULT')
-      trap('USR1') do
-        @logger.info "worker=#{worker.nr} rotating logs..."
-        Unicorn::Util.reopen_logs
-        @logger.info "worker=#{worker.nr} done rotating logs"
-      end
+      trap(:CHLD, 'DEFAULT')
 
       $0 = "unicorn worker[#{worker.nr}]"
       @rd_sig.close if @rd_sig
@@ -435,13 +441,24 @@ module Unicorn
       alive = true
       ready = @listeners
       client = nil
-      %w(TERM INT).each { |sig| trap(sig) { exit(0) } } # instant shutdown
-      trap('QUIT') do
+      [:TERM, :INT].each { |sig| trap(sig) { exit(0) } } # instant shutdown
+      trap(:QUIT) do
         alive = false
         @listeners.each { |sock| sock.close rescue nil } # break IO.select
       end
+      reopen_logs, (rd, wr) = false, IO.pipe
+      trap(:USR1) { reopen_logs = true; rd.close rescue nil } # break IO.select
+      @logger.info "worker=#{worker.nr} ready"
 
       while alive && @master_pid == Process.ppid
+        if reopen_logs
+          reopen_logs = false
+          @logger.info "worker=#{worker.nr} rotating logs..."
+          Unicorn::Util.reopen_logs
+          @logger.info "worker=#{worker.nr} done rotating logs"
+          wr.close rescue nil
+          rd, wr = IO.pipe
+        end
         # we're a goner in @timeout seconds anyways if tempfile.chmod
         # breaks, so don't trap the exception.  Using fchmod() since
         # futimes() is not available in base Ruby and I very strongly
@@ -460,17 +477,14 @@ module Unicorn
               rescue Errno::EAGAIN
                 next
               end
-              accepted = client.sync = true
-              client.nonblock = false
-              set_client_sockopt(client) if TCPSocket === client
+              accepted = true
               process_client(client)
             rescue Errno::ECONNABORTED
               # client closed the socket even before accept
-              if client && !client.closed?
-                client.close rescue nil
-              end
+              client.close rescue nil
             end
             tempfile.chmod(nr += 1)
+            break if reopen_logs
           end
           client = nil
 
@@ -478,18 +492,18 @@ module Unicorn
           # we're probably reasonably busy, so avoid calling select(2)
           # and try to do a blind non-blocking accept(2) on everything
           # before we sleep again in select
-          if accepted
+          if accepted || reopen_logs
             ready = @listeners
           else
             begin
               tempfile.chmod(nr += 1)
               # timeout used so we can detect parent death:
-              ret = IO.select(@listeners, nil, nil, @timeout/2.0) or next
+              ret = IO.select(@listeners, nil, [rd], @timeout/2.0) or next
               ready = ret[0]
             rescue Errno::EINTR
               ready = @listeners
             rescue Errno::EBADF => e
-              exit(alive ? 1 : 0)
+              reopen_logs or exit(alive ? 1 : 0)
             end
           end
         rescue SystemExit => e
@@ -542,7 +556,7 @@ module Unicorn
         logger.info "reloading config_file=#{@config.config_file}"
         @config.reload
         @config.commit!(self)
-        kill_each_worker('QUIT')
+        kill_each_worker(:QUIT)
         logger.info "done reloading config_file=#{@config.config_file}"
       rescue Object => e
         logger.error "error reloading config_file=#{@config.config_file}: " \

data/lib/unicorn/app/old_rails.rb

@@ -0,0 +1,23 @@
+# This code is based on the original Rails handler in Mongrel
+# Copyright (c) 2005 Zed A. Shaw
+# Copyright (c) 2009 Eric Wong
+# You can redistribute it and/or modify it under the same terms as Ruby.
+# Additional work donated by contributors.  See CONTRIBUTORS for more info.
+require 'unicorn/cgi_wrapper'
+require 'dispatcher'
+
+module Unicorn; module App; end; end
+
+# Implements a handler that can run Rails.
+class Unicorn::App::OldRails
+
+  def call(env)
+    cgi = Unicorn::CGIWrapper.new(env)
+    Dispatcher.dispatch(cgi,
+        ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS,
+        cgi.body)
+    cgi.out  # finalize the response
+    cgi.rack_response
+  end
+
+end

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

@@ -0,0 +1,58 @@
+# This code is based on the original Rails handler in Mongrel
+# Copyright (c) 2005 Zed A. Shaw
+# Copyright (c) 2009 Eric Wong
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+require 'rack/file'
+
+# Static file handler for Rails < 2.3.  This handler is only provided
+# as a convenience for developers.  Performance-minded deployments should
+# use nginx (or similar) for serving static files.
+#
+# This supports page caching directly and will try to resolve a
+# request in the following order:
+#
+# * If the requested exact PATH_INFO exists as a file then serve it.
+# * If it exists at PATH_INFO+rest_operator+".html" exists
+#   then serve that.
+#
+# This means that if you are using page caching it will actually work
+# with Unicorn and you should see a decent speed boost (but not as
+# fast as if you use a static server like nginx).
+class Unicorn::App::OldRails::Static
+  FILE_METHODS = { 'GET' => true, 'HEAD' => true }.freeze
+  REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+
+  def initialize(app)
+    @app = app
+    @root = "#{::RAILS_ROOT}/public"
+    @file_server = ::Rack::File.new(@root)
+  end
+
+  def call(env)
+    # short circuit this ASAP if serving non-file methods
+    FILE_METHODS.include?(env[REQUEST_METHOD]) or return @app.call(env)
+
+    # first try the path as-is
+    path_info = env[Unicorn::Const::PATH_INFO].chomp("/")
+    if File.file?("#@root/#{::Rack::Utils.unescape(path_info)}")
+      # File exists as-is so serve it up
+      env[Unicorn::Const::PATH_INFO] = path_info
+      return @file_server.call(env)
+    end
+
+    # then try the cached version:
+
+    # grab the semi-colon REST operator used by old versions of Rails
+    # this is the reason we didn't just copy the new Rails::Rack::Static
+    env[Unicorn::Const::REQUEST_URI] =~ /^#{Regexp.escape(path_info)}(;[^\?]+)/
+    path_info << "#$1#{ActionController::Base.page_cache_extension}"
+
+    if File.file?("#@root/#{::Rack::Utils.unescape(path_info)}")
+      env[Unicorn::Const::PATH_INFO] = path_info
+      return @file_server.call(env)
+    end
+
+    @app.call(env) # call OldRails
+  end
+end if defined?(Unicorn::App::OldRails)

data/lib/unicorn/cgi_wrapper.rb

@@ -0,0 +1,151 @@
+# This code is based on the original CGIWrapper from Mongrel
+# Copyright (c) 2005 Zed A. Shaw
+# Copyright (c) 2009 Eric Wong
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See CONTRIBUTORS for more info.
+
+require 'cgi'
+
+module Unicorn; end
+
+# The beginning of a complete wrapper around Unicorn's internal HTTP
+# processing system but maintaining the original Ruby CGI module.  Use
+# this only as a crutch to get existing CGI based systems working.  It
+# should handle everything, but please notify us if you see special
+# warnings.  This work is still very alpha so we need testers to help
+# work out the various corner cases.
+class Unicorn::CGIWrapper < ::CGI
+  undef_method :env_table
+  attr_reader :env_table
+  attr_reader :body
+
+  # these are stripped out of any keys passed to CGIWrapper.header function
+  NPH = 'nph'.freeze # Completely ignored, Unicorn outputs the date regardless
+  CONNECTION = 'connection'.freeze # Completely ignored. Why is CGI doing this?
+  CHARSET = 'charset'.freeze # this gets appended to Content-Type
+  COOKIE = 'cookie'.freeze # maps (Hash,Array,String) to "Set-Cookie" headers
+  STATUS = 'status'.freeze # stored as @status
+  Status = 'Status'.freeze # code + human-readable text, Rails sets this
+
+  # some of these are common strings, but this is the only module
+  # using them and the reason they're not in Unicorn::Const
+  SET_COOKIE = 'Set-Cookie'.freeze
+  CONTENT_TYPE = 'Content-Type'.freeze
+  CONTENT_LENGTH = 'Content-Length'.freeze # this is NOT Const::CONTENT_LENGTH
+  RACK_INPUT = 'rack.input'.freeze
+  RACK_ERRORS = 'rack.errors'.freeze
+
+  # this maps CGI header names to HTTP header names
+  HEADER_MAP = {
+    'status' => Status,
+    'type' => CONTENT_TYPE,
+    'server' => 'Server'.freeze,
+    'language' => 'Content-Language'.freeze,
+    'expires' => 'Expires'.freeze,
+    'length' => CONTENT_LENGTH,
+  }.freeze
+
+  # Takes an a Rackable environment, plus any additional CGI.new
+  # arguments These are used internally to create a wrapper around the
+  # real CGI while maintaining Rack/Unicorn's view of the world.  This
+  # this will NOT deal well with large responses that take up a lot of
+  # memory, but neither does the CGI nor the original CGIWrapper from
+  # Mongrel...
+  def initialize(rack_env, *args)
+    @env_table = rack_env
+    @status = nil
+    @head = {}
+    @headv = Hash.new { |hash,key| hash[key] = [] }
+    @body = StringIO.new
+    super(*args)
+  end
+
+  # finalizes the response in a way Rack applications would expect
+  def rack_response
+    # @head[CONTENT_LENGTH] ||= @body.size
+    @headv[SET_COOKIE] += @output_cookies if @output_cookies
+    @headv.each_pair do |key,value|
+      @head[key] ||= value.join("\n") unless value.empty?
+    end
+
+    # Capitalized "Status:", with human-readable status code (e.g. "200 OK")
+    parseable_status = @head.delete(Status)
+    unless @status
+      @status ||= parseable_status.split(/ /)[0].to_i rescue 404
+    end
+
+    [ @status, @head, [ @body.string ] ]
+  end
+
+  # The header is typically called to send back the header.  In our case we
+  # collect it into a hash for later usage.  This can be called multiple
+  # times to set different cookies.
+  def header(options = "text/html")
+    # if they pass in a string then just write the Content-Type
+    if String === options
+      @head[CONTENT_TYPE] ||= options
+    else
+      HEADER_MAP.each_pair do |from, to|
+        from = options.delete(from) or next
+        @head[to] = from.to_s
+      end
+
+      @head[CONTENT_TYPE] ||= "text/html"
+      if charset = options.delete(CHARSET)
+        @head[CONTENT_TYPE] << "; charset=#{charset}"
+      end
+
+      # lots of ways to set cookies
+      if cookie = options.delete(COOKIE)
+        set_cookies = @headv[SET_COOKIE]
+        case cookie
+        when Array
+          cookie.each { |c| set_cookies << c.to_s }
+        when Hash
+          cookie.each_value { |c| set_cookies << c.to_s }
+        else
+          set_cookies << cookie.to_s
+        end
+      end
+      @status ||= options.delete(STATUS) # all lower-case
+
+      # drop the keys we don't want anymore
+      options.delete(NPH)
+      options.delete(CONNECTION)
+
+      # finally, set the rest of the headers as-is, allowing duplicates
+      options.each_pair { |k,v| @headv[k] << v }
+    end
+
+    # doing this fakes out the cgi library to think the headers are empty
+    # we then do the real headers in the out function call later
+    ""
+  end
+
+  # The dumb thing is people can call header or this or both and in
+  # any order.  So, we just reuse header and then finalize the
+  # HttpResponse the right way.  This will have no effect if called
+  # the second time if the first "outputted" anything.
+  def out(options = "text/html")
+    header(options)
+    @body.size == 0 or return
+    @body << yield if block_given?
+  end
+
+  # Used to wrap the normal stdinput variable used inside CGI.
+  def stdinput
+    @env_table[RACK_INPUT]
+  end
+
+  # The stdoutput should be completely bypassed but we'll drop a
+  # warning just in case
+  def stdoutput
+    err = @env_table[RACK_ERRORS]
+    err.puts "WARNING: Your program is doing something not expected."
+    err.puts "Please tell Eric that stdoutput was used and what software " \
+             "you are running.  Thanks."
+    @body
+  end
+
+end