unicorn 1.1.7 → 2.0.0pre1

data/lib/unicorn/launcher.rb

@@ -20,6 +20,7 @@ module Unicorn::Launcher
   #     to pickup code changes if the original deployment directory
   #     is a symlink or otherwise got replaced.
   def self.daemonize!(options)
+    cfg = Unicorn::Configurator
     $stdin.reopen("/dev/null")
 
     # We only start a new process group if we're not being reexecuted
@@ -52,9 +53,9 @@ module Unicorn::Launcher
       end
     end
     # $stderr/$stderr can/will be redirected separately in the Unicorn config
-    Unicorn::Configurator::DEFAULTS[:stderr_path] ||= "/dev/null"
-    Unicorn::Configurator::DEFAULTS[:stdout_path] ||= "/dev/null"
-    Unicorn::Configurator::RACKUP[:daemonized] = true
+    cfg::DEFAULTS[:stderr_path] ||= "/dev/null"
+    cfg::DEFAULTS[:stdout_path] ||= "/dev/null"
+    cfg::RACKUP[:daemonized] = true
   end
 
 end

data/lib/unicorn/oob_gc.rb

@@ -1,69 +1,58 @@
 # -*- encoding: binary -*-
+module Unicorn
 
-# Runs GC after requests, after closing the client socket and
-# before attempting to accept more connections.
-#
-# This shouldn't hurt overall performance as long as the server cluster
-# is at <50% CPU capacity, and improves the performance of most memory
-# intensive requests.  This serves to improve _client-visible_
-# performance (possibly at the cost of overall performance).
-#
-# Increasing the number of +worker_processes+ may be necessary to
-# improve average client response times because some of your workers
-# will be busy doing GC and unable to service clients.  Think of
-# using more workers with this module as a poor man's concurrent GC.
-#
-# We'll call GC after each request is been written out to the socket, so
-# the client never sees the extra GC hit it.
-#
-# This middleware is _only_ effective for applications that use a lot
-# of memory, and will hurt simpler apps/endpoints that can process
-# multiple requests before incurring GC.
-#
-# This middleware is only designed to work with unicorn, as it harms
-# performance with keepalive-enabled servers.
-#
-# Example (in config.ru):
-#
-#     require 'unicorn/oob_gc'
-#
-#     # GC ever two requests that hit /expensive/foo or /more_expensive/foo
-#     # in your app.  By default, this will GC once every 5 requests
-#     # for all endpoints in your app
-#     use Unicorn::OobGC, 2, %r{\A/(?:expensive/foo|more_expensive/foo)}
-#
-# Feedback from users of early implementations of this module:
-# * http://comments.gmane.org/gmane.comp.lang.ruby.unicorn.general/486
-# * http://article.gmane.org/gmane.comp.lang.ruby.unicorn.general/596
-module Unicorn::OobGC
-
-  # this pretends to be Rack middleware because it used to be
-  # But we need to hook into unicorn internals so we need to close
-  # the socket before clearing the request env.
+  # Run GC after every request, after closing the client socket and
+  # before attempting to accept more connections.
+  #
+  # This shouldn't hurt overall performance as long as the server cluster
+  # is at <50% CPU capacity, and improves the performance of most memory
+  # intensive requests.  This serves to improve _client-visible_
+  # performance (possibly at the cost of overall performance).
+  #
+  # We'll call GC after each request is been written out to the socket, so
+  # the client never sees the extra GC hit it.
+  #
+  # This middleware is _only_ effective for applications that use a lot
+  # of memory, and will hurt simpler apps/endpoints that can process
+  # multiple requests before incurring GC.
   #
-  # +interval+ is the number of requests matching the +path+ regular
-  # expression before invoking GC.
-  def self.new(app, interval = 5, path = %r{\A/})
-    @@nr = interval
-    self.const_set :OOBGC_PATH, path
-    self.const_set :OOBGC_INTERVAL, interval
-    self.const_set :OOBGC_ENV, Unicorn::HttpRequest::REQ
-    ObjectSpace.each_object(Unicorn::HttpServer) do |s|
-      s.extend(self)
+  # This middleware is only designed to work with Unicorn, as it harms
+  # keepalive performance.
+  #
+  # Example (in config.ru):
+  #
+  #     require 'unicorn/oob_gc'
+  #
+  #     # GC ever two requests that hit /expensive/foo or /more_expensive/foo
+  #     # in your app.  By default, this will GC once every 5 requests
+  #     # for all endpoints in your app
+  #     use Unicorn::OobGC, 2, %r{\A/(?:expensive/foo|more_expensive/foo)}
+  class OobGC < Struct.new(:app, :interval, :path, :nr, :env, :body)
+
+    def initialize(app, interval = 5, path = %r{\A/})
+      super(app, interval, path, interval)
     end
