zbatery 0.0.0

data/GNUmakefile

@@ -0,0 +1,169 @@
+# use GNU Make to run tests in parallel, and without depending on RubyGems
+all::
+RUBY = ruby
+RAKE = rake
+GIT_URL = git://git.bogomips.org/zbatery.git
+
+GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
+	@./GIT-VERSION-GEN
+-include GIT-VERSION-FILE
+-include local.mk
+ifeq ($(DLEXT),) # "so" for Linux
+  DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts Config::CONFIG["DLEXT"]')
+endif
+ifeq ($(RUBY_VERSION),)
+  RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
+endif
+
+base_bins := zbatery
+bins := $(addprefix bin/, $(base_bins))
+man1_bins := $(addsuffix .1, $(base_bins))
+man1_paths := $(addprefix man/man1/, $(man1_bins))
+
+install: $(bins)
+	$(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
+	-$(MAKE) -C Documentation clean
+	$(RM) $(setup_rb_files) $(t_log)
+
+man:
+	$(MAKE) -C Documentation install-man
+
+pkg_extra := GIT-VERSION-FILE NEWS ChangeLog
+manifest: $(pkg_extra) man
+	$(RM) .manifest
+	$(MAKE) .manifest
+
+.manifest:
+	(git ls-files && \
+         for i in $@ $(pkg_extra) $(man1_paths); \
+	 do echo $$i; done) | LC_ALL=C sort > $@+
+	cmp $@+ $@ || mv $@+ $@
+	$(RM) $@+
+
+NEWS: GIT-VERSION-FILE
+	$(RAKE) -s news_rdoc > $@+
+	mv $@+ $@
+
+SINCE =
+ChangeLog: LOG_VERSION = \
+  $(shell git rev-parse -q "$(GIT_VERSION)" >/dev/null 2>&1 && \
+          echo $(GIT_VERSION) || git describe)
+ifneq ($(SINCE),)
+ChangeLog: log_range = v$(SINCE)..$(LOG_VERSION)
+endif
+ChangeLog: GIT-VERSION-FILE
+	@echo "ChangeLog from $(GIT_URL) ($(log_range))" > $@+
+	@echo >> $@+
+	git log $(log_range) | sed -e 's/^/    /' >> $@+
+	mv $@+ $@
+
+news_atom := http://zbatery.bogomip.org/NEWS.atom.xml
+cgit_atom := http://git.bogomips.org/cgit/zbatery.git/atom/?h=master
+atom = <link rel="alternate" title="Atom feed" href="$(1)" \
+             type="application/atom+xml"/>
+
+# using rdoc 2.4.1+
+doc: .document NEWS ChangeLog
+	for i in $(man1_bins); do > $$i; done
+	rdoc -Na -t "$(shell sed -ne '1s/^= //p' README)"
+	install -m644 COPYING doc/COPYING
+	install -m644 $(shell grep '^[A-Z]' .document)  doc/
+	$(MAKE) -C Documentation install-html install-man
+	install -m644 $(man1_paths) doc/
+	cd doc && for i in $(base_bins); do \
+	  sed -e '/"documentation">/r man1/'$$i'.1.html' \
+		< $${i}_1.html > tmp && mv tmp $${i}_1.html; done
+	$(RUBY) -i -p -e \
+	  '$$_.gsub!("</title>",%q{\&$(call atom,$(cgit_atom))})' \
+	  doc/ChangeLog.html
+	$(RUBY) -i -p -e \
+	  '$$_.gsub!("</title>",%q{\&$(call atom,$(news_atom))})' \
+	  doc/NEWS.html doc/README.html
+	$(RAKE) -s news_atom > doc/NEWS.atom.xml
+	cd doc && ln README.html tmp && mv tmp index.html
+	$(RM) $(man1_bins)
+
+ifneq ($(VERSION),)
+rfproject := rainbows
+rfpackage := zbatery
+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):
+	$(RAKE) -s release_changes > $@+
+	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
+$(release_notes):
+	GIT_URL=$(GIT_URL) $(RAKE) -s 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 c `cat .manifest` | (cd $(distdir) && tar x)
+	cd pkg && tar c $(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) $(pkggem)
+	# push gem to Gemcutter
+	gem push $(pkggem)
+	# in case of gem downloads from RubyForge releases page
+	-rubyforge add_file \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkggem)
+else
+gem install-gem: GIT-VERSION-FILE
+	$(MAKE) $@ VERSION=$(GIT_VERSION)
+endif
+
+all:: test
+test:
+	$(MAKE) -C t
+
+.PHONY: .FORCE-GIT-VERSION-FILE doc manifest man test

