unicorn-academia 4.7.0.1

data/FAQ

@@ -0,0 +1,53 @@
+= Frequently Asked Questions about Unicorn
+
+===  I've installed Rack 1.1.x, why can't Unicorn load Rails (2.3.5)?
+
+Rails 2.3.5 is not compatible with Rack 1.1.x.  Unicorn is compatible
+with both Rack 1.1.x and Rack 1.0.x, and RubyGems will load the latest
+version of Rack installed on the system.  Uninstalling the Rack 1.1.x
+gem should solve gem loading issues with Rails 2.3.5.  Rails 2.3.6
+and later correctly support Rack 1.1.x.
+
+=== Why are my redirects going to "http" URLs when my site uses https?
+
+If your site is entirely behind https, then Rack applications that use
+"rack.url_scheme" can set the following in the Unicorn config file:
+
+  HttpRequest::DEFAULTS["rack.url_scheme"] = "https"
+
+For frameworks that do not use "rack.url_scheme", you can also
+try setting one or both of the following:
+
+  HttpRequest::DEFAULTS["HTTPS"] = "on"
+  HttpRequest::DEFAULTS["HTTP_X_FORWARDED_PROTO"] = "https"
+
+Otherwise, you can configure your proxy (nginx) to send the
+"X-Forwarded-Proto: https" header only for parts of the site that use
+https.  For nginx, you can do it with the following line in appropriate
+"location" blocks of your nginx config file:
+
+  proxy_set_header X-Forwarded-Proto https;
+
+=== Why are log messages from Unicorn are unformatted when using Rails?
+
+Current versions of Rails unfortunately overrides the default Logger
+formatter.
+
+You can undo this behavior with the default logger in your Unicorn
+config file:
+
+  Configurator::DEFAULTS[:logger].formatter = Logger::Formatter.new
+
+Of course you can specify an entirely different logger as well
+with the "logger" directive described by Unicorn::Configurator.
+
+=== Why am I getting "connection refused"/502 errors under high load?
+
+Short answer: your application cannot keep up.
+
+You can increase the size of the :backlog parameter if your kernel
+supports a larger listen() queue, but keep in mind having a large listen
+queue makes failover to a different machine more difficult.
+
+See the TUNING and Unicorn::Configurator documents for more information
+on :backlog-related topics.

data/GIT-VERSION-GEN

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+DEF_VER = "v4.7.0.1"
+CONSTANT = "Unicorn::Const::UNICORN_VERSION"
+RVF = "lib/unicorn/version.rb"
+GVF = "GIT-VERSION-FILE"
+vn = DEF_VER
+
+# First see if there is a version file (included in release tarballs),
+# then try git-describe, then default.
+if File.exist?(".git")
+  describe = `git describe --abbrev=4 HEAD 2>/dev/null`.strip
+  case describe
+  when /\Av[0-9]*/
+    vn = describe
+    system(*%w(git update-index -q --refresh))
+    unless `git diff-index --name-only HEAD --`.chomp.empty?
+      vn << "-dirty"
+    end
+    vn.tr!('-', '.')
+  end
+end
+
+vn = vn.sub!(/\Av/, "")
+
+# generate the Ruby constant
+new_ruby_version = "#{CONSTANT} = '#{vn}'\n"
+cur_ruby_version = File.read(RVF) rescue nil
+if new_ruby_version != cur_ruby_version
+  File.open(RVF, "w") { |fp| fp.write(new_ruby_version) }
+end
+
+# generate the makefile snippet
+new_make_version = "GIT_VERSION = #{vn}\n"
+cur_make_version = File.read(GVF) rescue nil
+if new_make_version != cur_make_version
+  File.open(GVF, "w") { |fp| fp.write(new_make_version) }
+end
+
+puts vn if $0 == __FILE__

data/GNUmakefile

@@ -0,0 +1,266 @@
+# 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
+
+test-all: test test-integration
+
+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-academia
+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 test
+
+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.