preplay_unicorn 4.3.1.2.gc450

data/lib/unicorn/tee_input.rb

@@ -0,0 +1,126 @@
+# -*- encoding: binary -*-
+
+# 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::Lint::InputWrapper
+# specification on the public API.  This class is intended to be a
+# strict interpretation of Rack::Lint::InputWrapper functionality and
+# will not support any deviations from it.
+#
+# When processing uploads, Unicorn exposes a TeeInput object under
+# "rack.input" of the Rack environment.
+class Unicorn::TeeInput < Unicorn::StreamInput
+  # The maximum size (in +bytes+) to buffer in memory before
+  # resorting to a temporary file.  Default is 112 kilobytes.
+  @@client_body_buffer_size = Unicorn::Const::MAX_BODY
+
+  # sets the maximum size of request bodies to buffer in memory,
+  # amounts larger than this are buffered to the filesystem
+  def self.client_body_buffer_size=(bytes)
+    @@client_body_buffer_size = bytes
+  end
+
+  # returns the maximum size of request bodies to buffer in memory,
+  # amounts larger than this are buffered to the filesystem
+  def self.client_body_buffer_size
+    @@client_body_buffer_size
+  end
+
+  # Initializes a new TeeInput object.  You normally do not have to call
+  # this unless you are writing an HTTP server.
+  def initialize(socket, request)
+    @len = request.content_length
+    super
+    @tmp = @len && @len <= @@client_body_buffer_size ?
+           StringIO.new("") : Unicorn::TmpIO.new
+  end
+
+  # :call-seq:
+  #   ios.size  => Integer
+  #
+  # Returns the size of the input.  For requests with a Content-Length
+  # header value, this will not read data off the socket and just return
+  # the value of the Content-Length header as an Integer.
+  #
+  # For Transfer-Encoding:chunked requests, this requires consuming
+  # all of the input stream before returning since there's no other
+  # way to determine the size of the request body beforehand.
+  #
+  # This method is no longer part of the Rack specification as of
+  # Rack 1.2, so its use is not recommended.  This method only exists
+  # for compatibility with Rack applications designed for Rack 1.1 and
+  # earlier.  Most applications should only need to call +read+ with a
+  # specified +length+ in a loop until it returns +nil+.
+  def size
+    @len and return @len
+    pos = @tmp.pos
+    consume!
+    @tmp.pos = pos
+    @len = @tmp.size
+  end
+
+  # :call-seq:
+  #   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 ? tee(super) : @tmp.read(*args)
+  end
+
+  # :call-seq:
+  #   ios.gets   => string or nil
+  #
+  # Reads the next ``line'' from the I/O stream; lines are separated
+  # by the global record separator ($/, typically "\n"). A global
+  # record separator of nil reads the entire unread contents of ios.
+  # Returns nil if called at the end of file.
+  # This takes zero arguments for strict Rack::Lint compatibility,
+  # unlike IO#gets.
+  def gets
+    @socket ? tee(super) : @tmp.gets
+  end
+
+  # :call-seq:
+  #   ios.rewind    => 0
+  #
+  # Positions the *ios* pointer to the beginning of input, returns
+  # the offset (zero) of the +ios+ pointer.  Subsequent reads will
+  # start from the beginning of the previously-buffered input.
+  def rewind
+    return 0 if 0 == @tmp.size
+    consume! if @socket
+    @tmp.rewind # Rack does not specify what the return value is here
+  end
+
+private
+
+  # consumes the stream of the socket
+  def consume!
+    junk = ""
+    nil while read(@@io_chunk_size, junk)
+  end
+
+  def tee(buffer)
+    if buffer && buffer.size > 0
+      @tmp.write(buffer)
+    end
+    buffer
+  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 unless File.method_defined?(:size)
+end

data/lib/unicorn/util.rb

