unicorn-heroku-wait 4.8.0.1.g0ed2.dirty

data/GNUmakefile

@@ -0,0 +1,267 @@
+# use GNU Make to run tests in parallel, and without depending on RubyGems
+all:: test
+
+RLFLAGS = -G2
+
+MRI = ruby
+RUBY = ruby
+RAKE = rake
+RAGEL = ragel
+RSYNC = rsync
+
+GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
+	@./GIT-VERSION-GEN
+-include GIT-VERSION-FILE
+-include local.mk
+ruby_bin := $(shell which $(RUBY))
+ifeq ($(DLEXT),) # "so" for Linux
+  DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts RbConfig::CONFIG["DLEXT"]')
+endif
+ifeq ($(RUBY_VERSION),)
+  RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
+endif
+
+RUBY_ENGINE := $(shell $(RUBY) -e 'puts((RUBY_ENGINE rescue "ruby"))')
+
+isolate_libs := tmp/isolate/$(RUBY_ENGINE)-$(RUBY_VERSION).mk
+$(isolate_libs): script/isolate_for_tests
+	@$(RUBY) script/isolate_for_tests
+-include $(isolate_libs)
+MYLIBS = $(RUBYLIB):$(ISOLATE_LIBS)
+
+# dunno how to implement this as concisely in Ruby, and hell, I love awk
+awk_slow := awk '/def test_/{print FILENAME"--"$$2".n"}' 2>/dev/null
+
+slow_tests := test/unit/test_server.rb test/exec/test_exec.rb \
+  test/unit/test_signals.rb test/unit/test_upload.rb
+log_suffix = .$(RUBY_ENGINE).$(RUBY_VERSION).log
+T := $(filter-out $(slow_tests), $(wildcard test/*/test*.rb))
+T_n := $(shell $(awk_slow) $(slow_tests))
+T_log := $(subst .rb,$(log_suffix),$(T))
+T_n_log := $(subst .n,$(log_suffix),$(T_n))
+test_prefix = $(CURDIR)/test/$(RUBY_ENGINE)-$(RUBY_VERSION)
+
+ext := ext/unicorn_http
+c_files := $(ext)/unicorn_http.c $(ext)/httpdate.c $(wildcard $(ext)/*.h)
+rl_files := $(wildcard $(ext)/*.rl)
+base_bins := unicorn unicorn_rails
+bins := $(addprefix bin/, $(base_bins))
+man1_rdoc := $(addsuffix _1, $(base_bins))
+man1_bins := $(addsuffix .1, $(base_bins))
+man1_paths := $(addprefix man/man1/, $(man1_bins))
+rb_files := $(bins) $(shell find lib ext -type f -name '*.rb')
+inst_deps := $(c_files) $(rb_files) GNUmakefile test/test_helper.rb
+
+ragel: $(ext)/unicorn_http.c
+$(ext)/unicorn_http.c: $(rl_files)
+	cd $(@D) && $(RAGEL) unicorn_http.rl -C $(RLFLAGS) -o $(@F)
+$(ext)/Makefile: $(ext)/extconf.rb $(c_files)
+	cd $(@D) && $(RUBY) extconf.rb
+$(ext)/unicorn_http.$(DLEXT): $(ext)/Makefile
+	$(MAKE) -C $(@D)
+lib/unicorn_http.$(DLEXT): $(ext)/unicorn_http.$(DLEXT)
+	@mkdir -p lib
+	install -m644 $< $@
+http: lib/unicorn_http.$(DLEXT)
+
+test-install: $(test_prefix)/.stamp
+$(test_prefix)/.stamp: $(inst_deps)
+	mkdir -p $(test_prefix)/.ccache
+	tar cf - $(inst_deps) GIT-VERSION-GEN | \
+	  (cd $(test_prefix) && tar xf -)
+	$(MAKE) -C $(test_prefix) clean
+	$(MAKE) -C $(test_prefix) http shebang RUBY="$(RUBY)"
+	> $@
+
+# this is only intended to be run within $(test_prefix)
+shebang: $(bins)
+	$(MRI) -i -p -e '$$_.gsub!(%r{^#!.*$$},"#!$(ruby_bin)")' $^
+
+t_log := $(T_log) $(T_n_log)
+test: $(T) $(T_n)
+	@cat $(t_log) | $(MRI) test/aggregate.rb
+	@$(RM) $(t_log)
+
+test-exec: $(wildcard test/exec/test_*.rb)
+test-unit: $(wildcard test/unit/test_*.rb)
+$(slow_tests): $(test_prefix)/.stamp
+	@$(MAKE) $(shell $(awk_slow) $@)
+
+test-integration: $(test_prefix)/.stamp
+	$(MAKE) -C t
+
+check: test test-integration
+test-all: check
+
+TEST_OPTS = -v
+check_test = grep '0 failures, 0 errors' $(t) >/dev/null
+ifndef V
+       quiet_pre = @echo '* $(arg)$(extra)';
+       quiet_post = >$(t) 2>&1 && $(check_test)
+else
+       # we can't rely on -o pipefail outside of bash 3+,
+       # so we use a stamp file to indicate success and
+       # have rm fail if the stamp didn't get created
+       stamp = $@$(log_suffix).ok
+       quiet_pre = @echo $(RUBY) $(arg) $(TEST_OPTS); ! test -f $(stamp) && (
+       quiet_post = && > $(stamp) )2>&1 | tee $(t); \
+         rm $(stamp) 2>/dev/null && $(check_test)
+endif
+
+# not all systems have setsid(8), we need it because we spam signals
+# stupidly in some tests...
+rb_setsid := $(RUBY) -e 'Process.setsid' -e 'exec *ARGV'
+
+# TRACER='strace -f -o $(t).strace -s 100000'
+run_test = $(quiet_pre) \
+  $(rb_setsid) $(TRACER) $(RUBY) -w $(arg) $(TEST_OPTS) $(quiet_post) || \
+  (sed "s,^,$(extra): ," >&2 < $(t); exit 1)
+
+%.n: arg = $(subst .n,,$(subst --, -n ,$@))
+%.n: t = $(subst .n,$(log_suffix),$@)
+%.n: export PATH := $(test_prefix)/bin:$(PATH)
+%.n: export RUBYLIB := $(test_prefix):$(test_prefix)/lib:$(MYLIBS)
+%.n: $(test_prefix)/.stamp
+	$(run_test)
+
+$(T): arg = $@
+$(T): t = $(subst .rb,$(log_suffix),$@)
+$(T): export PATH := $(test_prefix)/bin:$(PATH)
+$(T): export RUBYLIB := $(test_prefix):$(test_prefix)/lib:$(MYLIBS)
+$(T): $(test_prefix)/.stamp
+	$(run_test)
+
+install: $(bins) $(ext)/unicorn_http.c
+	$(prep_setup_rb)
+	$(RM) lib/unicorn_http.$(DLEXT)
+	$(RM) -r .install-tmp
+	mkdir .install-tmp
+	cp -p bin/* .install-tmp
+	$(RUBY) setup.rb all
+	$(RM) $^
+	mv .install-tmp/* bin/
+	$(RM) -r .install-tmp
+	$(prep_setup_rb)
+
+setup_rb_files := .config InstalledFiles
+prep_setup_rb := @-$(RM) $(setup_rb_files);$(MAKE) -C $(ext) clean
+
+clean:
+	-$(MAKE) -C $(ext) clean
+	-$(MAKE) -C Documentation clean
+	$(RM) $(ext)/Makefile lib/unicorn_http.$(DLEXT)
+	$(RM) $(setup_rb_files) $(t_log)
+	$(RM) -r $(test_prefix) man
+
+man html:
+	$(MAKE) -C Documentation install-$@
+
+pkg_extra := GIT-VERSION-FILE lib/unicorn/version.rb ChangeLog LATEST NEWS \
+             $(ext)/unicorn_http.c $(man1_paths)
+
+ChangeLog: GIT-VERSION-FILE .wrongdoc.yml
+	wrongdoc prepare
+
+.manifest: ChangeLog $(ext)/unicorn_http.c man
+	(git ls-files && for i in $@ $(pkg_extra); do echo $$i; done) | \
+	  LC_ALL=C sort > $@+
+	cmp $@+ $@ || mv $@+ $@
+	$(RM) $@+
+
+doc: .document $(ext)/unicorn_http.c man html .wrongdoc.yml
+	for i in $(man1_rdoc); do echo > $$i; done
+	find bin lib -type f -name '*.rbc' -exec rm -f '{}' ';'
+	$(RM) -r doc
+	wrongdoc all
+	install -m644 COPYING doc/COPYING
+	install -m644 $(shell LC_ALL=C grep '^[A-Z]' .document) doc/
+	install -m644 $(man1_paths) doc/
+	tar cf - $$(git ls-files examples/) | (cd doc && tar xf -)
+	$(RM) $(man1_rdoc)
+
+# publishes docs to http://unicorn.bogomips.org
+publish_doc:
+	-git set-file-times
+	$(MAKE) doc
+	find doc/images -type f | \
+		TZ=UTC xargs touch -d '1970-01-01 00:00:02' doc/rdoc.css
+	$(MAKE) doc_gz
+	chmod 644 $$(find doc -type f)
+	$(RSYNC) -av doc/ unicorn.bogomips.org:/srv/unicorn/
+	git ls-files | xargs touch
+
+# Create gzip variants of the same timestamp as the original so nginx
+# "gzip_static on" can serve the gzipped versions directly.
+doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.\(gif\|jpg\|png\|gz\)$$')
+doc_gz:
+	for i in $(docs); do \
+	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
+
+ifneq ($(VERSION),)
+rfproject := mongrel
+rfpackage := unicorn
+pkggem := pkg/$(rfpackage)-$(VERSION).gem
+pkgtgz := pkg/$(rfpackage)-$(VERSION).tgz
+release_notes := release_notes-$(VERSION)
+release_changes := release_changes-$(VERSION)
+
+release-notes: $(release_notes)
+release-changes: $(release_changes)
+$(release_changes):
+	wrongdoc release_changes > $@+
+	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
+$(release_notes):
+	wrongdoc release_notes > $@+
+	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
+
+# ensures we're actually on the tagged $(VERSION), only used for release
+verify:
+	test x"$(shell umask)" = x0022
+	git rev-parse --verify refs/tags/v$(VERSION)^{}
+	git diff-index --quiet HEAD^0
+	test `git rev-parse --verify HEAD^0` = \
+	     `git rev-parse --verify refs/tags/v$(VERSION)^{}`
+
+fix-perms:
+	git ls-tree -r HEAD | awk '/^100644 / {print $$NF}' | xargs chmod 644
+	git ls-tree -r HEAD | awk '/^100755 / {print $$NF}' | xargs chmod 755
+
+gem: $(pkggem)
+
+install-gem: $(pkggem)
+	gem install $(CURDIR)/$<
+
+$(pkggem): .manifest fix-perms
+	gem build $(rfpackage).gemspec
+	mkdir -p pkg
+	mv $(@F) $@
+
+$(pkgtgz): distdir = $(basename $@)
+$(pkgtgz): HEAD = v$(VERSION)
+$(pkgtgz): .manifest fix-perms
+	@test -n "$(distdir)"
+	$(RM) -r $(distdir)
+	mkdir -p $(distdir)
+	tar cf - $$(cat .manifest) | (cd $(distdir) && tar xf -)
+	cd pkg && tar cf - $(basename $(@F)) | gzip -9 > $(@F)+
+	mv $@+ $@
+
+package: $(pkgtgz) $(pkggem)
+
+release: verify package $(release_notes) $(release_changes)
+	# make tgz release on RubyForge
+	rubyforge add_release -f -n $(release_notes) -a $(release_changes) \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkgtgz)
+	# push gem to Gemcutter
+	gem push $(pkggem)
+	# in case of gem downloads from RubyForge releases page
+	-rubyforge add_file \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkggem)
+	$(RAKE) fm_update VERSION=$(VERSION)
+else
+gem install-gem: GIT-VERSION-FILE
+	$(MAKE) $@ VERSION=$(GIT_VERSION)
+endif
+
+.PHONY: .FORCE-GIT-VERSION-FILE doc $(T) $(slow_tests) man
+.PHONY: test-install

data/HACKING

@@ -0,0 +1,134 @@
+= Unicorn Hacker's Guide
+
+== Polyglot Infrastructure
+
+Like Mongrel, we use Ruby where it makes sense, and Ragel with C where
+it helps performance.  All of the code that actually runs your Rack
+application is written Ruby, Ragel or C.
+
+As far as tests and documentation goes, we're not afraid to embrace Unix
+and use traditional Unix tools where they make sense and get the job
+done.
+
+=== Tests
+
+Tests are good, but slow tests make development slow, so we make tests
+faster (in parallel) with GNU make (instead of Rake) and avoiding
+RubyGems.
+
+Users of GNU-based systems (such as GNU/Linux) usually have GNU make
+installed as "make" instead of "gmake".
+
+Since we don't load RubyGems by default, loading Rack properly requires
+setting up RUBYLIB to point to where Rack is located.  Not loading
+RubyGems drastically lowers the time to run the full test suite.  You
+may setup a "local.mk" file in the top-level working directory to setup
+your RUBYLIB and any other environment variables.  A "local.mk.sample"
+file is provided for reference.
+
+Running the entire test suite with 4 tests in parallel:
+
+  gmake -j4 check
+
+Running just one unit test:
+
+  gmake test/unit/test_http_parser.rb
+
+Running just one test case in a unit test:
+
+  gmake test/unit/test_http_parser.rb--test_parse_simple.n
+
+=== HttpServer
+
+We strive to write as little code as possible while still maintaining
+readability.  However, readability and flexibility may be sacrificed for
+performance in hot code paths.  For Ruby, less code generally means
+faster code.
+
+Memory allocation should be minimized as much as practically possible.
+Buffers for IO#readpartial are preallocated in the hot paths to avoid
+building up garbage.  Hash assignments use frozen strings to avoid the
+duplication behind-the-scenes.
+
+We spend as little time as possible inside signal handlers and instead
+defer handling them for predictability and robustness.  Most of the
+Unix-specific things are in the Unicorn::HttpServer class.  Unix systems
+programming experience will come in handy (or be learned) here.
+
+=== Documentation
+
+We use RDoc 2.5.x with Darkfish for documentation as much as possible,
+if you're on Ruby 1.8 you want to install the latest "rdoc" gem.  Due to
+the lack of RDoc-to-manpage converters we know about, we're writing
+manpages in Markdown and converting to troff/HTML with Pandoc.
+
+Please wrap documentation at 72 characters-per-line or less (long URLs
+are exempt) so it is comfortably readable from terminals.
+
+When referencing mailing list posts, use
+"http://mid.gmane.org/$MESSAGE_ID" if possible since the Message-ID
+remains searchable even if Gmane becomes unavailable.
+
+=== Ruby/C Compatibility
+
+We target Ruby 1.8.6+, 1.9 and will target Rubinius as it becomes
+production-ready.  We need the Ruby implementation to support fork,
+exec, pipe, UNIX signals, access to integer file descriptors and
+ability to use unlinked files.
+
+All of our C code is OS-independent and should run on compilers
+supported by the versions of Ruby we target.
+
+=== Ragel Compatibility
+
+We target the latest released version of Ragel and will update our code
+to keep up with new releases.  Packaged tarballs and gems include the
+generated source code so they will remain usable if compatibility is
+broken.
+
+== Contributing
+
+Contributions are welcome in the form of patches, pull requests, code
+review, testing, documentation, user support or any other feedback is
+welcome.  The mailing list is the central coordination point for all
+user and developer feedback and bug reports.
+
+=== Submitting Patches
+
+Follow conventions already established in the code and do not exceed 80
+characters per line.
+
+Inline patches (from "git format-patch -M") to the mailing list are
+preferred because they allow code review and comments in the reply to
+the patch.
+
+We will adhere to mostly the same conventions for patch submissions as
+git itself.  See the Documentation/SubmittingPatches document
+distributed with git on on patch submission guidelines to follow.  Just
+don't email the git mailing list or maintainer with Unicorn patches :)
+
+== Building a Gem
+
+In order to build the gem, you must install the following components:
+
+ * wrongdoc
+ * pandoc
+
+You can build the Unicorn gem with the following command:
+
+  gmake gem
+
+== Running Development Versions
+
+It is easy to install the contents of your git working directory:
+
+Via RubyGems (RubyGems 1.3.5+ recommended for prerelease versions):
+
+  gmake install-gem
+
+Without RubyGems (via setup.rb):
+
+  gmake install
+
+It is not at all recommended to mix a RubyGems installation with an
+installation done without RubyGems, however.

data/ISSUES

@@ -0,0 +1,36 @@
+= Issues
+
+The {mailing list}[mailto:mongrel-unicorn@rubyforge.org] is the best
+place to report bugs, submit patches and/or obtain support after you
+have searched the mailing list archives and
+{documentation}[http://unicorn.bogomips.org].
+
+* No subscription is needed to post to the mailing list,
+  let us know that we need to Cc: replies to you if you're unsubscribed.
+* Do not {top post}[http://catb.org/jargon/html/T/top-post.html] in replies
+* Quote only the relevant portions of the message you're replying to
+* Do not send HTML mail
+
+If your issue is of a sensitive nature or you're just shy in public,
+then feel free to email us privately at mailto:unicorn@bogomips.org
+instead and your issue will be handled discreetly.
+
+If you don't get a response within a few days, we may have forgotten
+about it so feel free to ask again.
+
+== Submitting Patches
+
+See the HACKING document (and additionally, the
+Documentation/SubmittingPatches document distributed with git) on
+guidelines for patch submission.
+
+== Mailing List Info
+
+* subscribe: http://rubyforge.org/mailman/listinfo/mongrel-unicorn
+* post: mailto:mongrel-unicorn@rubyforge.org
+* private: mailto:unicorn@bogomips.org
+
+== Mailing List Archives
+
+* nntp://news.gmane.org/gmane.comp.lang.ruby.unicorn.general
+* http://rubyforge.org/pipermail/mongrel-unicorn

data/KNOWN_ISSUES

@@ -0,0 +1,79 @@
+= Known Issues
+
+Occasionally odd {issues}[link:ISSUES.html] arise without a transparent or
+acceptable solution.  Those issues are documented here.
+
+* Some libraries/applications may install signal handlers which conflict
+  with signal handlers unicorn uses.  Leaving "preload_app false"
+  (the default) will allow unicorn to always override existing signal
+  handlers.
+
+* Issues with FreeBSD jails can be worked around as documented by Tatsuya Ono:
+  http://mid.gmane.org/CAHBuKRj09FdxAgzsefJWotexw-7JYZGJMtgUp_dhjPz9VbKD6Q@mail.gmail.com
+
+* PRNGs (pseudo-random number generators) loaded before forking
+  (e.g. "preload_app true") may need to have their internal state
+  reset in the after_fork hook.  Starting with \Unicorn 3.6.1, we
+  have builtin workarounds for Kernel#rand and OpenSSL::Random users,
+  but applications may use other PRNGs.
+
+* Under some versions of Ruby 1.8, it is necessary to call +srand+ in an
+  after_fork hook to get correct random number generation.  We have a builtin
+  workaround for this starting with \Unicorn 3.6.1
+
+  See http://redmine.ruby-lang.org/issues/show/4338
+
+* On Ruby 1.8 prior to Ruby 1.8.7-p248, *BSD platforms have a broken
+  stdio that causes failure for file uploads larger than 112K.  Upgrade
+  your version of Ruby or continue using Unicorn 1.x/3.4.x.
+
+* For notes on sandboxing tools such as Bundler or Isolate,
+  see the {Sandbox}[link:Sandbox.html] page.
+
+* nginx with "sendfile on" under FreeBSD 8 is broken when
+  uploads are buffered to disk.  Disabling sendfile is required to
+  work around this bug which should be fixed in newer versions of FreeBSD.
+
+* When using "preload_app true", with apps using background threads
+  need to restart them in the after_fork hook because threads are never
+  shared with child processes.  Additionally, any synchronization
+  primitives (Mutexes, Monitors, ConditionVariables) should be
+  reinitialized in case they are held during fork time to avoid
+  deadlocks.  The core Ruby Logger class needlessly uses a MonitorMutex
+  which can be disabled with a {monkey patch}[link:examples/logger_mp_safe.rb]
+
+== Known Issues (Old)
+
+* Under Ruby 1.9.1, methods like Array#shuffle and Array#sample will
+  segfault if called after forking.  Upgrade to Ruby 1.9.2 or call
+  "Kernel.rand" in your after_fork hook to reinitialize the random
+  number generator.
+
+  See http://redmine.ruby-lang.org/issues/show/2962 for more details
+
+* Rails 2.3.2 bundles its own version of Rack.  This may cause subtle
+  bugs when simultaneously loaded with the system-wide Rack Rubygem
+  which Unicorn depends on.  Upgrading to Rails 2.3.4 (or later) is
+  strongly recommended for all Rails 2.3.x users for this (and security
+  reasons).  Rails 2.2.x series (or before) did not bundle Rack and are
+  should be unnaffected.  If there is any reason which forces your
+  application to use Rails 2.3.2 and you have no other choice, then
+  you may edit your Unicorn gemspec and remove the Rack dependency.
+
+  ref: http://mid.gmane.org/20091014221552.GA30624@dcvr.yhbt.net
+  Note: the workaround described in the article above only made
+  the issue more subtle and we didn't notice them immediately.
+
+* WONTFIX: code reloading and restarts with Sinatra 0.3.x (and likely older
+  versions) apps is broken.  The workaround is to force production
+  mode to disable code reloading as well as disabling "run" in your
+  Sinatra application:
+    set :env, :production
+    set :run, false
+  Since this is no longer an issue with Sinatra 0.9.x apps, this will not be
+  fixed on our end.  Since Unicorn is itself the application launcher, the
+  at_exit handler used in old Sinatra always caused Mongrel to be launched
+  whenever a Unicorn worker was about to exit.
+
+  Also remember we're capable of replacing the running binary without dropping
+  any connections regardless of framework :)

data/LATEST

@@ -0,0 +1,28 @@
+=== unicorn 4.8.0 - big internal changes, but compatible / 2014-01-11 07:34 UTC
+
+  This release contains fairly major internal workings of master-to-worker
+  notifications.  The master process no longer sends signals to workers
+  for most tasks.  This works around some compatibility issues with some
+  versions of the "pg" gem (and potentially any other code which may not
+  handle EINTR properly).  One extra benefit is it also helps stray
+  workers notice a rare, unexpected master death more easily.  Workers
+  continue to (and will always) accept existing signals for compatibility
+  with tools/scripts which may signal workers.
+
+  PID file are always written early (even on upgrade) again to avoid
+  breaking strange monitoring setups which use PID files.  Keep in mind we
+  have always discouraged monitoring based on PID files as they are
+  fragile.
+
+  We now avoid bubbling IOError to the Rack app on premature client
+  disconnects when streaming the input body.  This is usually not a
+  problem with nginx, but may be on some LAN setups without nginx).
+
+  Thanks to Sam Saffron, Jimmy Soho, Rodrigo Rosenfeld Rosas,
+  Michael Fischer, and Andrew Hobson for their help with this release.
+
+  Note: the unicorn mailing list will be moved/changed soon due to the
+  RubyForge shutdown.  unicorn will always rely only on Free Software.
+  There will never be any sign-up requirements nor terms-of-service to
+  agree to when communicating with us.
+

data/LICENSE

@@ -0,0 +1,67 @@
+Unicorn is copyrighted free software by all contributors, see logs in
+revision control for names and email addresses of all of them.
+
+You can redistribute it and/or modify it under either the terms of the
+GNU General Public License (GPL) as published by the Free Software
+Foundation (FSF), either version 2 of the License, or (at your option)
+any later version.  We currently prefer the GPLv3 or later for
+derivative works, but the GPLv2 is fine.
+
+The complete texts of the GPLv2 and GPLv3 are below:
+GPLv2 - http://www.gnu.org/licenses/gpl-2.0.txt
+GPLv3 - http://www.gnu.org/licenses/gpl-3.0.txt
+
+You may (against our _preference_) also use the Ruby 1.8 license terms
+which we inherited from the original Mongrel project when we forked it:
+
+=== Ruby 1.8-specific terms (if you're not using the GPL)
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise make them
+       Freely Available, such as by posting said modifications to Usenet or an
+       equivalent medium, or by allowing the author to include your
+       modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict with
+       standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+       together with instructions (in the manual page or equivalent) on where
+       to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of the
+       software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+  5. The scripts and library files supplied as input to or produced as
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them,
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/Links

@@ -0,0 +1,56 @@
+= Related Projects
+
+If you're interested in \Unicorn, you may be interested in some of the projects
+listed below.  If you have any links to add/change/remove, please tell us at
+mailto:mongrel-unicorn@rubyforge.org!
+
+== Disclaimer
+
+The \Unicorn project is not responsible for the content in these links.
+Furthermore, the \Unicorn project has never, does not and will never endorse:
+
+* any for-profit entities or services
+* any non-{Free Software}[http://www.gnu.org/philosophy/free-sw.html]
+
+The existence of these links does not imply endorsement of any entities
+or services behind them.
+
+=== For use with \Unicorn
+
+* {Bluepill}[https://github.com/arya/bluepill] -
+  a simple process monitoring tool written in Ruby
+
+* {golden_brindle}[https://github.com/simonoff/golden_brindle] - tool to
+  manage multiple \Unicorn instances/applications on a single server
+
+* {raindrops}[http://raindrops.bogomips.org/] - real-time stats for
+  preforking Rack servers
+
+* {UnXF}[http://bogomips.org/unxf/]  Un-X-Forward* the Rack environment,
+  useful since unicorn is designed to be deployed behind a reverse proxy.
+
+=== \Unicorn is written to work with
+
+* {Rack}[http://rack.rubyforge.org/] - a minimal interface between webservers
+  supporting Ruby and Ruby frameworks
+
+* {Ruby}[http://ruby-lang.org/] - the programming language of Rack and \Unicorn
+
+* {nginx}[http://nginx.org/] - the reverse proxy for use with \Unicorn
+
+* {kgio}[http://bogomips.org/kgio/] - the I/O library written for \Unicorn
+
+=== Derivatives
+
+* {Green Unicorn}[http://gunicorn.org/] - a Python version of \Unicorn
+
+* {Rainbows!}[http://rainbows.rubyforge.org/] - \Unicorn for sleepy
+  apps and slow clients.
+
+=== Prior Work
+
+* {Mongrel}[http://mongrel.rubyforge.org/] - the awesome webserver \Unicorn is
+  based on
+
+* {david}[http://bogomips.org/david.git] - a tool to explain why you need
+  nginx in front of \Unicorn