data/LICENSE

@@ -0,0 +1,55 @@
+Zbatery is copyrighted Free Software by all contributors, see the
+logs in revision control for all of them.  You can redistribute it
+and/or modify it under either the terms of the
+{GPL2}[http://www.gnu.org/licenses/gpl-2.0.txt] (see link:COPYING) or
+the conditions below:
+
+  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/NEWS

@@ -0,0 +1,4 @@
+=== 0.0.0 / 2009-12-10 08:49 UTC
+
+  Initial release of Rainbows! without fork()
+

data/README

@@ -0,0 +1,130 @@
+= Zbatery: Rack HTTP server without a fork stuck in it
+
+Zbatery is an HTTP server for Rack applications on systems that either
+do not support fork(), or have no memory (nor need) to run the
+master/worker model.  It is based on Rainbows! (which is based on
+Unicorn (which is based on Mongrel)) and inherits parts of each.
+Zbatery supports your choice of all the thread/fiber/event/actor-based
+concurrency models and Rack middleware that Rainbows! supports (or will
+ever support) in a single process.
+
+Zbatery will still exploit certain features of Unix for transparent
+upgrades, log reopening, and graceful stops, but does not rely on them
+for basic functionality.
+
+== Features
+
+* Designed for {Rack}[http://rack.rubyforge.org/], the standard for
+  modern Ruby HTTP applications.
+
+* Configuration files are compatible with Rainbows!, a superset
+  of the Unicorn
+  {DSL}[http://unicorn.bogomips.org/Unicorn/Configurator.html].
+
+* Inherits all features and concurrency models Rainbows! supports
+  (and ever will support): http://rainbows.rubyforge.org/Summary.html
+
+* -Untested- Works under operating systems that don't support signals,
+  pipe and fork().  Unicorn 0.95.2+ has rake-compiler support, so
+  compiling the HTTP parser should be easier at least.
+
+* -Untested- HTML 5 Web Sockets support
+
+== License
+
+Zbatery is copyright 2009 by all contributors (see logs in git).
+It is ultimately based on Mongrel and carries the same license.
+
+Mongrel is copyright 2007 Zed A. Shaw and contributors. It is licensed
+under the Ruby license and the GPL2. See the included LICENSE file for
+details.
+
+Zbatery is 100% Free Software.
+
+== Install
+
+You may download the tarball from the Rainbows project page on Rubyforge
+and run setup.rb after unpacking it:
+
+http://rubyforge.org/frs/?group_id=8977
+
+You may also install it via RubyGems on Gemcutter:
+
+  gem install zbatery
+
+== Usage
+
+=== for Rack applications
+
+In APP_ROOT (where config.ru is located), run:
+
+  zbatery
+
+Zbatery will bind to all interfaces on TCP port 8080 by default.
+
+=== Configuration File(s)
+
+Zbatery will look for the config.ru file used by rackup in APP_ROOT.
+
+For deployments, it can use a config file for Unicorn and
+Rainbows!-specific options specified by the +--config-file/-c+
+command-line switch.  Zbatery accepts all options found in
+{Unicorn::Configurator}[http://unicorn.bogomips.org/Unicorn/Configurator.html]
+as well as the "Rainbows!" block, so you can have the following in your
+config file:
+
+    Rainbows! do
+      use :FiberSpawn
+      worker_connections 400
+    end
+
+See the Rainbows! configuration
+{documentation}[http://rainbows.rubyforge.org/Rainbows.html#M000001]
+for more details.
+
+== Disclaimer
+
+There is NO WARRANTY whatsoever if anything goes wrong, but let us know
+and we'll try our best to fix it.
+
+This project may be temporary and may eventually have its name encoded
+with uncrackable ROT13 encryption leaving you with no way to upgrade.
+
+== Development
+
+Most of the work is done in Rainbows!, Zbatery is just a shim to
+allow access to Rainbows! without requiring fork() or signals.
+
+You can get the latest source via git from the following locations:
+
+  git://git.bogomips.org/zbatery.git
+  git://repo.or.cz/zbatery.git (mirror)
+
+You may browse the code from the web and download the latest snapshot
+tarballs here:
+
+* http://git.bogomips.org/cgit/zbatery.git (cgit)
+* http://repo.or.cz/w/zbatery.git (gitweb)
+
+Inline patches (from "git format-patch") 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 Zbatery patches.
+
+== Tests
+
+There currently are no tests specific to Zbatery.  Keep in mind that
+Zbatery is only a small shim to drive Rainbows! (and Unicorn)
+underneath.  Rainbows! and Unicorn both have extensive (but very
+UNIX-specific) test suites.
+
+== Contact
+
+All feedback (bug reports, user/development dicussion, patches, pull
+requests) go to the mailing list/newsgroup.  We are currently
+borrowing the Rainbows! mailing list since most of our code (and
+problems) are related to Rainbows! mailto:rainbows-talk@rubyforge.org.

data/Rakefile

@@ -0,0 +1,158 @@
+# -*- encoding: binary -*-
+
+# most tasks are in the GNUmakefile which offers better parallelism
+
+def tags
+  timefmt = '%Y-%m-%dT%H:%M:%SZ'
+  @tags ||= `git tag -l`.split(/\n/).map do |tag|
+    if %r{\Av[\d\.]+\z} =~ tag
+      header, subject, body = `git cat-file tag #{tag}`.split(/\n\n/, 3)
+      header = header.split(/\n/)
+      tagger = header.grep(/\Atagger /).first
+      body ||= "initial"
+      {
+        :time => Time.at(tagger.split(/ /)[-2].to_i).utc.strftime(timefmt),
+        :tagger_name => %r{^tagger ([^<]+)}.match(tagger)[1].strip,
+        :tagger_email => %r{<([^>]+)>}.match(tagger)[1].strip,
+        :id => `git rev-parse refs/tags/#{tag}`.chomp!,
+        :tag => tag,
+        :subject => subject,
+        :body => body,
+      }
+    end
+  end.compact.sort { |a,b| b[:time] <=> a[:time] }
+end
+
+cgit_url = "http://git.bogomips.org/cgit/zbatery.git"
+git_url = ENV['GIT_URL'] || 'git://git.bogomips.org/zbatery.git'
+
+desc 'prints news as an Atom feed'
+task :news_atom do
+  require 'nokogiri'
+  new_tags = tags[0,10]
+  puts(Nokogiri::XML::Builder.new do
+    feed :xmlns => "http://www.w3.org/2005/Atom" do
+      id! "http://zbatery.bogomip.org/NEWS.atom.xml"
+      title "Zbatery news"
+      subtitle "HTTP server without a fork stuck in it"
+      link! :rel => 'alternate', :type => 'text/html',
+            :href => 'http://zbatery.bogomip.org/NEWS.html'
+      updated(new_tags.empty? ? "1970-01-01T00:00:00Z" : new_tags.first[:time])
+      new_tags.each do |tag|
+        entry do
+          title tag[:subject]
+          updated tag[:time]
+          published tag[:time]
+          author {
+            name tag[:tagger_name]
+            email tag[:tagger_email]
+          }
+          url = "#{cgit_url}/tag/?id=#{tag[:tag]}"
+          link! :rel => "alternate", :type => "text/html", :href =>url
+          id! url
+          message_only = tag[:body].split(/\n.+\(\d+\):\n {6}/s).first.strip
+          content({:type =>:text}, message_only)
+          content(:type =>:xhtml) { pre tag[:body] }
+        end
+      end
+    end
+  end.to_xml)
+end
+
+desc 'prints RDoc-formatted news'
+task :news_rdoc do
+  tags.each do |tag|
+    time = tag[:time].tr!('T', ' ').gsub!(/:\d\dZ/, ' UTC')
+    puts "=== #{tag[:tag].sub(/^v/, '')} / #{time}"
+    puts ""
+
+    body = tag[:body]
+    puts tag[:body].gsub(/^/sm, "  ").gsub(/[ \t]+$/sm, "")
+    puts ""
+  end
+end
+
+desc "print release changelog for Rubyforge"
+task :release_changes do
+  version = ENV['VERSION'] or abort "VERSION= needed"
+  version = "v#{version}"
+  vtags = tags.map { |tag| tag[:tag] =~ /\Av/ and tag[:tag] }.sort
+  prev = vtags[vtags.index(version) - 1]
+  if prev
+    system('git', 'diff', '--stat', prev, version) or abort $?
+    puts ""
+    system('git', 'log', "#{prev}..#{version}") or abort $?
+  else
+    system('git', 'log', version) or abort $?
+  end
+end
+
+desc "print release notes for Rubyforge"
+task :release_notes do
+  require 'rubygems'
+
+  spec = Gem::Specification.load('zbatery.gemspec')
+  puts spec.description.strip
+  puts ""
+  puts "* #{spec.homepage}"
+  puts "* #{spec.email}"
+  puts "* #{git_url}"
+
+  _, _, body = `git cat-file tag v#{spec.version}`.split(/\n\n/, 3)
+  print "\nChanges:\n\n"
+  puts body
+end
+
+desc "read news article from STDIN and post to rubyforge"
+task :publish_news do
+  require 'rubyforge'
+  IO.select([STDIN], nil, nil, 1) or abort "E: news must be read from stdin"
+  msg = STDIN.readlines
+  subject = msg.shift
+  blank = msg.shift
+  blank == "\n" or abort "no newline after subject!"
+  subject.strip!
+  body = msg.join("").strip!
+
+  rf = RubyForge.new.configure
+  rf.login
+  rf.post_news('rainbows', subject, body)
+end
+
+desc "post to RAA"
+task :raa_update do
+  require 'rubygems'
+  require 'net/http'
+  require 'net/netrc'
+  rc = Net::Netrc.locate('zbatery-raa') or abort "~/.netrc not found"
+  password = rc.password
+
+  s = Gem::Specification.load('zbatery.gemspec')
+  desc = [ s.description.strip ]
+  desc << ""
+  desc << "* #{s.email}"
+  desc << "* #{git_url}"
+  desc << "* #{cgit_url}"
+  desc = desc.join("\n")
+  uri = URI.parse('http://raa.ruby-lang.org/regist.rhtml')
+  form = {
+    :name => s.name,
+    :short_description => s.summary,
+    :version => s.version.to_s,
+    :status => 'experimental',
+    :owner => s.authors.first,
+    :email => s.email,
+    :category_major => 'Library',
+    :category_minor => 'Web',
+    :url => s.homepage,
+    :download => "http://rubyforge.org/frs/?group_id=8977",
+    :license => "Ruby's",
+    :description_style => 'Plain',
+    :description => desc,
+    :pass => password,
+    :submit => "Update",
+  }
+  res = Net::HTTP.post_form(uri, form)
+  p res
+  puts res.body
+end

data/bin/zbatery

@@ -0,0 +1,166 @@
+#!/usr/bin/ruby
+# -*- encoding: binary -*-
+require 'unicorn/launcher'
+require 'zbatery'
+require 'optparse'
+
+ENV["RACK_ENV"] ||= "development"
+daemonize = false
+listeners = []
+options = { :listeners => listeners }
+host, port = Unicorn::Const::DEFAULT_HOST, Unicorn::Const::DEFAULT_PORT
+set_listener = false
+
+opts = OptionParser.new("", 24, '  ') do |opts|
+  opts.banner = "Usage: #{File.basename($0)} " \
+                "[ruby options] [zbatery options] [rackup config file]"
+
+  opts.separator "Ruby options:"
+
+  lineno = 1
+  opts.on("-e", "--eval LINE", "evaluate a LINE of code") do |line|
+    eval line, TOPLEVEL_BINDING, "-e", lineno
+    lineno += 1
+  end
+
+  opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") do
+    $DEBUG = true
+  end
+
+  opts.on("-w", "--warn", "turn warnings on for your script") do
+    $-w = true
+  end
+
+  opts.on("-I", "--include PATH",
+          "specify $LOAD_PATH (may be used more than once)") do |path|
+    $LOAD_PATH.unshift(*path.split(/:/))
+  end
+
+  opts.on("-r", "--require LIBRARY",
+          "require the library, before executing your script") do |library|
+    require library
+  end
+
+  opts.separator "Zbatery options:"
+
+  # some of these switches exist for rackup command-line compatibility,
+
+  opts.on("-o", "--host HOST",
+          "listen on HOST (default: #{Unicorn::Const::DEFAULT_HOST})") do |h|
+    host = h
+    set_listener = true
+  end
+
+  opts.on("-p", "--port PORT",
+          "use PORT (default: #{Unicorn::Const::DEFAULT_PORT})") do |p|
+    port = p.to_i
+    set_listener = true
+  end
+
+  opts.on("-E", "--env ENVIRONMENT",
+          "use ENVIRONMENT for defaults (default: development)") do |e|
+    ENV["RACK_ENV"] = e
+  end
+
+  opts.on("-D", "--daemonize", "run daemonized in the background") do |d|
+    daemonize = d ? true : false
+  end
+
+  opts.on("-P", "--pid FILE", "DEPRECATED") do |f|
+    warn %q{Use of --pid/-P is strongly discouraged}
+    warn %q{Use the 'pid' directive in the Zbatery config file instead}
+    options[:pid] = f
+  end
+
+  opts.on("-s", "--server SERVER",
+          "this flag only exists for compatibility") do |s|
+    warn "-s/--server only exists for compatibility with rackup"
+  end
+
+  # Zbatery/Unicorn-specific stuff
+  opts.on("-l", "--listen {HOST:PORT|PATH}",
+          "listen on HOST:PORT or PATH",
+          "this may be specified multiple times",
+          "(default: #{Unicorn::Const::DEFAULT_LISTEN})") do |address|
+    listeners << address
+  end
+
+  opts.on("-c", "--config-file FILE", "Unicorn-specific config file") do |f|
+    options[:config_file] = f
+  end
+
+  # I'm avoiding Unicorn-specific config options on the command-line.
+  # IMNSHO, config options on the command-line are redundant given
+  # config files and make things unnecessarily complicated with multiple
+  # places to look for a config option.
+
+  opts.separator "Common options:"
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts.to_s.gsub(/^.*DEPRECATED.*$/s, '')
+    exit
+  end
+
+  opts.on_tail("-v", "--version", "Show version") do
+    puts "zbatery v#{Zbatery::VERSION}"
+    exit
+  end
+
+  opts.parse! ARGV
+end
+
+config = ARGV[0] || "config.ru"
+abort "configuration file #{config} not found" unless File.exist?(config)
+
+if config =~ /\.ru$/
+  # parse embedded command-line options in config.ru comments
+  if File.open(config, "rb") { |fp| fp.sysread(fp.stat.size) } =~ /^#\\(.*)/
+    opts.parse! $1.split(/\s+/)
+  end
+end
+
+require 'pp' if $DEBUG
+
+app = lambda do ||
+  # require Rack as late as possible in case $LOAD_PATH is modified
+  # in config.ru or command-line
+  inner_app = case config
+  when /\.ru$/
+    raw = File.open(config, "rb") { |fp| fp.sysread(fp.stat.size) }
+    raw.sub!(/^__END__\n.*/, '')
+    eval("Rack::Builder.new {(#{raw}\n)}.to_app", nil, config)
+  else
+    require config
+    Object.const_get(File.basename(config, '.rb').capitalize)
+  end
+  pp({ :inner_app => inner_app }) if $DEBUG
+  case ENV["RACK_ENV"]
+  when "development"
+    Rack::Builder.new do
+      use Rack::CommonLogger, $stderr
+      use Rack::ShowExceptions
+      use Rack::Lint
+      run inner_app
+    end.to_app
+  when "deployment"
+    Rack::Builder.new do
+      use Rack::CommonLogger, $stderr
+      run inner_app
+    end.to_app
+  else
+    inner_app
+  end
+end
+
+listeners << "#{host}:#{port}" if set_listener
+
+if $DEBUG
+  pp({
+    :zbatery_options => options,
+    :app => app,
+    :daemonize => daemonize,
+  })
+end
+
+Unicorn::Launcher.daemonize! if daemonize
+Zbatery.run(app, options)