@@ -0,0 +1,68 @@
+# -*- encoding: binary -*-
+
+module Unicorn::Util
+
+# :stopdoc:
+  def self.is_log?(fp)
+    append_flags = File::WRONLY | File::APPEND
+
+    ! fp.closed? &&
+      fp.sync &&
+      (fp.fcntl(Fcntl::F_GETFL) & append_flags) == append_flags
+    rescue IOError, Errno::EBADF
+      false
+  end
+
+  def self.chown_logs(uid, gid)
+    ObjectSpace.each_object(File) do |fp|
+      fp.chown(uid, gid) if is_log?(fp)
+    end
+  end
+# :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) the current open file handle does not match its original open path
+  #   3) unbuffered (as far as userspace buffering goes, not O_SYNC)
+  # Returns the number of files reopened
+  #
+  # In Unicorn 3.5.x and earlier, files must be opened with an absolute
+  # path to be considered a log file.
+  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
+
+      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
+
+        nr += 1
+      rescue IOError, Errno::EBADF
+        # not much we can do...
+      end
+    end
+    nr
+  end
+end

data/lib/unicorn/worker.rb

@@ -0,0 +1,88 @@
+# -*- encoding: binary -*-
+require "raindrops"
+
+# This class and its members can be considered a stable interface
+# and will not change in a backwards-incompatible fashion between
+# releases of \Unicorn.  Knowledge of this class is generally not
+# not needed for most users of \Unicorn.
+#
+# Some users may want to access it in the before_fork/after_fork hooks.
+# See the Unicorn::Configurator RDoc for examples.
+class Unicorn::Worker
+  # :stopdoc:
+  attr_accessor :nr, :switched
+  attr_writer :tmp
+
+  PER_DROP = Raindrops::PAGE_SIZE / Raindrops::SIZE
+  DROPS = []
+
+  def initialize(nr)
+    drop_index = nr / PER_DROP
+    @raindrop = DROPS[drop_index] ||= Raindrops.new(PER_DROP)
+    @offset = nr % PER_DROP
+    @raindrop[@offset] = 0
+    @nr = nr
+    @tmp = @switched = false
+  end
+
+  # worker objects may be compared to just plain Integers
+  def ==(other_nr) # :nodoc:
+    @nr == other_nr
+  end
+
+  # called in the worker process
+  def tick=(value) # :nodoc:
+    @raindrop[@offset] = value
+  end
+
+  # called in the master process
+  def tick # :nodoc:
+    @raindrop[@offset]
+  end
+
+  # only exists for compatibility
+  def tmp # :nodoc:
+    @tmp ||= begin
+      tmp = Unicorn::TmpIO.new
+      tmp.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      tmp
+    end
+  end
+
+  def close # :nodoc:
+    @tmp.close if @tmp
+  end
+
+  # :startdoc:
+
+  # In most cases, you should be using the Unicorn::Configurator#user
+  # directive instead.  This method should only be used if you need
+  # fine-grained control of exactly when you want to change permissions
+  # in your after_fork hooks.
+  #
+  # 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 privileged 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 privileges
+  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 @tmp
+    if gid && Process.egid != gid
+      Process.initgroups(user, gid)
+      Process::GID.change_privilege(gid)
+    end
+    Process.euid != uid and Process::UID.change_privilege(uid)
+    @switched = true
+  end
+end

data/lib/unicorn.rb

