giraffesoft-unicorn 0.93.5

data/lib/unicorn/http_response.rb

@@ -0,0 +1,74 @@
+# -*- encoding: binary -*-
+
+require 'time'
+
+module Unicorn
+  # Writes a Rack response to your client using the HTTP/1.1 specification.
+  # You use it by simply doing:
+  #
+  #   status, headers, body = rack_app.call(env)
+  #   HttpResponse.write(socket, [ status, headers, body ])
+  #
+  # Most header correctness (including Content-Length and Content-Type)
+  # is the job of Rack, with the exception of the "Connection: close"
+  # and "Date" headers.
+  #
+  # A design decision was made to force the client to not pipeline or
+  # keepalive requests.  HTTP/1.1 pipelining really kills the
+  # performance due to how it has to be handled and how unclear the
+  # standard is.  To fix this the HttpResponse always gives a
+  # "Connection: close" header which forces the client to close right
+  # away.  The bonus for this is that it gives a pretty nice speed boost
+  # to most clients since they can close their connection immediately.
+
+  class HttpResponse
+
+    # Every standard HTTP code mapped to the appropriate message.
+    CODES = Rack::Utils::HTTP_STATUS_CODES.inject({}) { |hash,(code,msg)|
+      hash[code] = "#{code} #{msg}"
+      hash
+    }
+
+    # Rack does not set/require a Date: header.  We always override the
+    # Connection: and Date: headers no matter what (if anything) our
+    # Rack application sent us.
+    SKIP = { 'connection' => true, 'date' => true, 'status' => true }
+
+    # writes the rack_response to socket as an HTTP response
+    def self.write(socket, rack_response, have_header = true)
+      status, headers, body = rack_response
+
+      if have_header
+        status = CODES[status.to_i] || status
+        out = []
+
+        # Don't bother enforcing duplicate supression, it's a Hash most of
+        # the time anyways so just hope our app knows what it's doing
+        headers.each do |key, value|
+          next if SKIP.include?(key.downcase)
+          if value =~ /\n/
+            out.concat(value.split(/\n/).map! { |v| "#{key}: #{v}\r\n" })
+          else
+            out << "#{key}: #{value}\r\n"
+          end
+        end
+
+        # Rack should enforce Content-Length or chunked transfer encoding,
+        # so don't worry or care about them.
+        # Date is required by HTTP/1.1 as long as our clock can be trusted.
+        # Some broken clients require a "Status" header so we accomodate them
+        socket.write("HTTP/1.1 #{status}\r\n" \
+                     "Date: #{Time.now.httpdate}\r\n" \
+                     "Status: #{status}\r\n" \
+                     "Connection: close\r\n" \
+                     "#{out.join('')}\r\n")
+      end
+
+      body.each { |chunk| socket.write(chunk) }
+      socket.close # flushes and uncorks the socket immediately
+      ensure
+        body.respond_to?(:close) and body.close
+    end
+
+  end
+end

data/lib/unicorn/launcher.rb

@@ -0,0 +1,39 @@
+# -*- encoding: binary -*-
+
+$stdin.sync = $stdout.sync = $stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
+
+require 'unicorn'
+
+class Unicorn::Launcher
+
+  # We don't do a lot of standard daemonization stuff:
+  #   * umask is whatever was set by the parent process at startup
+  #     and can be set in config.ru and config_file, so making it
+  #     0000 and potentially exposing sensitive log data can be bad
+  #     policy.
+  #   * don't bother to chdir("/") here since unicorn is designed to
+  #     run inside APP_ROOT.  Unicorn will also re-chdir() to
+  #     the directory it was started in when being re-executed
+  #     to pickup code changes if the original deployment directory
+  #     is a symlink or otherwise got replaced.
+  def self.daemonize!
+    $stdin.reopen("/dev/null")
+
+    # We only start a new process group if we're not being reexecuted
+    # and inheriting file descriptors from our parent
+    unless ENV['UNICORN_FD']
+      exit if fork
+      Process.setsid
+      exit if fork
+
+      # $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"
+    end
+    $stdin.sync = $stdout.sync = $stderr.sync = true
+  end
+
+end

data/lib/unicorn/socket_helper.rb