-    app # pretend to be Rack middleware since it was in the past
-  end
 
-  #:stopdoc:
-  PATH_INFO = "PATH_INFO"
-  def process_client(client)
-    super(client) # Unicorn::HttpServer#process_client
-    if OOBGC_PATH =~ OOBGC_ENV[PATH_INFO] && ((@@nr -= 1) <= 0)
-      @@nr = OOBGC_INTERVAL
-      OOBGC_ENV.clear
-      GC.start
+    def call(env)
+      status, headers, self.body = app.call(self.env = env)
+      [ status, headers, self ]
+    end
+
+    def each(&block)
+      body.each(&block)
     end
-  end
 
-  # :startdoc:
+    # in Unicorn, this is closed _after_ the client socket
+    def close
+      body.close if body.respond_to?(:close)
+
+      if path =~ env['PATH_INFO'] && ((self.nr -= 1) <= 0)
+        self.nr = interval
+        self.body = nil
+        env.clear
+        GC.start
+      end
+    end
+
+  end
 end

data/lib/unicorn/socket_helper.rb

@@ -126,12 +126,12 @@ module Unicorn
         end
         old_umask = File.umask(opt[:umask] || 0)
         begin
-          UNIXServer.new(address)
+          Kgio::UNIXServer.new(address)
         ensure
           File.umask(old_umask)
         end
       elsif address =~ /^(\d+\.\d+\.\d+\.\d+):(\d+)$/
-        TCPServer.new($1, $2.to_i)
+        Kgio::TCPServer.new($1, $2.to_i)
       else
         raise ArgumentError, "Don't know how to bind: #{address}"
       end
@@ -166,9 +166,9 @@ module Unicorn
     def server_cast(sock)
       begin
         Socket.unpack_sockaddr_in(sock.getsockname)
-        TCPServer.for_fd(sock.fileno)
+        Kgio::TCPServer.for_fd(sock.fileno)
       rescue ArgumentError
-        UNIXServer.for_fd(sock.fileno)
+        Kgio::UNIXServer.for_fd(sock.fileno)
       end
     end
 

data/lib/unicorn/tee_input.rb