@@ -0,0 +1,107 @@
+# -*- encoding: binary -*-
+require 'fcntl'
+require 'etc'
+require 'stringio'
+require 'rack'
+require 'kgio'
+
+# :stopdoc:
+# Unicorn module containing all of the classes (include C extensions) for
+# running a Unicorn web server.  It contains a minimalist HTTP server with just
+# enough functionality to service web application requests fast as possible.
+# :startdoc:
+
+# \Unicorn exposes very little of an user-visible API and most of its
+# internals are subject to change.  \Unicorn is designed to host Rack
+# applications, so applications should be written against the Rack SPEC
+# and not \Unicorn internals.
+module Unicorn
+
+  # Raised inside TeeInput when a client closes the socket inside the
+  # application dispatch.  This is always raised with an empty backtrace
+  # since there is nothing in the application stack that is responsible
+  # for client shutdowns/disconnects.  This exception is visible to Rack
+  # applications unless PrereadInput middleware is loaded.
+  class ClientShutdown < EOFError
+  end
+
+  # :stopdoc:
+
+  # 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 self.builder(ru, op)
+    # allow Configurator to parse cli switches embedded in the ru file
+    op = Unicorn::Configurator::RACKUP.merge!(:file => ru, :optparse => op)
+
+    # always called after config file parsing, may be called after forking
+    lambda do ||
+      inner_app = case ru
+      when /\.ru$/
+        raw = File.read(ru)
+        raw.sub!(/^__END__\n.*/, '')
+        eval("Rack::Builder.new {(\n#{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
+      # Unicorn does not support persistent connections, but Rainbows!
+      # and Zbatery both do.  Users accustomed to the Rack::Server default
+      # middlewares will need ContentLength/Chunked middlewares.
+      case ENV["RACK_ENV"]
+      when "development"
+        Rack::Builder.new do
+          use Rack::ContentLength
+          use Rack::Chunked
+          use Rack::CommonLogger, $stderr
+          use Rack::ShowExceptions
+          use Rack::Lint
+          run inner_app
+        end.to_app
+      when "deployment"
+        Rack::Builder.new do
+          use Rack::ContentLength
+          use Rack::Chunked
+          use Rack::CommonLogger, $stderr
+          run inner_app
+        end.to_app
+      else
+        inner_app
+      end
+    end
+  end
+
+  # returns an array of strings representing TCP listen socket addresses
+  # and Unix domain socket paths.  This is useful for use with
+  # Raindrops::Middleware under Linux: http://raindrops.bogomips.org/
+  def self.listener_names
+    Unicorn::HttpServer::LISTENERS.map do |io|
+      Unicorn::SocketHelper.sock_name(io)
+    end
+  end
+
+  def self.log_error(logger, prefix, exc)
+    message = exc.message
+    message = message.dump if /[[:cntrl:]]/ =~ message
+    logger.error "#{prefix}: #{message} (#{exc.class})"
+    exc.backtrace.each { |line| logger.error(line) }
+  end
+  # :startdoc:
+end
+# :enddoc:
+require 'unicorn/const'
+require 'unicorn/socket_helper'
+require 'unicorn/stream_input'
+require 'unicorn/tee_input'
+require 'unicorn/http_request'
+require 'unicorn/configurator'
+require 'unicorn/tmpio'
+require 'unicorn/util'
+require 'unicorn/http_response'
+require 'unicorn/worker'
+require 'unicorn/http_server'

data/local.mk.sample

@@ -0,0 +1,59 @@
+# this is the local.mk file used by Eric Wong on his dev boxes.
+# GNUmakefile will source local.mk in the top-level source tree
+# if it is present.
+#
+# This is depends on a bunch of GNU-isms from bash, sed, touch.
+
+DLEXT := so
+
+# Avoid loading rubygems to speed up tests because gmake is
+# fork+exec heavy with Ruby.
+prefix = $(HOME)
+
+# XXX clean this up
+ifeq ($(r192),)
+  ifeq ($(r19),)
+    ifeq ($(rbx),)
+      ifeq ($(r186),)
+        RUBY := $(prefix)/bin/ruby
+      else
+        prefix := $(prefix)/r186-p114
+        export PATH := $(prefix)/bin:$(PATH)
+        RUBY := $(prefix)/bin/ruby
+      endif
+    else
+      prefix := $(prefix)/rbx
+      export PATH := $(prefix)/bin:$(PATH)
+      RUBY := $(prefix)/bin/rbx
+    endif
+  else
+    prefix := $(prefix)/ruby-1.9
+    export PATH := $(prefix)/bin:$(PATH)
+    RUBY := $(prefix)/bin/ruby --disable-gems
+  endif
+else
+  prefix := $(prefix)/ruby-1.9.2
+  export PATH := $(prefix)/bin:$(PATH)
+  RUBY := $(prefix)/bin/ruby --disable-gems
+endif
+
+# pipefail is THE reason to use bash (v3+) or never revisions of ksh93
+# SHELL := /bin/bash -e -o pipefail
+SHELL := /bin/ksh93 -e -o pipefail
+
+full-test: test-18 test-191 test-192 test-rbx test-186
+
+# FIXME: keep eye on Rubinius activity and wait for fixes from upstream
+# so we don't need RBX_SKIP anymore
+test-rbx: export RBX_SKIP := 1
+test-rbx: export RUBY := $(RUBY)
+test-rbx:
+	$(MAKE) test test-integration rbx=T 2>&1 |sed -e 's!^!rbx !'
+test-186:
+	$(MAKE) test-all r186=1 2>&1 |sed 's!^!1.8.6 !'
+test-18:
+	$(MAKE) test-all 2>&1 |sed 's!^!1.8 !'
+test-191:
+	$(MAKE) test-all r19=1 2>&1 |sed 's!^!1.9.1 !'
+test-192:
+	$(MAKE) test-all r192=1 2>&1 |sed 's!^!1.9.2 !'

data/man/man1/unicorn.1

@@ -0,0 +1,201 @@
+.TH UNICORN 1 "September 15, 2009" "Unicorn User Manual"
+.SH NAME
+.PP
+unicorn - a rackup-like command to launch the Unicorn HTTP server
+.SH SYNOPSIS
+.PP
+unicorn [-c CONFIG_FILE] [-E RACK_ENV] [-D] [RACKUP_FILE]
+.SH DESCRIPTION
+.PP
+A rackup(1)-like command to launch Rack applications using Unicorn.
+It is expected to be started in your application root (APP_ROOT), but
+the "working_directory" directive may be used in the CONFIG_FILE.
+.PP
+While unicorn takes a myriad of command-line options for compatibility
+with ruby(1) and rackup(1), it is recommended to stick to the few
+command-line options specified in the SYNOPSIS and use the CONFIG_FILE
+as much as possible.
+.SH RACKUP FILE
+.PP
+This defaults to "config.ru" in APP_ROOT.
+It should be the same file used by rackup(1) and other Rack launchers,
+it uses the \f[I]Rack::Builder\f[] DSL.
+.PP
+Embedded command-line options are mostly parsed for compatibility with
+rackup(1) but strongly discouraged.
+.SH UNICORN OPTIONS
+.TP
+.B -c, --config-file CONFIG_FILE
+Path to the Unicorn-specific config file.
+The config file is implemented as a Ruby DSL, so Ruby code may executed.
+See the RDoc/ri for the \f[I]Unicorn::Configurator\f[] class for the
+full list of directives available from the DSL.
+Using an absolute path for for CONFIG_FILE is recommended as it makes
+multiple instances of Unicorn easily distinguishable when viewing ps(1)
+output.
+.RS
+.RE
+.TP
+.B -D, --daemonize
+Run daemonized in the background.
+The process is detached from the controlling terminal and stdin is
+redirected to "/dev/null".
+Unlike many common UNIX daemons, we do not chdir to "/" upon
+daemonization to allow more control over the startup/upgrade process.
+Unless specified in the CONFIG_FILE, stderr and stdout will also be
+redirected to "/dev/null".
+.RS
+.RE
+.TP
+.B -E, --env RACK_ENV
+Run under the given RACK_ENV.
+See the RACK ENVIRONMENT section for more details.
+.RS
+.RE
+.TP
+.B -l, --listen ADDRESS
+Listens on a given ADDRESS.
+ADDRESS may be in the form of HOST:PORT or PATH, HOST:PORT is taken to
+mean a TCP socket and PATH is meant to be a path to a UNIX domain
+socket.
+Defaults to "0.0.0.0:8080" (all addresses on TCP port 8080) For
+production deployments, specifying the "listen" directive in CONFIG_FILE
+is recommended as it allows fine-tuning of socket options.
+.RS
+.RE
+.SH RACKUP COMPATIBILITY OPTIONS
+.TP
+.B -o, --host HOST
+Listen on a TCP socket belonging to HOST, default is "0.0.0.0" (all
+addresses).
+If specified multiple times on the command-line, only the last-specified
+value takes effect.
+This option only exists for compatibility with the rackup(1) command,
+use of "-l"/"--listen" switch is recommended instead.
+.RS
+.RE
+.TP
+.B -p, --port PORT
+Listen on the specified TCP PORT, default is 8080.
+If specified multiple times on the command-line, only the last-specified
+value takes effect.
+This option only exists for compatibility with the rackup(1) command,
+use of "-l"/"--listen" switch is recommended instead.
+.RS
+.RE
+.TP
+.B -s, --server SERVER
+No-op, this exists only for compatibility with rackup(1).
+.RS
+.RE
+.SH RUBY OPTIONS
+.TP
+.B -e, --eval LINE
+Evaluate a LINE of Ruby code.
+This evaluation happens immediately as the command-line is being parsed.
+.RS
+.RE
+.TP
+.B -d, --debug
+Turn on debug mode, the $DEBUG variable is set to true.
+.RS
+.RE
+.TP
+.B -w, --warn
+Turn on verbose warnings, the $VERBOSE variable is set to true.
+.RS
+.RE
+.TP
+.B -I, --include PATH
+specify $LOAD_PATH.
+PATH will be prepended to $LOAD_PATH.
+The \[aq]:\[aq] character may be used to delimit multiple directories.
+This directive may be used more than once.
+Modifications to $LOAD_PATH take place immediately and in the order they
+were specified on the command-line.
+.RS
+.RE
+.TP
+.B -r, --require LIBRARY
+require a specified LIBRARY before executing the application.
+The "require" statement will be executed immediately and in the order
+they were specified on the command-line.
+.RS
+.RE
+.SH SIGNALS
+.PP
+The following UNIX signals may be sent to the master process:
+.IP \[bu] 2
+HUP - reload config file, app, and gracefully restart all workers
+.IP \[bu] 2
+INT/TERM - quick shutdown, kills all workers immediately
+.IP \[bu] 2
+QUIT - graceful shutdown, waits for workers to finish their current
+request before finishing.
+.IP \[bu] 2
+USR1 - reopen all logs owned by the master and all workers See
+Unicorn::Util.reopen_logs for what is considered a log.
+.IP \[bu] 2
+USR2 - reexecute the running binary.
+A separate QUIT should be sent to the original process once the child is
+verified to be up and running.
+.IP \[bu] 2
+WINCH - gracefully stops workers but keep the master running.
+This will only work for daemonized processes.
+.IP \[bu] 2
+TTIN - increment the number of worker processes by one
+.IP \[bu] 2
+TTOU - decrement the number of worker processes by one
+.PP
+See the SIGNALS (http://unicorn.bogomips.org/SIGNALS.html) document for
+full description of all signals used by Unicorn.
+.SH RACK ENVIRONMENT
+.PP
+Accepted values of RACK_ENV and the middleware they automatically load
+(outside of RACKUP_FILE) are exactly as those in rackup(1):
+.IP \[bu] 2
+development - loads Rack::CommonLogger, Rack::ShowExceptions, and
+Rack::Lint middleware
+.IP \[bu] 2
+deployment - loads Rack::CommonLogger middleware
+.IP \[bu] 2
+none - loads no middleware at all, relying entirely on RACKUP_FILE
+.PP
+All unrecognized values for RACK_ENV are assumed to be "none".
+Production deployments are strongly encouraged to use "deployment" or
+"none" for maximum performance.
+.PP
+As of Unicorn 0.94.0, RACK_ENV is exported as a process-wide environment
+variable as well.
+While not current a part of the Rack specification as of Rack 1.0.1,
+this has become a de facto standard in the Rack world.
+.PP
+Note that the Rack::ContentLength and Rack::Chunked middlewares are
+never loaded by default.
+If needed, they should be individually specified in the RACKUP_FILE,
+some frameworks do not require them.
+.SH ENVIRONMENT VARIABLES
+.PP
+The RACK_ENV variable is set by the aforementioned -E switch.
+All application or library-specific environment variables (e.g.
+TMPDIR) may always be set in the Unicorn CONFIG_FILE in addition to the
+spawning shell.
+When transparently upgrading Unicorn, all environment variables set in
+the old master process are inherited by the new master process.
+Unicorn only uses (and will overwrite) the UNICORN_FD environment
+variable internally when doing transparent upgrades.
+.SH SEE ALSO
+.IP \[bu] 2
+unicorn_rails(1)
+.IP \[bu] 2
+\f[I]Rack::Builder\f[] ri/RDoc
+.IP \[bu] 2
+\f[I]Unicorn::Configurator\f[] ri/RDoc
+.IP \[bu] 2
+Unicorn RDoc (http://unicorn.bogomips.org/)
+.IP \[bu] 2
+Rack RDoc (http://rack.rubyforge.org/doc/)
+.IP \[bu] 2
+Rackup HowTo (http://wiki.github.com/rack/rack/tutorial-rackup-howto)
+.SH AUTHORS
+The Unicorn Community <mongrel-unicorn@rubyforge.org>.