@@ -0,0 +1,138 @@
+# -*- encoding: binary -*-
+
+require 'socket'
+
+module Unicorn
+  module SocketHelper
+    include Socket::Constants
+
+    # configure platform-specific options (only tested on Linux 2.6 so far)
+    case RUBY_PLATFORM
+    when /linux/
+      # from /usr/include/linux/tcp.h
+      TCP_DEFER_ACCEPT = 9 unless defined?(TCP_DEFER_ACCEPT)
+      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)
+    when /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?
+        FILTER_ARG = ['httpready', nil].pack('a16a240')
+      end
+    end
+
+    def set_tcp_sockopt(sock, opt)
+
+      # 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
+      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
+        elsif defined?(TCP_NOPUSH) # TCP_NOPUSH is untested (FreeBSD)
+          sock.setsockopt(IPPROTO_TCP, TCP_NOPUSH, val) rescue nil
+        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
+      elsif defined?(SO_ACCEPTFILTER) && defined?(FILTER_ARG)
+        sock.setsockopt(SOL_SOCKET, SO_ACCEPTFILTER, FILTER_ARG) rescue nil
+      end
+    end
+
+    def set_server_sockopt(sock, opt)
+      opt ||= {}
+
+      TCPSocket === sock and set_tcp_sockopt(sock, opt)
+
+      if opt[:rcvbuf] || opt[:sndbuf]
+        log_buffer_sizes(sock, "before: ")
+        sock.setsockopt(SOL_SOCKET, SO_RCVBUF, opt[:rcvbuf]) if opt[:rcvbuf]
+        sock.setsockopt(SOL_SOCKET, SO_SNDBUF, opt[:sndbuf]) if opt[:sndbuf]
+        log_buffer_sizes(sock, " after: ")
+      end
+      sock.listen(opt[:backlog] || 1024)
+    end
+
+    def log_buffer_sizes(sock, pfx = '')
+      respond_to?(:logger) or return
+      rcvbuf = sock.getsockopt(SOL_SOCKET, SO_RCVBUF).unpack('i')
+      sndbuf = sock.getsockopt(SOL_SOCKET, SO_SNDBUF).unpack('i')
+      logger.info "#{pfx}#{sock_name(sock)} rcvbuf=#{rcvbuf} sndbuf=#{sndbuf}"
+    end
+
+    # creates a new server, socket. address may be a HOST:PORT or
+    # an absolute path to a UNIX socket.  address can even be a Socket
+    # object in which case it is immediately returned
+    def bind_listen(address = '0.0.0.0:8080', opt = {})
+      return address unless String === address
+
+      sock = if address[0] == ?/
+        if File.exist?(address)
+          if File.socket?(address)
+            if self.respond_to?(:logger)
+              logger.info "unlinking existing socket=#{address}"
+            end
+            File.unlink(address)
+          else
+            raise ArgumentError,
+                  "socket=#{address} specified but it is not a socket!"
+          end
+        end
+        old_umask = File.umask(0)
+        begin
+          UNIXServer.new(address)
+        ensure
+          File.umask(old_umask)
+        end
+      elsif address =~ /^(\d+\.\d+\.\d+\.\d+):(\d+)$/
+        TCPServer.new($1, $2.to_i)
+      else
+        raise ArgumentError, "Don't know how to bind: #{address}"
+      end
+      set_server_sockopt(sock, opt)
+      sock
+    end
+
+    # Returns the configuration name of a socket as a string.  sock may
+    # be a string value, in which case it is returned as-is
+    # Warning: TCP sockets may not always return the name given to it.
+    def sock_name(sock)
+      case sock
+      when String then sock
+      when UNIXServer
+        Socket.unpack_sockaddr_un(sock.getsockname)
+      when TCPServer
+        Socket.unpack_sockaddr_in(sock.getsockname).reverse!.join(':')
+      when Socket
+        begin
+          Socket.unpack_sockaddr_in(sock.getsockname).reverse!.join(':')
+        rescue ArgumentError
+          Socket.unpack_sockaddr_un(sock.getsockname)
+        end
+      else
+        raise ArgumentError, "Unhandled class #{sock.class}: #{sock.inspect}"
+      end
+    end
+
+    # casts a given Socket to be a TCPServer or UNIXServer
+    def server_cast(sock)
+      begin
+        Socket.unpack_sockaddr_in(sock.getsockname)
+        TCPServer.for_fd(sock.fileno)
+      rescue ArgumentError
+        UNIXServer.for_fd(sock.fileno)
+      end
+    end
+
+  end # module SocketHelper
+end # module Unicorn

data/lib/unicorn/tee_input.rb

