unicorn-rupcio 6.1.0

data/GNUmakefile

@@ -0,0 +1,318 @@
+# 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
+# OLDDOC = olddoc
+RDOC = rdoc
+INSTALL = install
+PROVE = prove
+
+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"))')
+
+# we should never package more than one ext to avoid DSO proliferation:
+# https://udrepper.livejournal.com/8790.html
+ext := $(firstword $(wildcard ext/*))
+
+ragel: $(ext)/unicorn_http.c
+
+rl_files := $(wildcard $(ext)/*.rl)
+ragel: $(ext)/unicorn_http.c
+$(ext)/unicorn_http.c: $(rl_files)
+	cd $(@D) && $(RAGEL) unicorn_http.rl -C $(RLFLAGS) -o $(@F)
+ext_pfx := test/$(RUBY_ENGINE)-$(RUBY_VERSION)
+tmp_bin := $(ext_pfx)/bin
+ext_h := $(wildcard $(ext)/*/*.h $(ext)/*.h)
+ext_src := $(sort $(wildcard $(ext)/*.c) $(ext_h) $(ext)/unicorn_http.c)
+ext_pfx_src := $(addprefix $(ext_pfx)/,$(ext_src))
+ext_dir := $(ext_pfx)/$(ext)
+$(ext)/extconf.rb:
+	@>>$@
+$(ext_dir) $(tmp_bin) man/man1 doc/man1 pkg t/trash:
+	@mkdir -p $@
+$(ext_pfx)/$(ext)/%: $(ext)/% | $(ext_dir)
+	$(INSTALL) -m 644 $< $@
+$(ext_pfx)/$(ext)/Makefile: $(ext)/extconf.rb | $(ext_dir)
+	$(RM) -f $(@D)/*.o
+	cd $(@D) && $(RUBY) $(CURDIR)/$(ext)/extconf.rb $(EXTCONF_ARGS)
+ext_sfx := _ext.$(DLEXT)
+ext_dl := $(ext_pfx)/$(ext)/$(notdir $(ext)_ext.$(DLEXT))
+$(ext_dl): $(ext_src) $(ext_pfx_src) $(ext_pfx)/$(ext)/Makefile
+	$(MAKE) -C $(@D)
+lib := $(CURDIR)/lib:$(CURDIR)/$(ext_pfx)/$(ext)
+http build: $(ext_dl)
+$(ext_pfx)/$(ext)/unicorn_http.c: ext/unicorn_http/unicorn_http.c
+
+# 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))
+
+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))
+tmp_bins = $(addprefix $(tmp_bin)/, unicorn unicorn_rails)
+pid := $(shell echo $$PPID)
+build: $(tmp_bins)
+
+$(tmp_bin)/%: bin/% | $(tmp_bin)
+	$(INSTALL) -m 755 $< $@.$(pid)
+	$(MRI) -i -p -e '$$_.gsub!(%r{^#!.*$$},"#!$(ruby_bin)")' $@.$(pid)
+	mv $@.$(pid) $@
+
+bins: $(tmp_bins)
+
+t_log := $(T_log) $(T_n_log)
+test: $(T) $(T_n) test-prove
+	@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): $(ext_dl)
+	@$(MAKE) $(shell $(awk_slow) $@)
+
+# ensure we can require just the HTTP parser without the rest of unicorn
+test-require: $(ext_dl)
+	$(RUBY) --disable-gems -I$(ext_pfx)/$(ext) -runicorn_http -e Unicorn
+
+test_prereq := $(tmp_bins) $(ext_dl)
+
+SH_TEST_OPTS =
+ifdef V
+  ifeq ($(V),2)
+    SH_TEST_OPTS += --trace
+  else
+    SH_TEST_OPTS += --verbose
+  endif
+endif
+
+# do we trust Ruby behavior to be stable? some tests are
+# (mostly) POSIX sh (not bash or ksh93, so no "set -o pipefail"
+# TRACER = strace -f -o $(t_pfx).strace -s 100000
+# TRACER = /usr/bin/time -o $(t_pfx).time
+t_pfx = trash/$@-$(RUBY_ENGINE)-$(RUBY_VERSION)
+T_sh = $(wildcard t/t[0-9][0-9][0-9][0-9]-*.sh)
+$(T_sh): export RUBY := $(RUBY)
+$(T_sh): export PATH := $(CURDIR)/$(tmp_bin):$(PATH)
+$(T_sh): export RUBYLIB := $(lib):$(RUBYLIB)
+$(T_sh): dep $(test_prereq) t/random_blob t/trash/.gitignore
+	cd t && $(TRACER) $(SHELL) $(SH_TEST_OPTS) $(@F) $(TEST_OPTS)
+
+t/trash/.gitignore : | t/trash
+	echo '*' >$@
+
+dependencies := curl
+deps := $(addprefix t/.dep+,$(dependencies))
+$(deps): dep_bin = $(lastword $(subst +, ,$@))
+$(deps):
+	@which $(dep_bin) > $@.$(pid) 2>/dev/null || :
+	@test -s $@.$(pid) || \
+	  { echo >&2 "E '$(dep_bin)' not found in PATH=$(PATH)"; exit 1; }
+	@mv $@.$(pid) $@
+dep: $(deps)
+
+t/random_blob:
+	dd if=/dev/urandom bs=1M count=30 of=$@.$(pid)
+	mv $@.$(pid) $@
+
+test-integration: $(T_sh)
+
+test-prove: t/random_blob
+	$(PROVE) -vw
+
+check: test-require 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 := $(CURDIR)/$(tmp_bin):$(PATH)
+%.n: export RUBYLIB := $(lib):$(RUBYLIB)
+%.n: $(test_prereq)
+	$(run_test)
+
+$(T): arg = $@
+$(T): t = $(subst .rb,$(log_suffix),$@)
+$(T): export PATH := $(CURDIR)/$(tmp_bin):$(PATH)
+$(T): export RUBYLIB := $(lib):$(RUBYLIB)
+$(T): $(test_prereq)
+	$(run_test)
+
+install: $(bins) $(ext)/unicorn_http.c
+	$(prep_setup_rb)
+	$(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
+	$(RM) $(ext)/Makefile
+	$(RM) $(setup_rb_files) $(t_log)
+	$(RM) -r $(ext_pfx) man t/trash
+	$(RM) $(html1)
+
+man1 := $(addprefix Documentation/, unicorn.1 unicorn_rails.1)
+html1 := $(addsuffix .html, $(man1))
+man : $(man1) | man/man1
+	$(INSTALL) -m 644 $(man1) man/man1
+
+html : $(html1) | doc/man1
+	$(INSTALL) -m 644 $(html1) doc/man1
+
+%.1.html: %.1
+	$(OLDDOC) man2html -o $@ ./$<
+
+pkg_extra := GIT-VERSION-FILE lib/unicorn/version.rb \
+             $(ext)/unicorn_http.c $(man1_paths)
+
+NEWS:
+	# $(OLDDOC) prepare
+
+.manifest: $(ext)/unicorn_http.c man NEWS
+	(git ls-files && for i in $@ $(pkg_extra); do echo $$i; done) | \
+	  LC_ALL=C sort > $@+
+	cmp $@+ $@ || mv $@+ $@
+	$(RM) $@+
+
+PLACEHOLDERS = $(man1_rdoc)
+# doc: .document $(ext)/unicorn_http.c man html .olddoc.yml $(PLACEHOLDERS)
+# 	find bin lib -type f -name '*.rbc' -exec rm -f '{}' ';'
+# 	$(RM) -r doc
+# 	$(OLDDOC) prepare
+# 	$(RDOC) -f dark216
+# 	$(OLDDOC) merge
+# 	$(INSTALL) -m 644 COPYING doc/COPYING
+# 	$(INSTALL) -m 644 NEWS.atom.xml doc/NEWS.atom.xml
+# 	$(INSTALL) -m 644 $(shell LC_ALL=C grep '^[A-Z]' .document) doc/
+# 	$(INSTALL) -m 644 $(man1_paths) doc/
+# 	tar cf - $$(git ls-files examples/) | (cd doc && tar xf -)
+#
+# # publishes docs to https://yhbt.net/unicorn/
+# publish_doc:
+# 	-git set-file-times
+# 	$(MAKE) doc
+# 	$(MAKE) doc_gz
+# 	chmod 644 $$(find doc -type f)
+# 	$(RSYNC) -av doc/ yhbt.net:/srv/yhbt/unicorn/ \
+# 		--exclude index.html* --exclude created.rid*
+# 	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 '^.*\.gz$$')
+doc_gz:
+	for i in $(docs); do \
+	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
+
+ifneq ($(VERSION),)
+rfpackage := unicorn
+pkggem := pkg/$(rfpackage)-$(VERSION).gem
+pkgtgz := pkg/$(rfpackage)-$(VERSION).tgz
+
+# 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 --local $(CURDIR)/$<
+
+$(pkggem): .manifest fix-perms | pkg
+	gem build $(rfpackage).gemspec
+	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
+	# push gem to Gemcutter
+	gem push $(pkggem)
+else
+gem install-gem: GIT-VERSION-FILE
+	$(MAKE) $@ VERSION=$(GIT_VERSION)
+endif
+
+$(PLACEHOLDERS):
+	# echo olddoc_placeholder > $@
+
+check-warnings:
+	@(for i in $$(git ls-files '*.rb' bin | grep -v '^setup\.rb$$'); \
+	  do $(RUBY) --disable-gems -d -W2 -c \
+	  $$i; done) | grep -v '^Syntax OK$$' || :
+
+.PHONY: .FORCE-GIT-VERSION-FILE doc $(T) $(slow_tests) man $(T_sh) clean

data/HACKING

@@ -0,0 +1,117 @@
+= 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.
+
+Ragel may be dropped in favor of a picohttpparser-based one in the future.
+
+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.
+
+New tests are written in Perl 5 and use TAP <https://testanything.org/>
+to ensure stability and immunity from Ruby incompatibilities.
+
+Users of GNU-based systems (such as GNU/Linux) usually have GNU make
+installed as "make" instead of "gmake".
+
+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
+
+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
+<tt>https://yhbt.net/unicorn-public/$MESSAGE_ID/</tt> if possible
+since the Message-ID remains searchable even if a particular site
+becomes unavailable.
+
+=== Ruby/C Compatibility
+
+We target C Ruby 2.5 and later.  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 in Debian 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
+{SubmittingPatches}[https://git.kernel.org/cgit/git/git.git/tree/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
+
+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
+
+  gmake install-gem

data/ISSUES

@@ -0,0 +1,102 @@
+= Issues
+
+mailto:unicorn-public@yhbt.net is the best place to report bugs,
+submit patches and/or obtain support after you have searched the
+{email archives}[https://yhbt.net/unicorn-public/] and
+{documentation}[https://yhbt.net/unicorn/].
+
+* No subscription will ever be required to email us
+* Cc: all participants in a thread or commit, as subscription is optional
+* Do not {top post}[http://catb.org/jargon/html/T/top-post.html] in replies
+* Quote as little as possible of the message you're replying to
+* Do not send HTML mail or images,
+  they hurt reader privacy and will be flagged as spam
+* Anonymous and pseudonymous messages will ALWAYS be welcome
+* The email submission port (587) is enabled on the yhbt.net MX:
+  https://yhbt.net/unicorn-public/20141004232241.GA23908@dcvr.yhbt.net/t/
+
+We will never have a centralized or formal bug tracker.  Instead we
+can interoperate with any bug tracker which can Cc: us plain-text to
+mailto:unicorn-public@yhbt.net   This includes the Debian BTS
+at https://bugs.debian.org/unicorn and possibly others.
+
+unicorn is a server; it does not depend on graphics/audio.  Nobody
+communicating with us will ever be expected to go through the trouble
+of setting up graphics nor audio support.
+
+If your issue is of a sensitive nature or you're just shy in public,
+use anonymity tools such as Tor or Mixmaster; and rely on the public
+mail archives for responses.  Be sure to scrub sensitive log messages
+and such.
+
+If you don't get a response within a few days, we may have forgotten
+about it so feel free to ask again.
+
+The project does not and will never endorse nor promote commercial
+services (including support).  The author of unicorn must never be
+allowed to profit off the damage it's done to the entire Ruby world.
+
+== Bugs in related projects
+
+unicorn is sometimes affected by bugs in its dependencies.  Bugs
+triggered by unicorn in mainline Ruby, rack, GNU C library (glibc),
+or the Linux kernel will be reported upstream and fixed.
+
+For bugs in Ruby itself, we may forward bugs to
+https://bugs.ruby-lang.org/ and discuss+fix them on the ruby-core
+list at mailto:ruby-core@ruby-lang.org
+Subscription to post is required to ruby-core, unfortunately:
+mailto:ruby-core-request@ruby-lang.org?subject=subscribe
+Unofficial archives are available at: https://public-inbox.org/ruby-core/
+
+For uncommon bugs in Rack, we may forward bugs to
+mailto:rack-devel@googlegroups.com and discuss there.
+Subscription (without any web UI or Google account) is possible via:
+mailto:rack-devel+subscribe@googlegroups.com
+Note: not everyone can use the proprietary bug tracker used by Rack,
+but their mailing list remains operational.
+Unofficial archives are available at: https://public-inbox.org/rack-devel/
+
+Uncommon bugs we encounter in the Linux kernel should be Cc:-ed to the
+Linux kernel mailing list (LKML) at mailto:linux-kernel@vger.kernel.org
+and subsystem maintainers such as mailto:netdev@vger.kernel.org
+(for networking issues).  It is expected practice to Cc: anybody
+involved with any problematic commits (including those in the
+Signed-off-by: and other trailer lines).  No subscription is necessary,
+and the our mailing list follows the same conventions as LKML for
+interopability. Archives are available at https://lore.kernel.org/lkml/
+There is a kernel.org Bugzilla instance, but it is ignored by most.
+
+Likewise for any rare glibc bugs we might encounter, we should Cc:
+mailto:libc-alpha@sourceware.org
+Archives are available at: https://inbox.sourceware.org/libc-alpha/
+Keep in mind glibc upstream does use Bugzilla for tracking bugs:
+https://sourceware.org/bugzilla/
+
+== Submitting Patches
+
+See the HACKING document (and additionally, the
+{SubmittingPatches}[https://git.kernel.org/cgit/git/git.git/tree/Documentation/SubmittingPatches]
+document distributed with git) on guidelines for patch submission.
+
+== Contact Info
+
+Mail is publicly-archived, SMTP subscription is discouraged to avoid
+servers being a single-point-of-failure, so Cc: all participants.
+
+The HTTP(S) archives have links to per-thread Atom feeds and downloadable
+mboxes.  Read-only IMAP(S) folders, POP3, and NNTP(S) newsgroups are available.
+
+* https://yhbt.net/unicorn-public/
+* http://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/unicorn-public/
+* imaps://;AUTH=ANONYMOUS@yhbt.net/inbox.comp.lang.ruby.unicorn.0
+* imap://;AUTH=ANONYMOUS@7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/inbox.comp.lang.ruby.unicorn.0
+* nntps://news.public-inbox.org/inbox.comp.lang.ruby.unicorn
+* nntp://news.gmane.io/gmane.comp.lang.ruby.unicorn.general
+* https://yhbt.net/unicorn-public/_/text/help/#pop3
+
+Full Atom feeds:
+* https://yhbt.net/unicorn-public/new.atom
+* http://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/unicorn-public/new.atom
+
+We only accept plain-text mail: mailto:unicorn-public@yhbt.net

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:
+  https://yhbt.net/unicorn-public/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.
+
+* 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 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://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/36450
+
+* 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.
+
+* 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://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/28655
+
+* 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: https://yhbt.net/unicorn-public/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/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 - https://www.gnu.org/licenses/gpl-2.0.txt
+GPLv3 - https://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.