@@ -25,11 +25,14 @@ class Unicorn::TeeInput < Struct.new(:socket, :req, :parser,
 
   # 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)
+  def initialize(socket, request)
+    self.socket = socket
+    self.req = request.env
+    self.parser = request.parser
+    self.buf = request.buf
     self.len = parser.content_length
     self.tmp = len && len < @@client_body_buffer_size ?
-               StringIO.new("") : Unicorn::Util.tmpio
+               StringIO.new("") : Unicorn::TmpIO.new
     self.buf2 = ""
     if buf.size > 0
       parser.filter_body(buf2, buf) and finalize_input
@@ -168,44 +171,25 @@ class Unicorn::TeeInput < Struct.new(:socket, :req, :parser,
 
 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 Unicorn::ClientShutdown, "bytes_read=#{tmp.size}", []
-    when Unicorn::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.  +dst+ must be specified.
   # returns nil if reading from the input returns nil
   def tee(length, dst)
     unless parser.body_eof?
-      if parser.filter_body(dst, socket.readpartial(length, buf)).nil?
+      r = socket.kgio_read(length, buf) or eof!
+      unless parser.filter_body(dst, r)
         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(@@io_chunk_size)
+      r = socket.kgio_read(@@io_chunk_size) or eof!
+      buf << r
     end
     self.socket = nil
   end
@@ -229,4 +213,12 @@ private
     dst
   end
 
+  def eof!
+    # 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 Unicorn::ClientShutdown, "bytes_read=#{tmp.size}", []
+  end
 end

data/lib/unicorn/tmpio.rb

@@ -0,0 +1,29 @@
+# -*- encoding: binary -*-
+# :stopdoc:
+require 'tmpdir'
+
+# some versions of Ruby had a broken Tempfile which didn't work
+# well with unlinked files.  This one is much shorter, easier
+# to understand, and slightly faster.
+class Unicorn::TmpIO < File
+
+  # creates and returns a new File object.  The File is unlinked
+  # immediately, switched to binary mode, and userspace output
+  # buffering is disabled
+  def self.new
+    fp = begin
+      super("#{Dir::tmpdir}/#{rand}", RDWR|CREAT|EXCL, 0600)
+    rescue Errno::EEXIST
+      retry
+    end
+    unlink(fp.path)
+    fp.binmode
+    fp.sync = true
+    fp
+  end
+
+  # for easier env["rack.input"] compatibility with Rack <= 1.1
+  def size
+    stat.size
+  end
+end

data/lib/unicorn/util.rb

@@ -1,101 +1,67 @@
 # -*- encoding: binary -*-
 
-require 'fcntl'
-require 'tmpdir'
-
-module Unicorn
-
-  class TmpIO < ::File
+module Unicorn::Util
+
+# :stopdoc:
+  def self.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
+    rescue IOError, Errno::EBADF
+      false
+  end
 
-    # for easier env["rack.input"] compatibility
-    def size
-      # flush if sync
-      stat.size
+  def self.chown_logs(uid, gid)
+    ObjectSpace.each_object(File) do |fp|
+      fp.chown(uid, gid) if is_log?(fp)
     end
   end
-
-  module 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
-        rescue IOError, Errno::EBADF
-          false
+# :startdoc:
+
+  # 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:
+  #   1) opened with the O_APPEND and O_WRONLY flags
+  #   2) opened with an absolute path (starts with "/")
+  #   3) the current open file handle does not match its original open path
+  #   4) unbuffered (as far as userspace buffering goes, not O_SYNC)
+  # Returns the number of files reopened
+  def self.reopen_logs
+    to_reopen = []
+    nr = 0
+    ObjectSpace.each_object(File) { |fp| is_log?(fp) and to_reopen << fp }
+
+    to_reopen.each do |fp|
+      orig_st = begin
+        fp.stat
+      rescue IOError, Errno::EBADF
+        next
       end
 
-      def chown_logs(uid, gid)
-        ObjectSpace.each_object(File) do |fp|
-          fp.chown(uid, gid) if is_log?(fp)
-        end
+      begin
+        b = File.stat(fp.path)
+        next if orig_st.ino == b.ino && orig_st.dev == b.dev
+      rescue Errno::ENOENT
       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:
-      #   1) opened with the O_APPEND and O_WRONLY flags
-      #   2) opened with an absolute path (starts with "/")
-      #   3) the current open file handle does not match its original open path
-      #   4) unbuffered (as far as userspace buffering goes, not O_SYNC)
-      # Returns the number of files reopened
-      def reopen_logs
-        to_reopen = []
-        nr = 0
-        ObjectSpace.each_object(File) { |fp| is_log?(fp) and to_reopen << fp }
-
-        to_reopen.each do |fp|
-          orig_st = begin
-            fp.stat
-          rescue IOError, Errno::EBADF
-            next
-          end
-
-          begin
-            b = File.stat(fp.path)
-            next if orig_st.ino == b.ino && orig_st.dev == b.dev
-          rescue Errno::ENOENT
-          end
-
-          begin
-            File.open(fp.path, 'a') { |tmpfp| fp.reopen(tmpfp) }
-            fp.sync = true
-            new_st = fp.stat
-
-            # this should only happen in the master:
-            if orig_st.uid != new_st.uid || orig_st.gid != new_st.gid
-              fp.chown(orig_st.uid, orig_st.gid)
-            end
+      begin
+        File.open(fp.path, 'a') { |tmpfp| fp.reopen(tmpfp) }
+        fp.sync = true
+        new_st = fp.stat
 
-            nr += 1
-          rescue IOError, Errno::EBADF
-            # not much we can do...
-          end
+        # this should only happen in the master:
+        if orig_st.uid != new_st.uid || orig_st.gid != new_st.gid
+          fp.chown(orig_st.uid, orig_st.gid)
         end
 
-        nr
+        nr += 1
+      rescue IOError, Errno::EBADF
+        # not much we can do...
       end
-
-      # creates and returns a new File object.  The File is unlinked
-      # immediately, switched to binary mode, and userspace output
-      # buffering is disabled
-      def tmpio
-        fp = begin
-          TmpIO.open("#{Dir::tmpdir}/#{rand}",
-                     File::RDWR|File::CREAT|File::EXCL, 0600)
-        rescue Errno::EEXIST
-          retry
-        end
-        File.unlink(fp.path)
-        fp.binmode
-        fp.sync = true
-        fp
-      end
-
     end
-
+    nr
   end
 end

data/lib/unicorn/worker.rb

@@ -0,0 +1,40 @@
+# -*- encoding: binary -*-
+
+# This class and its members can be considered a stable interface
+# and will not change in a backwards-incompatible fashion between
+# releases of Unicorn.  You may need to access it in the
+# before_fork/after_fork hooks.  See the Unicorn::Configurator RDoc
+# for examples.
+class Unicorn::Worker < Struct.new(:nr, :tmp, :switched)
+
+  # 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
+    Unicorn::Util.chown_logs(uid, gid)
+    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)
+    self.switched = true
+  end
+end