@@ -0,0 +1,174 @@
+# -*- encoding: binary -*-
+
+module Unicorn
+
+  # acts like tee(1) on an input input to provide a input-like stream
+  # while providing rewindable semantics through a File/StringIO
+  # backing store.  On the first pass, the input is only read on demand
+  # so your Rack application can use input notification (upload progress
+  # and like).  This should fully conform to the Rack::InputWrapper
+  # specification on the public API.  This class is intended to be a
+  # strict interpretation of Rack::InputWrapper functionality and will
+  # not support any deviations from it.
+  class TeeInput < Struct.new(:socket, :req, :parser, :buf)
+
+    def initialize(*args)
+      super(*args)
+      @size = parser.content_length
+      @tmp = @size && @size < Const::MAX_BODY ? StringIO.new("") : Util.tmpio
+      @buf2 = buf.dup
+      if buf.size > 0
+        parser.filter_body(@buf2, buf) and finalize_input
+        @tmp.write(@buf2)
+        @tmp.seek(0)
+      end
+    end
+
+    # returns the size of the input.  This is what the Content-Length
+    # header value should be, and how large our input is expected to be.
+    # For TE:chunked, this requires consuming all of the input stream
+    # before returning since there's no other way
+    def size
+      @size and return @size
+
+      if socket
+        pos = @tmp.pos
+        while tee(Const::CHUNK_SIZE, @buf2)
+        end
+        @tmp.seek(pos)
+      end
+
+      @size = tmp_size
+    end
+
+    # call-seq:
+    #   ios = env['rack.input']
+    #   ios.read([length [, buffer ]]) => string, buffer, or nil
+    #
+    # Reads at most length bytes from the I/O stream, or to the end of
+    # file if length is omitted or is nil. length must be a non-negative
+    # integer or nil. If the optional buffer argument is present, it
+    # must reference a String, which will receive the data.
+    #
+    # At end of file, it returns nil or "" depend on length.
+    # ios.read() and ios.read(nil) returns "".
+    # ios.read(length [, buffer]) returns nil.
+    #
+    # If the Content-Length of the HTTP request is known (as is the common
+    # case for POST requests), then ios.read(length [, buffer]) will block
+    # until the specified length is read (or it is the last chunk).
+    # Otherwise, for uncommon "Transfer-Encoding: chunked" requests,
+    # ios.read(length [, buffer]) will return immediately if there is
+    # any data and only block when nothing is available (providing
+    # IO#readpartial semantics).
+    def 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
+        end
+        rv
+      else
+        rv = args.shift || @buf2.dup
+        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)
+        end
+      end
+    end
+
+    # takes zero arguments for strict Rack::Lint compatibility, unlike IO#gets
+    def 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)
+      end
+
+      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
+      begin
+        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
+      end while true
+
+      line
+    end
+
+    def each(&block)
+      while line = gets
+        yield line
+      end
+
+      self # Rack does not specify what the return value is here
+    end
+
+    def rewind
+      @tmp.rewind # Rack does not specify what the return value is here
+    end
+
+  private
+
+    # tees off a +length+ chunk of data from the input into the IO
+    # backing store as well as returning it.  +buf+ 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
+        end
+      end
+      finalize_input
+    end
+
+    def finalize_input
+      while parser.trailers(req, buf).nil?
+        buf << socket.readpartial(Const::CHUNK_SIZE, @buf2)
+      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)
+    # 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)
+      # @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?
+
+      while buf.size < length && @size != @tmp.pos
+        buf << tee(length - buf.size, @buf2)
+      end
+
+      buf
+    end
+
+  end
+end

data/lib/unicorn/util.rb

@@ -0,0 +1,64 @@
+# -*- encoding: binary -*-
+
+require 'fcntl'
+require 'tmpdir'
+
+module Unicorn
+  class Util
+    class << self
+
+      # 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
+        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..0] == "/")
+          next unless (fp.fcntl(Fcntl::F_GETFL) & append_flags) == append_flags
+
+          begin
+            a, b = fp.stat, File.stat(fp.path)
+            next if a.ino == b.ino && a.dev == b.dev
+          rescue Errno::ENOENT
+          end
+
+          open_arg = 'a'
+          if fp.respond_to?(:external_encoding) && enc = fp.external_encoding
+            open_arg << ":#{enc.to_s}"
+            enc = fp.internal_encoding and open_arg << ":#{enc.to_s}"
+          end
+          fp.reopen(fp.path, open_arg)
+          fp.sync = true
+          nr += 1
+        end # each_object
+        nr
+      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
+          File.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
+
+  end
+end