0.37.0.pre2

---

Fixes #2

This is my first patch for JRuby, so any feedback would be appreciated. The specs do not run (Ill file a separate issue) but I am able to successfully start up & run the contents of a `Procfile`.

I based this patch on [launchys JRuby support](https://github.com/copiousfreetime/launchy/pull/10) and I too confirmed these changes did not break 1.8.7, 1.9.2 or 1.9.3.

.env

@@ -0,0 +1 @@
+FOO=bar

.gitignore

@@ -1,7 +1,8 @@
-.bundle
-coverage
-example/log/*
-man/*.?
-man/*.html
-man/*.markdown
-pkg
+/.bundle
+/coverage
+/example/log/*
+/man/*.html
+/man/*.markdown
+/pkg
+/tags
+/vendor

.travis.yml

@@ -0,0 +1,14 @@
+script: bundle exec rake spec
+
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+
+notifications:
+  email: false
+  webhooks:
+    on_success: always
+    on_failure: always
+    urls:
+      - https://dx-helper.herokuapp.com/travis

Changelog

@@ -0,0 +1,11 @@
+0.26.1 12/05/2011 6160246da0fafe9cf8fde188d94bbc6babc667dc
+==========================================================
+
+Merge pull request #103 from csquared/load_env_from_irb   [David Dollar]
+refactor load_env to apply_environment   [Chris Continanza]
+rename load! to load_env!   [Chris Continanza]
+use ./.env as default   [Chris Continanza]
+load contents from env file   [Chris Continanza]
+refactor engine to expose env methods   [Chris Continanza]
+disable email notifications   [David Dollar]
+add travis config   [David Dollar]

Gemfile

@@ -1,16 +1,19 @@
 source "http://rubygems.org"
 
+gemspec
+
+platform :jruby do
+  gem "posix-spawn", "~> 0.3.6"
+end
+
 group :development do
   gem 'parka'
   gem 'rake'
-end
-
-group :test do
-  gem 'fakefs', '~> 0.2.1'
+  gem 'ronn'
+  gem 'fakefs', '~> 0.3.2'
   gem 'rcov',   '~> 0.9.8'
-  gem 'rr',     '~> 0.10.11'
-  gem 'rspec',  '~> 2.0.0.beta.19'
+  gem 'rr',     '~> 1.0.2'
+  gem 'rspec',  '~> 2.0'
+  gem 'aws-s3'
+  gem "rubyzip"
 end
-
-gem 'term-ansicolor', '~> 1.0.5'
-gem 'thor',           '~> 0.13.6'

Gemfile.lock

@@ -1,37 +1,67 @@
+PATH
+  remote: .
+  specs:
+    foreman (0.37.0.pre2)
+      term-ansicolor (~> 1.0.7)
+      thor (>= 0.13.6)
+
 GEM
   remote: http://rubygems.org/
   specs:
-    diff-lcs (1.1.2)
-    fakefs (0.2.1)
+    aws-s3 (0.6.2)
+      builder
+      mime-types
+      xml-simple
+    builder (3.0.0)
+    crack (0.1.8)
+    diff-lcs (1.1.3)
+    fakefs (0.3.2)
+    hpricot (0.8.2)
+    hpricot (0.8.2-java)
     mime-types (1.16)
-    parka (0.3.1)
+    mustache (0.11.2)
+    parka (0.6.2)
+      crack
       rest-client
       thor
-    rake (0.8.7)
+    posix-spawn (0.3.6)
+    rake (0.9.2.2)
     rcov (0.9.8)
-    rest-client (1.6.0)
+    rcov (0.9.8-java)
+    rdiscount (1.6.5)
+    rest-client (1.6.1)
       mime-types (>= 1.16)
-    rr (0.10.11)
-    rspec (2.0.0.beta.19)
-      rspec-core (= 2.0.0.beta.19)
-      rspec-expectations (= 2.0.0.beta.19)
-      rspec-mocks (= 2.0.0.beta.19)
-    rspec-core (2.0.0.beta.19)
-    rspec-expectations (2.0.0.beta.19)
-      diff-lcs (>= 1.1.2)
-    rspec-mocks (2.0.0.beta.19)
-    term-ansicolor (1.0.5)
-    thor (0.13.8)
+    ronn (0.7.3)
+      hpricot (>= 0.8.2)
+      mustache (>= 0.7.0)
+      rdiscount (>= 1.5.8)
+    rr (1.0.2)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    rubyzip (0.9.4)
+    term-ansicolor (1.0.7)
+    thor (0.14.6)
+    xml-simple (1.0.15)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
-  fakefs (~> 0.2.1)
+  aws-s3
+  fakefs (~> 0.3.2)
+  foreman!
   parka
+  posix-spawn (~> 0.3.6)
   rake
   rcov (~> 0.9.8)
-  rr (~> 0.10.11)
-  rspec (~> 2.0.0.beta.19)
-  term-ansicolor (~> 1.0.5)
-  thor (~> 0.13.6)
+  ronn
+  rr (~> 1.0.2)
+  rspec (~> 2.0)
+  rubyzip

README.markdown

@@ -1,4 +1,50 @@
-Foreman
-=======
+# Foreman
 
-See the [man page](http://ddollar.github.com/foreman) for usage.
+## Installation
+
+* Rubygems
+
+    gem install foreman
+
+* OSX
+
+    http://assets.foreman.io/foreman/foreman.pkg
+
+* Standalone Tarball
+
+    http://assets.foreman.io/foreman/foreman.tgz
+
+## Description
+
+http://blog.daviddollar.org/2011/05/06/introducing-foreman.html
+
+## Manual
+
+* [man page](http://ddollar.github.com/foreman)
+* [wiki](http://github.com/ddollar/foreman/wiki)
+
+## Authorship
+
+Created by David Dollar
+
+Patches contributed by:
+
+* Adam Wiggins
+* Dan Peterson
+* Hunter Nield
+* Jay Zeschin
+* Keith Rarick
+* Khaja Minhajuddin
+* Matt Haynes
+* Michael van Rooijen
+* Mike Javorski
+* Nathan L Smith
+* Nick Zadrozny
+* Ricardo Chimal, Jr
+* Thom May
+* clifff
+* Greg Reinacker
+
+## License
+
+MIT

Rakefile

@@ -1,7 +1,3 @@
-require "rubygems"
-require "bundler"
-Bundler.setup
-
 require "rake"
 require "rspec"
 require "rspec/core/rake_task"
@@ -13,7 +9,7 @@ task :default => :spec
 task :release => :man
 
 desc "Run all specs"
-Rspec::Core::RakeTask.new(:spec) do |t|
+RSpec::Core::RakeTask.new(:spec) do |t|
   t.pattern = 'spec/**/*_spec.rb'
 end
 
@@ -22,10 +18,10 @@ task :rcov => "rcov:build" do
   %x{ open coverage/index.html }
 end
 
-Rspec::Core::RakeTask.new("rcov:build") do |t|
+RSpec::Core::RakeTask.new("rcov:build") do |t|
   t.pattern = 'spec/**/*_spec.rb'
   t.rcov = true
-  t.rcov_opts = [ "--exclude", Gem.default_dir , "--exclude", "spec" ]
+  t.rcov_opts = [ "--exclude", ".bundle", "--exclude", "spec" ]
 end
 
 desc 'Build the manual'
@@ -33,19 +29,159 @@ task :man do
   ENV['RONN_MANUAL']  = "Foreman Manual"
   ENV['RONN_ORGANIZATION'] = "Foreman #{Foreman::VERSION}"
   sh "ronn -w -s toc -r5 --markdown man/*.ronn"
+end
+
+desc "Commit the manual to git"
+task "man:commit" => :man do
   sh "git add README.markdown"
   sh "git commit -m 'update readme' || echo 'nothing to commit'"
 end
 
-task :pages => :man do
+desc "Generate the Github docs"
+task :pages => "man:commit" do
   sh %{
     cp man/foreman.1.html /tmp/foreman.1.html
     git checkout gh-pages
     rm ./index.html
     cp /tmp/foreman.1.html ./index.html
     git add -u index.html
-    git commit -m "rebuilding man page"
+    git commit -m "saving man page to github docs"
     git push origin -f gh-pages
     git checkout master
   }
 end
+
+## dist
+
+require "erb"
+require "fileutils"
+require "tmpdir"
+
+def assemble(source, target, perms=0644)
+  FileUtils.mkdir_p(File.dirname(target))
+  File.open(target, "w") do |f|
+    f.puts ERB.new(File.read(source)).result(binding)
+  end
+  File.chmod(perms, target)
+end
+
+def assemble_distribution(target_dir=Dir.pwd)
+  distribution_files.each do |source|
+    target = source.gsub(/^#{project_root}/, target_dir)
+    FileUtils.mkdir_p(File.dirname(target))
+    FileUtils.cp(source, target)
+  end
+end
+
+GEM_BLACKLIST = %w( bundler foreman )
+
+def assemble_gems(target_dir=Dir.pwd)
+  lines = %x{ bundle show }.strip.split("\n")
+  raise "error running bundler" unless $?.success?
+
+  %x{ env BUNDLE_WITHOUT="development:test" bundle show }.split("\n").each do |line|
+    if line =~ /^  \* (.*?) \((.*?)\)/
+      next if GEM_BLACKLIST.include?($1)
+      puts "vendoring: #{$1}-#{$2}"
+      gem_dir = %x{ bundle show #{$1} }.strip
+      FileUtils.mkdir_p "#{target_dir}/vendor/gems"
+      %x{ cp -R "#{gem_dir}" "#{target_dir}/vendor/gems" }
+    end
+  end.compact
+end
+
+def beta?
+  Foreman::VERSION.to_s =~ /pre/
+end
+
+def clean(file)
+  rm file if File.exists?(file)
+end
+
+def distribution_files(type=nil)
+  require "foreman/distribution"
+  base_files = Foreman::Distribution.files
+  type_files = type ?
+    Dir[File.expand_path("../dist/resources/#{type}/**/*", __FILE__)] :
+    []
+  base_files.concat(type_files)
+end
+
+def mkchdir(dir)
+  FileUtils.mkdir_p(dir)
+  Dir.chdir(dir) do |dir|
+    yield(File.expand_path(dir))
+  end
+end
+
+def pkg(filename)
+  File.expand_path("../pkg/#{filename}", __FILE__)
+end
+
+def project_root
+  File.dirname(__FILE__)
+end
+
+def resource(name)
+  File.expand_path("../dist/resources/#{name}", __FILE__)
+end
+
+def s3_connect
+  return if @s3_connected
+
+  require "aws/s3"
+
+  unless ENV["DAVID_RELEASE_ACCESS"] && ENV["DAVID_RELEASE_SECRET"]
+    puts "please set DAVID_RELEASE_ACCESS and DAVID_RELEASE_SECRET in your environment"
+    exit 1
+  end
+
+  AWS::S3::Base.establish_connection!(
+    :access_key_id => ENV["DAVID_RELEASE_ACCESS"],
+    :secret_access_key => ENV["DAVID_RELEASE_SECRET"]
+  )
+
+  @s3_connected = true
+end
+
+def store(package_file, filename, bucket="assets.foreman.io")
+  s3_connect
+  puts "storing: #{filename}"
+  AWS::S3::S3Object.store(filename, File.open(package_file), bucket, :access => :public_read)
+end
+
+def tempdir
+  Dir.mktmpdir do |dir|
+    Dir.chdir(dir) do
+      yield(dir)
+    end
+  end
+end
+
+def version
+  require "foreman/version"
+  Foreman::VERSION
+end
+
+Dir[File.expand_path("../dist/**/*.rake", __FILE__)].each do |rake|
+  import rake
+end
+
+task :changelog do
+  timestamp = Time.now.utc.strftime('%m/%d/%Y')
+  sha = `git log | head -1`.split(' ').last
+  changelog = ["#{version} #{timestamp} #{sha}"]
+  changelog << ('=' * changelog[0].length)
+  changelog << ''
+
+  last_sha = `cat Changelog | head -1`.split(' ').last
+  shortlog = `git log #{last_sha}..HEAD --pretty=format:'%s   [%an]'`
+  changelog << shortlog.split("\n")
+  changelog.concat ['', '', '']
+
+  old_changelog = File.read('Changelog')
+  File.open('Changelog', 'w') do |file|
+    file.write(changelog.join("\n"))
+    file.write(old_changelog)
+  end
+end

bin/runner

@@ -0,0 +1,36 @@
+#!/bin/sh
+#
+#/ Usage: runner [-d <dir>] <command>
+#/
+#/ Run a command with exec, optionally changing directory first
+
+set -e
+
+error() {
+  echo $@ >&2
+  exit 1
+}
+
+usage() {
+  cat $0 | grep '^#/' | cut -c4-
+  exit
+}
+
+while getopts ":hd:" OPT; do
+  case $OPT in
+     d) cd $OPTARG ;;
+     h) usage ;;
+    \?) error "invalid option: -$OPTARG" ;;
+     :) error "option -$OPTARG requires an argument" ;;
+  esac
+done
+
+shift $((OPTIND-1))
+
+command=$1
+
+if [ "$1" == "" ]; then
+  usage
+fi
+
+exec $1

data/example/Procfile

@@ -0,0 +1,2 @@
+ticker: ruby ./ticker $PORT
+error:  ruby ./error

data/example/error

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+$stdout.sync = true
+
 puts "will error in 10s"
 sleep 5
 raise "Dying"

data/example/log/neverdie.log

@@ -0,0 +1,4 @@
+tick
+tick
+./never_die:6:in `sleep': Interrupt
+	from ./never_die:6

data/example/ticker

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$stdout.sync = true
+
+%w( SIGINT SIGTERM ).each do |signal|
+  trap(signal) do
+    puts "received #{signal} but i'm ignoring it!"
+  end
+end
+
+while true
+  puts "tick: #{ARGV.inspect} -- FOO:#{ENV["FOO"]}"
+  sleep 1
+end

data/export/bluepill/master.pill.erb

@@ -0,0 +1,27 @@
+Bluepill.application("<%= app %>", :foreground => false, :log_file => "/var/log/bluepill.log") do |app|
+
+  app.uid = "<%= user %>"
+  app.gid = "<%= user %>"
+
+<% engine.procfile.entries.each do |process| %>
+<% 1.upto(concurrency[process.name]) do |num| %>
+<% port = engine.port_for(process, num, options[:port]) %>
+  app.process("<%= process.name %>-<%=num%>") do |process|
+    process.start_command = "<%= process.command.gsub("$PORT", port.to_s) %>"
+
+    process.working_dir = "<%= engine.directory %>"
+    process.daemonize = true
+    process.environment = {"PORT" => "<%= port %>"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+
+    process.stdout = process.stderr = "<%= log_root %>/<%= app %>-<%= process.name %>-<%=num%>.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill -QUIT {{PID}}"
+    end
+
+    process.group = "<%= app %>-<%= process.name %>"
+  end
+<% end %>
+<% end %>
+end

data/export/runit/log_run.erb

@@ -0,0 +1,7 @@
+#!/bin/sh
+set -e
+
+LOG=<%= log_root %>/<%= process.name %>-<%= num %>
+
+test -d "$LOG" || mkdir -p m2750 "$LOG" && chown <%= user %> "$LOG"
+exec chpst -u <%= user %> svlogd "$LOG"

data/export/runit/run.erb

@@ -0,0 +1,3 @@
+#!/bin/sh
+cd <%= engine.directory %>
+exec chpst -u <%= user %> -e <%= process_env_directory %> <%= process.command %>

data/export/upstart/process.conf.erb

@@ -0,0 +1,5 @@
+start on starting <%= app %>-<%= process.name %>
+stop on stopping <%= app %>-<%= process.name %>
+respawn
+
+exec su - <%= user %> -c 'cd <%= engine.directory %>; export PORT=<%= port %>;<% engine.environment.each_pair do |var,env| %> export <%= var.upcase %>=<%= env %>; <% end %> <%= process.command %> >> <%= log_root %>/<%=process.name%>-<%=num%>.log 2>&1'

dist/deb.rake

@@ -0,0 +1,48 @@
+file pkg("/apt-#{version}/foreman-#{version}.deb") => distribution_files("deb") do |t|
+  mkchdir(File.dirname(t.name)) do
+    mkchdir("usr/local/foreman") do
+      assemble_distribution
+      assemble_gems
+      assemble resource("deb/foreman"), "bin/foreman", 0755
+      File.chmod 0755, "bin/runner"
+    end
+
+    assemble resource("deb/control"), "control"
+    assemble resource("deb/postinst"), "postinst"
+
+    sh "tar czvf data.tar.gz usr/local/foreman --owner=root --group=root"
+    sh "tar czvf control.tar.gz control postinst"
+
+    File.open("debian-binary", "w") do |f|
+      f.puts "2.0"
+    end
+
+    deb = File.basename(t.name)
+
+    sh "ar -r #{t.name} debian-binary control.tar.gz data.tar.gz"
+
+    touch "Sources"
+    sh "apt-ftparchive packages . > Packages"
+    sh "gzip -c Packages > Packages.gz"
+    sh "apt-ftparchive release . > Release"
+    sh "gpg -abs -u 0F1B0520 -o Release.gpg Release"
+  end
+end
+
+desc "Build a .deb package"
+task "deb:build" => pkg("/apt-#{version}/foreman-#{version}.deb")
+
+desc "Remove build artifacts for .deb"
+task "deb:clean" do
+  clean pkg("foreman-#{version}.deb")
+  FileUtils.rm_rf("pkg/apt-#{version}") if Dir.exists?("pkg/apt-#{version}")
+end
+
+desc "Publish .deb to S3."
+task "deb:release" => "deb:build" do |t|
+  Dir["pkg/apt-#{version}/*"].each do |file|
+    unless File.directory?(file)
+      store file, "apt/#{File.basename(file)}"
+    end
+  end
+end

dist/gem.rake

@@ -0,0 +1,14 @@
+file pkg("foreman-#{version}.gem") => distribution_files do |t|
+  sh "gem build foreman.gemspec"
+  sh "mv foreman-#{version}.gem #{t.name}"
+end
+
+task "gem:build" => pkg("foreman-#{version}.gem")
+
+task "gem:clean" do
+  clean pkg("foreman-#{version}.gem")
+end
+
+task "gem:release" => "gem:build" do |t|
+  sh "parka push -f #{pkg("foreman-#{version}.gem")}"
+end

dist/jruby.rake

@@ -0,0 +1,14 @@
+file pkg("foreman-#{version}-jruby.gem") => distribution_files do |t|
+  sh "env PLATFORM=jruby gem build foreman.gemspec"
+  sh "mv foreman-#{version}-java.gem #{t.name}"
+end
+
+task "jruby:build" => pkg("foreman-#{version}-jruby.gem")
+
+task "jruby:clean" do
+  clean pkg("foreman-#{version}-jruby.gem")
+end
+
+task "jruby:release" => "jruby:build" do |t|
+  sh "parka push -f #{pkg("foreman-#{version}-jruby.gem")}"
+end

dist/pkg.rake

@@ -0,0 +1,52 @@
+require "erb"
+
+file pkg("foreman-#{version}.pkg") => distribution_files do |t|
+  tempdir do |dir|
+    mkchdir("foreman") do
+      assemble_distribution
+      assemble_gems
+      assemble resource("pkg/foreman"), "bin/foreman", 0755
+    end
+
+    kbytes = %x{ du -ks foreman | cut -f 1 }
+    num_files = %x{ find foreman | wc -l }
+
+    mkdir_p "pkg"
+    mkdir_p "pkg/Resources"
+    mkdir_p "pkg/foreman-#{version}.pkg"
+
+    dist = File.read(resource("pkg/Distribution.erb"))
+    dist = ERB.new(dist).result(binding)
+    File.open("pkg/Distribution", "w") { |f| f.puts dist }
+
+    dist = File.read(resource("pkg/PackageInfo.erb"))
+    dist = ERB.new(dist).result(binding)
+    File.open("pkg/foreman-#{version}.pkg/PackageInfo", "w") { |f| f.puts dist }
+
+    mkdir_p "pkg/foreman-#{version}.pkg/Scripts"
+    cp resource("pkg/postinstall"), "pkg/foreman-#{version}.pkg/Scripts/postinstall"
+    chmod 0755, "pkg/foreman-#{version}.pkg/Scripts/postinstall"
+
+    sh %{ mkbom -s foreman pkg/foreman-#{version}.pkg/Bom }
+
+    Dir.chdir("foreman") do
+      sh %{ pax -wz -x cpio . > ../pkg/foreman-#{version}.pkg/Payload }
+    end
+
+    sh %{ pkgutil --flatten pkg foreman-#{version}.pkg }
+
+    cp_r "foreman-#{version}.pkg", t.name
+  end
+end
+
+task "pkg:build" => pkg("foreman-#{version}.pkg")
+
+task "pkg:clean" do
+  clean pkg("foreman-#{version}.pkg")
+end
+
+task "pkg:release" => "pkg:build" do |t|
+  store pkg("foreman-#{version}.pkg"), "foreman/foreman-#{version}.pkg"
+  store pkg("foreman-#{version}.pkg"), "foreman/foreman-beta.pkg" if beta?
+  store pkg("foreman-#{version}.pkg"), "foreman/foreman.pkg" unless beta?
+end

dist/resources/deb/control

@@ -0,0 +1,12 @@
+Package: foreman
+Version: <%= version %>
+Section: main
+Priority: standard
+Architecture: all
+Depends: ruby1.9.1
+Maintainer: Heroku
+Description: Manage Procfile-based applications.
+ Foreman is a manager for Procfile-based applications. Its aim is to
+ abstract away the details of the Procfile format, and allow you to
+ either run your application directly or export it to some other
+ process management format.

dist/resources/deb/foreman

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby1.9.1
+
+# resolve bin path, ignoring symlinks
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+# add locally vendored gems to libpath
+gem_dir = File.expand_path("../../vendor/gems", bin_file)
+Dir["#{gem_dir}/**/lib"].each do |libdir|
+  $:.unshift libdir
+end
+
+# add self to libpath
+$:.unshift File.expand_path("../../lib", bin_file)
+
+require "foreman/cli"
+
+Foreman::CLI.start

dist/resources/deb/heroku-release-key.txt

@@ -0,0 +1,30 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v1.4.11 (Darwin)
+
+mQENBE5SfAEBCADLp056ZgfdtAMXLWpEuL9zY+dIHIY5qLQcDmUivjHLVE4l3Bi3
+Mn570K0W9rfk7fHBPEO2XJEDdjk8Bg6mWTAeGjdfZgZaL+qO9NjqQ5QmVR+vgp7s
+yxJYlfY+JYTZvl/JiDWGhuPHSPggXILCMf3SpqWMHGPqe/3RAK+CHCNv/94uaoS4
+vi4HQT+k4sRceiM8WqkSRYSoc7rzdDejZn+InCYFfR56VeSFF4G4I6neZs/q5T9d
+Ty2i5d0gZLaX/Iqc+3Dy0vDKClc0HUQJ6ajDPuUqKLHFUpqyuwfJij60+C3GMi8K
+ckRPti31EPFVzq3GPHU+GqA+e9j84WHr4uJ5ABEBAAG0L0hlcm9rdSBSZWxlYXNl
+IEVuZ2luZWVyaW5nIDxyZWxlYXNlQGhlcm9rdS5jb20+iQE4BBMBAgAiBQJOUnwB
+AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRDJJ+vgDxsFIChECAC9h4Ay
+Nx4AQFu85cjR9rijyBflPeVqi7Xhzd7IvLg2+kZSexlb2oidj7iVSMy+vy5tG9g9
+8Az/JqMCVjcZ7ltn60OGU8gIYpJqt6VmH3vfJBxXu/Sm9tym3UCYGVvMAN5Oq6yB
+HlQkQ8F3p0cW69PmF+fibkgo9RE0EYlBIt2rUHNilTGFS6vXGr5reFFp3/rRHq3k
+bixnUwFSqNujJgnBKDPwtSYKc4pMpnhuv88xEpLH7vU8NLXQZMitKQguV8XEmcsu
+43LXlsx5uVr239/XNW+h412gIHFDSzB/YuLWlVUXMfquC96z/wxMqWWZyskDNgr0
+WDdMgzK6CUfXSqQhuQENBE5SfAEBCADbnGKcXpdVauQpINQLtRnrT0BJIrIo1Yxv
+LQRb3G7RU+Eq6aHXwk9fSKa6nEv9RsmqiW874yODnr0d/DTUWMHT+jRvPHm1wlbE
+pGR1aPSo7GgkSUdaT6CVBN3JWZ2kVJGqohNoJMYbfVaWd/kpa/LiMFWzS8LfWT2K
+xiO2vIh4qBfeRCGR7s8rADCHuHJ0eibADrgqcRfdPrChB1JiYLeTdV4yRmSzJ7TM
+zWX7OVpGfIFLbCw9NeN65pI9ePs2mSPM7DYkhhKSXWMwJNXFzn1blOGiwAwKb48P
+a/QpE6TG3PQzbYyTTP0Td1XgKAHcprvbc89a/nAk3a+PJQ/MqvDzABEBAAGJAR8E
+GAECAAkFAk5SfAECGwwACgkQySfr4A8bBSD4mAgAnCT5WRiDl0259Px9Z9J9Wk8Z
+SxugDct2Yhzca4aw1Ou4cfaIFCDXzFlBzSJfqk0HoVhp9r2gzEPUCKnSjRDyxaMo
+wZCUtqigBua+z4NB4AWgeOl/2S06I2ki1K7pfl4piYcHtEThHamnhVPJ2Hi6HsHq
+mUU+8SxleHE4GCXmKkuvxelUq9jrhHikIkm1RoqFOPb9zV3WRy4YzVHQSYfHmfk0
+9kXlM/CS0sfNv2UKCX+5e6eFIZv0rdtpp6VEh0tsFmsIClY6Z9MX7bgp8MnUJpyk
+OeIzOzQgkb4aeT0Whl+EPcTeDZfqIhVBoNXupUanmWNppFcMngxfqG2NGi1vvQ==
+=aUAq
+-----END PGP PUBLIC KEY BLOCK-----

dist/resources/deb/postinst

@@ -0,0 +1,3 @@
+#!/bin/sh
+set -e
+ln -sf /usr/local/foreman/bin/foreman /usr/bin/foreman

dist/resources/pkg/Distribution.erb

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<installer-script minSpecVersion="1.000000" authoringTool="org.ruby-lang.rake" authoringToolVersion="0.8.7">
+  <title>Foreman</title>
+  <options customize="never" allow-external-scripts="no"/>
+  <domains enable_localSystem="true"/>
+  <script><![CDATA[
+    function needs_git() {
+      return (system.compareVersion(system.version.ProductVersion, "10.7.0") < 0);
+    }
+  ]]></script>
+  <choices-outline>
+    <line choice="git"/>
+    <line choice="foreman-<%= version %>"/>
+  </choices-outline>
+  <choice id="git" title="git" start_selected="false" start_enabled="false" selected="needs_git()" enabled="needs_git()">
+    <pkg-ref id="git.pkg" />
+  </choice>
+  <choice id="foreman-<%= version %>" title="foreman">
+    <pkg-ref id="io.foreman.installer"/>
+  </choice>
+  <pkg-ref id="io.foreman.installer" installKBytes="<%= kbytes %>" version="<%= version %>" auth="Root">#foreman-<%= version %>.pkg</pkg-ref>
+</installer-script>
+

dist/resources/pkg/PackageInfo.erb

@@ -0,0 +1,7 @@
+<pkg-info format-version="2" identifier="io.foreman.installer" version="<%= version %>" install-location="/usr/local/foreman" auth="root">
+  <payload installKBytes="<%= kbytes %>" numberOfFiles="<%= num_files %>"/>
+  <scripts>
+    <postinstall file="./postinstall"/>
+  </scripts>
+</pkg-info>
+

dist/resources/pkg/foreman

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+gem_dir = File.expand_path("../../vendor/gems", bin_file)
+  Dir["#{gem_dir}/**/lib"].each do |libdir|
+  $:.unshift libdir
+end
+
+$:.unshift File.expand_path("../../lib", bin_file)
+
+require "foreman/cli"
+
+Foreman::CLI.start

dist/resources/pkg/postinstall

@@ -0,0 +1,2 @@
+#!/bin/sh
+ln -sf /usr/local/foreman/bin/foreman /usr/bin/foreman

dist/resources/tgz/foreman

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+gem_dir = File.expand_path("../vendor/gems", bin_file)
+  Dir["#{gem_dir}/**/lib"].each do |libdir|
+  $:.unshift libdir
+end
+
+$:.unshift File.expand_path("../lib", bin_file)
+
+require "foreman/cli"
+
+Foreman::CLI.start

dist/tgz.rake

@@ -0,0 +1,24 @@
+file pkg("foreman-#{version}.tgz") => distribution_files do |t|
+  tempdir do |dir|
+    mkchdir("foreman") do
+      assemble_distribution
+      assemble_gems
+      rm_rf "bin"
+      assemble resource("tgz/foreman"), "foreman", 0755
+    end
+
+    sh "tar czvf #{t.name} foreman"
+  end
+end
+
+task "tgz:build" => pkg("foreman-#{version}.tgz")
+
+task "tgz:clean" do
+  clean pkg("foreman-#{version}.tgz")
+end
+
+task "tgz:release" => "tgz:build" do |t|
+  store pkg("foreman-#{version}.tgz"), "foreman/foreman-#{version}.tgz"
+  store pkg("foreman-#{version}.tgz"), "foreman/foreman-beta.tgz" if beta?
+  store pkg("foreman-#{version}.tgz"), "foreman/foreman.tgz" unless beta?
+end

example/ticker

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-while true
-  puts "tick: #{ARGV.inspect}"
-  sleep 1
-end

export/upstart/process.conf.erb

@@ -1,6 +0,0 @@
-start on starting <%= app %>-<%= process.name %>
-stop on stopping <%= app %>-<%= process.name %>
-respawn
-
-chdir <%= engine.directory %>
-exec su - <%= user %> -c 'export PORT=<%= port %>; <%= process.command %> >> <%= log_root %>/<%=process.name%>-<%=num%>.log 2>&1'

foreman.gemspec

@@ -1,13 +1,26 @@
-require "rubygems"
-require "parka/specification"
+$:.unshift File.expand_path("../lib", __FILE__)
+require "foreman/version"
 
-Parka::Specification.new do |gem|
+Gem::Specification.new do |gem|
   gem.name     = "foreman"
   gem.version  = Foreman::VERSION
-  gem.summary  = "Process manager for applications with multiple components"
-  gem.homepage = "http://github.com/ddollar/foreman"
 
-  gem.executables  = "foreman"
-  gem.files       << "man/foreman.1"
-  gem.files       << Dir["export/**/*"]
+  gem.author   = "David Dollar"
+  gem.email    = "ddollar@gmail.com"
+  gem.homepage = "http://github.com/ddollar/foreman"
+  gem.summary  = "Process manager for applications with multiple components"
+
+  gem.description = gem.summary
+
+  gem.executables = "foreman"
+  gem.files = Dir["**/*"].select { |d| d =~ %r{^(README|bin/|data/|ext/|lib/|spec/|test/)} }
+  gem.files << "man/foreman.1"
+
+  gem.add_dependency 'term-ansicolor', '~> 1.0.7'
+  gem.add_dependency 'thor',           '>= 0.13.6'
+
+  if ENV["PLATFORM"] == "jruby"
+    gem.add_dependency "posix-spawn", "~> 0.3.6"
+    gem.platform = Gem::Platform.new("java")
+  end
 end

lib/foreman.rb

@@ -1,8 +1,18 @@
-module Foreman
+require "foreman/version"
 
-  VERSION = "0.7.5"
+module Foreman
 
   class AppDoesNotExist < Exception; end
 
+  # load contents of env_file into ENV
+  def self.load_env!(env_file = './.env')
+    require 'foreman/engine'
+    Foreman::Engine.load_env!(env_file)
+  end
+
+  def self.runner
+    File.expand_path("../../bin/runner", __FILE__)
+  end
+
 end
 

lib/foreman/cli.rb

@@ -2,33 +2,40 @@ require "foreman"
 require "foreman/engine"
 require "foreman/export"
 require "thor"
+require "yaml"
 
 class Foreman::CLI < Thor
 
-  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: ./Procfile"
+  desc "start", "Start the application"
 
-  desc "start [PROCESS]", "Start the application, or a specific process"
+  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
+  class_option :app_root, :type => :string, :aliases => "-d", :desc => "Default: Procfile directory"
 
+  method_option :env,         :type => :string,  :aliases => "-e", :desc => "Specify an environment file to load, defaults to .env"
   method_option :port,        :type => :numeric, :aliases => "-p"
-  method_option :concurrency, :type => :string,  :aliases => "-c",
-    :banner => '"alpha=5,bar=3"'
+  method_option :concurrency, :type => :string,  :aliases => "-c", :banner => '"alpha=5,bar=3"'
 
-  def start(process=nil)
-    check_procfile!
-
-    if process
-      engine.execute(process, options)
-    else
-      engine.start(options)
+  class << self
+    # Hackery. Take the run method away from Thor so that we can redefine it.
+    def is_thor_reserved_word?(word, type)
+      return false if word == 'run'
+      super
     end
   end
 
+  def start
+    check_procfile!
+    engine.start
+  end
+
   desc "export FORMAT LOCATION", "Export the application to another process management format"
 
   method_option :app,         :type => :string,  :aliases => "-a"
   method_option :log,         :type => :string,  :aliases => "-l"
+  method_option :env,         :type => :string,  :aliases => "-e", :desc => "Specify an environment file to load, defaults to .env"
   method_option :port,        :type => :numeric, :aliases => "-p"
   method_option :user,        :type => :string,  :aliases => "-u"
+  method_option :template,    :type => :string,  :aliases => "-t"
   method_option :concurrency, :type => :string,  :aliases => "-c",
     :banner => '"alpha=5,bar=3"'
 
@@ -36,8 +43,10 @@ class Foreman::CLI < Thor
     check_procfile!
 
     formatter = case format
-      when "upstart" then Foreman::Export::Upstart
       when "inittab" then Foreman::Export::Inittab
+      when "upstart" then Foreman::Export::Upstart
+      when "bluepill" then Foreman::Export::Bluepill
+      when "runit"    then Foreman::Export::Runit
       else error "Unknown export format: #{format}."
     end
 
@@ -47,21 +56,43 @@ class Foreman::CLI < Thor
     error ex.message
   end
 
+  desc "check", "Validate your application's Procfile"
+
+  def check
+    error "no processes defined" unless engine.procfile.entries.length > 0
+    display "valid procfile detected (#{engine.procfile.process_names.join(', ')})"
+  end
+
+  desc "run COMMAND", "Run a command using your application's environment"
+
+  def run(*args)
+    engine.apply_environment!
+    begin
+      exec args.join(" ")
+    rescue Errno::EACCES
+      error "not executable: #{args.first}"
+    rescue Errno::ENOENT
+      error "command not found: #{args.first}"
+    end
+  end
+
 private ######################################################################
 
   def check_procfile!
-    error("Procfile does not exist.") unless File.exist?(procfile)
+    error("#{procfile} does not exist.") unless File.exist?(procfile)
   end
 
   def engine
-    @engine ||= Foreman::Engine.new(procfile)
+    @engine ||= Foreman::Engine.new(procfile, options)
   end
 
   def procfile
-    options[:procfile] || "./Procfile"
+    options[:procfile] || "Procfile"
   end
 
-private ######################################################################
+  def display(message)
+    puts message
+  end
 
   def error(message)
     puts "ERROR: #{message}"
@@ -72,4 +103,10 @@ private ######################################################################
     File.exist?(procfile)
   end
 
+  def options
+    original_options = super
+    return original_options unless File.exists?(".foreman")
+    defaults = YAML::load_file(".foreman") || {}
+    Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
+  end
 end

lib/foreman/distribution.rb

@@ -0,0 +1,9 @@
+module Foreman
+  module Distribution
+    def self.files
+      Dir[File.expand_path("../../../{bin,data,lib}/**/*", __FILE__)].select do |file|
+        File.file?(file)
+      end
+    end
+  end
+end

lib/foreman/engine.rb

@@ -1,167 +1,224 @@
 require "foreman"
 require "foreman/process"
+require "foreman/procfile"
 require "foreman/utils"
 require "pty"
 require "tempfile"
+require "timeout"
 require "term/ansicolor"
 require "fileutils"
+require "thread"
 
 class Foreman::Engine
 
   attr_reader :procfile
   attr_reader :directory
+  attr_reader :options
 
   extend Term::ANSIColor
 
-  COLORS = [ cyan, yellow, green, magenta, red ]
+  COLORS = [ cyan, yellow, green, magenta, red, blue,
+             intense_cyan, intense_yellow, intense_green, intense_magenta,
+             intense_red, intense_blue ]
 
-  def initialize(procfile)
-    @procfile  = read_procfile(procfile)
-    @directory = File.expand_path(File.dirname(procfile))
+  def initialize(procfile, options={})
+    @procfile  = Foreman::Procfile.new(procfile)
+    @directory = options[:app_root] || File.expand_path(File.dirname(procfile))
+    @options = options
+    @environment = read_environment_files(options[:env])
+    @output_mutex = Mutex.new
   end
 
-  def processes
-    @processes ||= begin
-      procfile.split("\n").inject({}) do |hash, line|
-        next if line.strip == ""
-        name, command = line.split(" ", 2)
-        process = Foreman::Process.new(name, command)
-        process.color = next_color
-        hash.update(process.name => process)
-      end
-    end
+  def self.load_env!(env_file)
+    @environment = read_environment_files(env_file)
+    apply_environment!
   end
 
-  def start(options={})
+  def start
     proctitle "ruby: foreman master"
+    termtitle "#{File.basename(@directory)} - foreman"
 
-    processes.each do |name, process|
-      fork process, options
-    end
-
-    trap("TERM") { kill_and_exit("TERM") }
-    trap("INT")  { kill_and_exit("INT")  }
-
-    watch_for_termination
-  end
-
-  def execute(name, options={})
-    fork processes[name], options
-
-    trap("TERM") { kill_and_exit("TERM") }
-    trap("INT")  { kill_and_exit("INT")  }
+    trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
+    trap("INT")  { puts "SIGINT received";  terminate_gracefully }
 
+    assign_colors
+    spawn_processes
+    watch_for_output
     watch_for_termination
   end
 
   def port_for(process, num, base_port=nil)
     base_port ||= 5000
-    offset = processes.keys.sort.index(process.name) * 100
+    offset = procfile.process_names.index(process.name) * 100
     base_port.to_i + offset + num - 1
   end
 
 private ######################################################################
 
-  def fork(process, options={})
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+  def spawn_processes
+    concurrency = Foreman::Utils.parse_concurrency(@options[:concurrency])
 
-    1.upto(concurrency[process.name]) do |num|
-      fork_individual(process, port_for(process, num, options[:port]))
+    procfile.entries.each do |entry|
+      reader, writer = IO.pipe
+      entry.spawn(concurrency[entry.name], writer, @directory, @environment, port_for(entry, 1, base_port)).each do |process|
+        running_processes[process.pid] = process
+        readers[process] = reader
+      end
     end
   end
 
-  def fork_individual(process, port)
-    ENV["PORT"] = port.to_s
-
-    pid = Process.fork do
-      run(process)
-    end
-
-    info "started with pid #{pid}", process
-    running_processes[pid] = process
+  def base_port
+    options[:port] || 5000
   end
 
-  def run(process, log_to_file=true)
-    proctitle "ruby: foreman #{process.name}"
+  def kill_all(signal="SIGTERM")
+    running_processes.each do |pid, process|
+      info "sending #{signal} to pid #{pid}"
+      Process.kill(signal, pid) rescue Errno::ESRCH
+    end
+  end
 
-    Dir.chdir directory do
-      FileUtils.mkdir_p "log"
-      command = process.command
+  def terminate_gracefully
+    info "sending SIGTERM to all processes"
+    kill_all "SIGTERM"
+    Timeout.timeout(5) { Process.waitall }
+  rescue Timeout::Error
+    info "sending SIGKILL to all processes"
+    kill_all "SIGKILL"
+  end
 
+  def watch_for_output
+    Thread.new do
       begin
-        PTY.spawn("#{process.command} 2>&1") do |stdin, stdout, pid|
-          until stdin.eof?
-            info stdin.gets, process
+        loop do
+          rs, ws = IO.select(readers.values, [], [], 1)
+          (rs || []).each do |r|
+            ps, message = r.gets.split(",", 2)
+            color = colors[ps.split(".").first]
+            info message, ps, color
           end
         end
-      rescue PTY::ChildExited, Interrupt
-        info "process exiting", process
+      rescue Exception => ex
+        puts ex.message
+        puts ex.backtrace
       end
-      Process.waitall
     end
   end
 
-  def kill_and_exit(signal="TERM")
-    info "terminating"
-    running_processes.each do |pid, process|
-      info "killing #{process.name} in pid #{pid}"
-      Process.kill(signal, pid)
-    end
-    Process.waitall
-    exit 0
+  def watch_for_termination
+    pid, status = Process.wait2
+    process = running_processes.delete(pid)
+    info "process terminated", process.name
+    terminate_gracefully
+    kill_all
+  rescue Errno::ECHILD
   end
 
-  def info(message, process=nil)
-    print process.color if process
-    print "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(process)} | "
+  def info(message, name="system", color=Term::ANSIColor.white)
+    print color
+    print "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(name)} | "
     print Term::ANSIColor.reset
     print message.chomp
-    puts
+    puts ""
+  end
+
+  def print(message=nil)
+    @output_mutex.synchronize do
+      $stdout.print message
+    end
+  end
+
+  def puts(message=nil)
+    @output_mutex.synchronize do
+      $stdout.puts message
+    end
+  end
+
+  def error(message)
+    puts "ERROR: #{message}"
+    exit 1
   end
 
   def longest_process_name
     @longest_process_name ||= begin
-      longest = processes.keys.map { |name| name.length }.sort.last
+      longest = procfile.process_names.map { |name| name.length }.sort.last
       longest = 6 if longest < 6 # system
       longest
     end
   end
 
-  def pad_process_name(process)
-    name = process ? "#{process.name}:#{ENV["PORT"]}" : "system"
-    name.ljust(longest_process_name + 6) # add 6 for port padding
-  end
-
-  def print_info
-    info "currently running processes:"
-    running_processes.each do |pid, process|
-      info "pid #{pid}", process
-    end
+  def pad_process_name(name="system")
+    name.to_s.ljust(longest_process_name + 3) # add 3 for process number padding
   end
 
   def proctitle(title)
     $0 = title
   end
 
-  def read_procfile(procfile)
-    File.read(procfile)
-  end
-
-  def watch_for_termination
-    pid, status = Process.wait2
-    process = running_processes.delete(pid)
-    info "process terminated", process
-    kill_and_exit
+  def termtitle(title)
+    printf("\033]0;#{title}\007")
   end
 
   def running_processes
     @running_processes ||= {}
   end
 
+  def readers
+    @readers ||= {}
+  end
+
+  def colors
+    @colors ||= {}
+  end
+
+  def assign_colors
+    procfile.entries.each do |entry|
+      colors[entry.name] = next_color
+    end
+  end
+
+  def process_by_reader(reader)
+    readers.invert[reader]
+  end
+
   def next_color
     @current_color ||= -1
     @current_color  +=  1
-    @current_color >= COLORS.length ? "" : COLORS[@current_color]
+    @current_color = 0 if COLORS.length < @current_color
+    COLORS[@current_color]
   end
 
+  module Env
+    attr_reader :environment
+
+    def read_environment_files(filenames)
+      environment = {}
+
+      (filenames || "").split(",").map(&:strip).each do |filename|
+        error "No such file: #{filename}" unless File.exists?(filename)
+        environment.merge!(read_environment(filename))
+      end
+
+      environment.merge!(read_environment(".env")) unless filenames
+      environment
+    end
+
+    def read_environment(filename)
+      return {} unless File.exists?(filename)
+
+      File.read(filename).split("\n").inject({}) do |hash, line|
+        if line =~ /\A([A-Za-z_0-9]+)=(.*)\z/
+          hash[$1] = $2
+        end
+        hash
+      end
+    end
+
+    def apply_environment!
+      @environment.each { |k,v| ENV[k] = v }
+    end
+  end
+
+  include Env
+  extend  Env
 end

lib/foreman/export.rb

@@ -4,5 +4,8 @@ module Foreman::Export
   class Exception < ::Exception; end
 end
 
-require "foreman/export/upstart"
+require "foreman/export/base"
 require "foreman/export/inittab"
+require "foreman/export/upstart"
+require "foreman/export/bluepill"
+require "foreman/export/runit"

lib/foreman/export/base.rb

@@ -23,8 +23,14 @@ private ######################################################################
     puts "[foreman export] %s" % message
   end
 
-  def export_template(name)
-    File.read(File.expand_path("../../../../export/#{name}", __FILE__))
+  def export_template(exporter, file, template_root)
+    if template_root && File.exist?(file_path = File.join(template_root, file))
+      File.read(file_path)
+    elsif File.exist?(file_path = File.expand_path(File.join("~/.foreman/templates", file)))
+      File.read(file_path)
+    else
+      File.read(File.expand_path("../../../../data/export/#{exporter}/#{file}", __FILE__))
+    end
   end
 
   def write_file(filename, contents)

lib/foreman/export/bluepill.rb

@@ -0,0 +1,28 @@
+require "erb"
+require "foreman/export"
+
+class Foreman::Export::Bluepill < Foreman::Export::Base
+
+  def export(location, options={})
+    error("Must specify a location") unless location
+
+    FileUtils.mkdir_p location
+
+    app = options[:app] || File.basename(engine.directory)
+    user = options[:user] || app
+    log_root = options[:log] || "/var/log/#{app}"
+    template_root = options[:template]
+
+    Dir["#{location}/#{app}.pill"].each do |file|
+      say "cleaning up: #{file}"
+      FileUtils.rm(file)
+    end
+
+    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+
+    master_template = export_template("bluepill", "master.pill.erb", template_root)
+    master_config   = ERB.new(master_template).result(binding)
+    write_file "#{location}/#{app}.pill", master_config
+  end
+
+end

lib/foreman/export/inittab.rb

@@ -1,4 +1,4 @@
-require "foreman/export/base"
+require "foreman/export"
 
 class Foreman::Export::Inittab < Foreman::Export::Base
 
@@ -12,7 +12,7 @@ class Foreman::Export::Inittab < Foreman::Export::Base
     inittab = []
     inittab << "# ----- foreman #{app} processes -----"
 
-    engine.processes.values.inject(1) do |index, process|
+    engine.procfile.entries.inject(1) do |index, process|
       1.upto(concurrency[process.name]) do |num|
         id = app.slice(0, 2).upcase + sprintf("%02d", index)
         port = engine.port_for(process, num, options[:port])
@@ -27,8 +27,8 @@ class Foreman::Export::Inittab < Foreman::Export::Base
     inittab = inittab.join("\n") + "\n"
 
     if fname
-      FileUtils.mkdir_p(log_root)
-      FileUtils.chown(user, nil, log_root)
+      FileUtils.mkdir_p(log_root) rescue error "could not create #{log_root}"
+      FileUtils.chown(user, nil, log_root) rescue error "could not chown #{log_root} to #{user}"
       write_file(fname, inittab)
     else
       puts inittab

lib/foreman/export/runit.rb

@@ -0,0 +1,61 @@
+require "erb"
+require "foreman/export"
+
+class Foreman::Export::Runit < Foreman::Export::Base
+  ENV_VARIABLE_REGEX = /([a-zA-Z_]+[a-zA-Z0-9_]*)=(\S+)/
+
+  def export(location, options={})
+    error("Must specify a location") unless location
+
+    app = options[:app] || File.basename(engine.directory)
+    user = options[:user] || app
+    log_root = options[:log] || "/var/log/#{app}"
+    template_root = options[:template]
+
+    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+
+    run_template = export_template('runit', 'run.erb', template_root)
+    log_run_template = export_template('runit', 'log_run.erb', template_root)
+
+    engine.procfile.entries.each do |process|
+      1.upto(concurrency[process.name]) do |num|
+        process_directory     = "#{location}/#{app}-#{process.name}-#{num}"
+        process_env_directory = "#{process_directory}/env"
+        process_log_directory = "#{process_directory}/log"
+
+        create_directory process_directory
+        create_directory process_env_directory
+        create_directory process_log_directory
+
+        run = ERB.new(run_template).result(binding)
+        write_file "#{process_directory}/run", run
+        FileUtils.chmod 0755, "#{process_directory}/run"
+
+        port = engine.port_for(process, num, options[:port])
+        environment_variables = {'PORT' => port}.
+            merge(engine.environment).
+            merge(inline_variables(process.command))
+
+        environment_variables.each_pair do |var, env|
+          write_file "#{process_env_directory}/#{var.upcase}", env
+        end
+
+        log_run = ERB.new(log_run_template).result(binding)
+        write_file "#{process_log_directory}/run", log_run
+        FileUtils.chmod 0755, "#{process_log_directory}/run"
+      end
+    end
+
+  end
+
+  private
+  def create_directory(location)
+    say "creating: #{location}"
+    FileUtils.mkdir(location)
+  end
+
+  def inline_variables(command)
+    variable_name_regex =
+    Hash[*command.scan(ENV_VARIABLE_REGEX).flatten]
+  end
+end

lib/foreman/export/upstart.rb

@@ -1,5 +1,5 @@
 require "erb"
-require "foreman/export/base"
+require "foreman/export"
 
 class Foreman::Export::Upstart < Foreman::Export::Base
 
@@ -11,6 +11,7 @@ class Foreman::Export::Upstart < Foreman::Export::Base
     app = options[:app] || File.basename(engine.directory)
     user = options[:user] || app
     log_root = options[:log] || "/var/log/#{app}"
+    template_root = options[:template]
 
     Dir["#{location}/#{app}*.conf"].each do |file|
       say "cleaning up: #{file}"
@@ -19,14 +20,15 @@ class Foreman::Export::Upstart < Foreman::Export::Base
 
     concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
 
-    master_template = export_template("upstart/master.conf.erb")
+    master_template = export_template("upstart", "master.conf.erb", template_root)
     master_config   = ERB.new(master_template).result(binding)
     write_file "#{location}/#{app}.conf", master_config
 
-    process_template = export_template("upstart/process.conf.erb")
+    process_template = export_template("upstart", "process.conf.erb", template_root)
 
-    engine.processes.values.each do |process|
-      process_master_template = export_template("upstart/process_master.conf.erb")
+    engine.procfile.entries.each do |process|
+      next if (conc = concurrency[process.name]) < 1
+      process_master_template = export_template("upstart", "process_master.conf.erb", template_root)
       process_master_config   = ERB.new(process_master_template).result(binding)
       write_file "#{location}/#{app}-#{process.name}.conf", process_master_config
 

lib/foreman/process.rb

@@ -1,14 +1,81 @@
 require "foreman"
+require "rubygems"
 
 class Foreman::Process
 
-  attr_reader :name
-  attr_reader :command
-  attr_accessor :color
+  attr_reader :entry
+  attr_reader :num
+  attr_reader :pid
+  attr_reader :port
 
-  def initialize(name, command)
-    @name    = name
-    @command = command
+  def initialize(entry, num, port)
+    @entry = entry
+    @num = num
+    @port = port
+  end
+
+  def run(pipe, basedir, environment)
+    with_environment(environment.merge("PORT" => port.to_s)) do
+      run_process basedir, entry.command, pipe
+    end
+  end
+
+  def name
+    "%s.%s" % [ entry.name, num ]
+  end
+
+private
+
+  def jruby?
+    defined?(RUBY_PLATFORM) and RUBY_PLATFORM == "java"
+  end
+
+  def fork_with_io(command, basedir)
+    reader, writer = IO.pipe
+    command = replace_command_env(command)
+    pid = if jruby?
+      require "posix/spawn"
+      POSIX::Spawn.spawn(Foreman.runner, "-d", basedir, command, {
+        :out => writer, :err => writer
+      })
+    else
+      fork do
+        trap("INT", "IGNORE")
+        writer.sync = true
+        $stdout.reopen writer
+        $stderr.reopen writer
+        reader.close
+        exec Foreman.runner, "-d", basedir, command
+      end
+    end
+    [ reader, pid ]
+  end
+
+  def run_process(basedir, command, pipe)
+    io, @pid = fork_with_io(command, basedir)
+    output pipe, "started with pid %d" % @pid
+    Thread.new do
+      until io.eof?
+        output pipe, io.gets
+      end
+    end
+  end
+
+  def output(pipe, message)
+    pipe.puts "%s,%s" % [ name, message ]
+  end
+
+  def replace_command_env(command)
+    command.gsub(/\$(\w+)/) { |e| ENV[e[1..-1]] }
+  end
+
+  def with_environment(environment)
+    old_env = ENV.each_pair.inject({}) { |h,(k,v)| h.update(k => v) }
+    environment.each { |k,v| ENV[k] = v }
+    ret = yield
+    ENV.clear
+    old_env.each { |k,v| ENV[k] = v}
+    ret
   end
 
 end

lib/foreman/procfile.rb

@@ -0,0 +1,38 @@
+require "foreman"
+require "foreman/procfile_entry"
+
+# A valid Procfile entry is captured by this regex.
+# All other lines are ignored.
+#
+# /^([A-Za-z0-9_]+):\s*(.+)$/
+#
+# $1 = name
+# $2 = command
+#
+class Foreman::Procfile
+
+  attr_reader :entries
+
+  def initialize(filename)
+    @entries = parse_procfile(filename)
+  end
+
+  def [](name)
+    entries.detect { |entry| entry.name == name }
+  end
+
+  def process_names
+    entries.map(&:name)
+  end
+
+private
+
+  def parse_procfile(filename)
+    File.read(filename).split("\n").map do |line|
+      if line =~ /^([A-Za-z0-9_]+):\s*(.+)$/
+        Foreman::ProcfileEntry.new($1, $2)
+      end
+    end.compact
+  end
+
+end

lib/foreman/procfile_entry.rb

@@ -0,0 +1,22 @@
+require "foreman"
+
+class Foreman::ProcfileEntry
+
+  attr_reader :name
+  attr_reader :command
+  attr_accessor :color
+
+  def initialize(name, command)
+    @name = name
+    @command = command
+  end
+
+  def spawn(num, pipe, basedir, environment, base_port)
+    (1..num).to_a.map do |n|
+      process = Foreman::Process.new(self, n, base_port + (n-1))
+      process.run(pipe, basedir, environment)
+      process
+    end
+  end
+
+end

lib/foreman/utils.rb

@@ -3,9 +3,12 @@ require "foreman"
 class Foreman::Utils
 
   def self.parse_concurrency(concurrency)
-    @concurrency ||= begin
+    begin
       pairs = concurrency.to_s.gsub(/\s/, "").split(",")
-      pairs.inject(Hash.new(1)) do |hash, pair|
+      
+      default = concurrency.nil? ? 1 : 0
+      
+      pairs.inject(Hash.new(default)) do |hash, pair|
         process, amount = pair.split("=")
         hash.update(process => amount.to_i)        
       end

lib/foreman/version.rb

@@ -0,0 +1,5 @@
+module Foreman
+
+  VERSION = "0.37.0.pre2"
+
+end

man/foreman.1

@@ -0,0 +1,222 @@
+.\" generated with Ronn/v0.7.3
+.\" http://github.com/rtomayko/ronn/tree/0.7.3
+.
+.TH "FOREMAN" "1" "January 2012" "Foreman 0.33.1" "Foreman Manual"
+.
+.SH "NAME"
+\fBforeman\fR \- manage Procfile\-based applications
+.
+.SH "SYNOPSIS"
+\fBforeman start [process]\fR
+.
+.br
+\fBforeman export <format> [location]\fR
+.
+.SH "DESCRIPTION"
+\fBForeman\fR is a manager for Procfile\-based applications\. Its aim is to abstract away the details of the Procfile format, and allow you to either run your application directly or export it to some other process management format\.
+.
+.SH "RUNNING"
+\fBforeman start\fR is used to run your application directly from the command line\.
+.
+.P
+If no additional parameters are passed, foreman will run one instance of each type of process defined in your Procfile\.
+.
+.P
+If a parameter is passed, foreman will run one instance of the specified application type\.
+.
+.P
+The following options control how the application is run:
+.
+.TP
+\fB\-c\fR, \fB\-\-concurrency\fR
+Specify the number of each process type to run\. The value passed in should be in the format \fBprocess=num,process=num\fR
+.
+.TP
+\fB\-p\fR, \fB\-\-port\fR
+Specify which port to use as the base for this application\. Should be a multiple of 1000\.
+.
+.SH "EXPORTING"
+\fBforeman export\fR is used to export your application to another process management format\.
+.
+.P
+An location to export can be passed as an argument\. This argument may be either required or optional depending on the export format\.
+.
+.P
+The following options control how the application is run:
+.
+.TP
+\fB\-a\fR, \fB\-\-app\fR
+Use this name rather than the application\'s root directory name as the name of the application when exporting\.
+.
+.TP
+\fB\-c\fR, \fB\-\-concurrency\fR
+Specify the number of each process type to run\. The value passed in should be in the format \fBprocess=num,process=num\fR
+.
+.TP
+\fB\-l\fR, \fB\-\-log\fR
+Specify the directory to place process logs in\.
+.
+.TP
+\fB\-p\fR, \fB\-\-port\fR
+Specify which port to use as the base for this application\. Should be a multiple of 1000\.
+.
+.TP
+\fB\-u\fR, \fB\-\-user\fR
+Specify the user the application should be run as\. Defaults to the app name
+.
+.SH "OPTIONS"
+These options control all modes of foreman\'s operation\.
+.
+.TP
+\fB\-d\fR, \fB\-\-directory\fR
+Specify an alternate application root\. This defaults to the directory containing the Procfile\.
+.
+.TP
+\fB\-e\fR, \fB\-\-env\fR
+Specify an alternate environment file\. You can specify more than one file by using: \fB\-\-env file1,file2\fR\.
+.
+.TP
+\fB\-f\fR, \fB\-\-procfile\fR
+Specify an alternate location for the application\'s Procfile\. This file\'s containing directory will be assumed to be the root directory of the application\.
+.
+.SH "EXPORT FORMATS"
+foreman currently supports the following output formats:
+.
+.IP "\(bu" 4
+bluepill
+.
+.IP "\(bu" 4
+inittab
+.
+.IP "\(bu" 4
+runit
+.
+.IP "\(bu" 4
+upstart
+.
+.IP "" 0
+.
+.SH "INITTAB EXPORT"
+Will export a chunk of inittab\-compatible configuration:
+.
+.IP "" 4
+.
+.nf
+
+# \-\-\-\-\- foreman example processes \-\-\-\-\-
+EX01:4:respawn:/bin/su \- example \-c \'PORT=5000 bundle exec thin start >> /var/log/web\-1\.log 2>&1\'
+EX02:4:respawn:/bin/su \- example \-c \'PORT=5100 bundle exec rake jobs:work >> /var/log/job\-1\.log 2>&1\'
+# \-\-\-\-\- end foreman example processes \-\-\-\-\-
+.
+.fi
+.
+.IP "" 0
+.
+.SH "UPSTART EXPORT"
+Will create a series of upstart scripts in the location you specify\. Scripts will be structured to make the following commands valid:
+.
+.P
+\fBstart appname\fR
+.
+.P
+\fBstop appname\-processname\fR
+.
+.P
+\fBrestart appname\-processname\-3\fR
+.
+.SH "PROCFILE"
+A Procfile should contain both a name for the process and the command used to run it\.
+.
+.IP "" 4
+.
+.nf
+
+web: bundle exec thin start
+job: bundle exec rake jobs:work
+.
+.fi
+.
+.IP "" 0
+.
+.P
+A process name may contain letters, numbers amd the underscore character\. You can validate your Procfile format using the \fBcheck\fR command:
+.
+.IP "" 4
+.
+.nf
+
+$ foreman check
+.
+.fi
+.
+.IP "" 0
+.
+.SH "ENVIRONMENT"
+If a \fB\.env\fR file exists in the current directory, the default environment will be read from it\. This file should contain key/value pairs, separated by \fB=\fR, with one key/value pair per line\.
+.
+.IP "" 4
+.
+.nf
+
+FOO=bar
+BAZ=qux
+.
+.fi
+.
+.IP "" 0
+.
+.SH "DEFAULT OPTIONS"
+If a \fB\.foreman\fR file exists in the current directory, default options will be read from it\. This file should be in YAML format with the long option name as keys\. Example:
+.
+.IP "" 4
+.
+.nf
+
+concurrency: alpha=0,bravo=1
+port: 15000
+.
+.fi
+.
+.IP "" 0
+.
+.SH "EXAMPLES"
+Start one instance of each process type, interleave the output on stdout:
+.
+.IP "" 4
+.
+.nf
+
+$ foreman start
+.
+.fi
+.
+.IP "" 0
+.
+.P
+Export the application in upstart format:
+.
+.IP "" 4
+.
+.nf
+
+$ foreman export upstart /etc/init
+.
+.fi
+.
+.IP "" 0
+.
+.P
+Run one process type from the application defined in a specific Procfile:
+.
+.IP "" 4
+.
+.nf
+
+$ foreman start alpha \-p ~/myapp/Procfile
+.
+.fi
+.
+.IP "" 0
+.
+.SH "COPYRIGHT"
+Foreman is Copyright (C) 2010 David Dollar \fIhttp://daviddollar\.org\fR

man/foreman.1.ronn

@@ -66,6 +66,14 @@ The following options control how the application is run:
 
 These options control all modes of foreman's operation.
 
+  * `-d`, `--directory`:
+    Specify an alternate application root. This defaults to the directory
+    containing the Procfile.
+
+  * `-e`, `--env`:
+    Specify an alternate environment file. You can specify more than one
+    file by using: `--env file1,file2`.
+
   * `-f`, `--procfile`:
     Specify an alternate location for the application's Procfile. This file's
     containing directory will be assumed to be the root directory of the
@@ -75,8 +83,12 @@ These options control all modes of foreman's operation.
 
 foreman currently supports the following output formats:
 
+  * bluepill
+
   * inittab
 
+  * runit
+
   * upstart
 
 ## INITTAB EXPORT
@@ -104,8 +116,31 @@ will be structured to make the following commands valid:
 A Procfile should contain both a name for the process and the command used
 to run it.
 
-    web  bundle exec thin start
-    job  bundle exec rake jobs:work
+    web: bundle exec thin start
+    job: bundle exec rake jobs:work
+
+A process name may contain letters, numbers amd the underscore character.
+You can validate your Procfile format using the `check` command:
+
+    $ foreman check
+
+## ENVIRONMENT
+
+If a `.env` file exists in the current directory, the default environment will
+be read from it. This file should contain key/value pairs, separated by `=`, with
+one key/value pair per line.
+
+    FOO=bar
+    BAZ=qux
+
+## DEFAULT OPTIONS
+
+If a `.foreman` file exists in the current directory, default options will
+be read from it. This file should be in YAML format with the long option
+name as keys. Example:
+
+    concurrency: alpha=0,bravo=1
+    port: 15000
 
 ## EXAMPLES
 
@@ -119,7 +154,7 @@ Export the application in upstart format:
 
 Run one process type from the application defined in a specific Procfile:
 
-    $ foreman start alpha -p ~/app/Procfile
+    $ foreman start alpha -p ~/myapp/Procfile
 
 ## COPYRIGHT
 

spec/foreman/cli_spec.rb

@@ -19,13 +19,22 @@ describe "Foreman::CLI" do
 
       it "runs successfully" do
         dont_allow(subject).error
-        mock.instance_of(Foreman::Engine).start({})
+        mock.instance_of(Foreman::Engine).start
         subject.start
       end
     end
   end
 
   describe "export" do
+    describe "options" do
+      it "respects --env" do
+        write_procfile
+        write_env("envfile")
+        mock.instance_of(Foreman::Export::Upstart).export("/upstart", { "env" => "envfile" })
+        foreman %{ export upstart /upstart --env envfile }
+      end
+    end
+
     describe "with a non-existent Procfile" do
       it "prints an error" do
         mock_error(subject, "Procfile does not exist.") do
@@ -58,4 +67,76 @@ describe "Foreman::CLI" do
     end
   end
 
+  describe "check" do
+    describe "with a valid Procfile" do
+      before { write_procfile }
+
+      it "displays the jobs" do
+        mock(subject).display("valid procfile detected (alpha, bravo)")
+        subject.check
+      end
+    end
+
+    describe "with a blank Procfile" do
+      before do
+        FileUtils.touch("Procfile")
+      end
+
+      it "displays an error" do
+        mock_error(subject, "no processes defined") do
+          subject.check
+        end
+      end
+    end
+  end
+  
+  describe "run" do
+    describe "with a valid Procfile" do
+      before { write_procfile }
+
+      describe "and a command" do
+        let(:command) { ["ls", "-l"] }
+        
+        before(:each) do
+          stub(subject).exec
+        end
+        
+        it "should load the environment file" do
+          write_env
+          preserving_env do
+            subject.run *command
+            ENV["FOO"].should == "bar"
+          end
+          
+          ENV["FOO"].should be_nil
+        end
+        
+        it "should runute the command as a string" do
+          mock(subject).exec(command.join(" "))
+          subject.run *command
+        end
+      end
+      
+      describe "and a non-existent command" do
+        let(:command) { "iuhtngrglhulhdfg" }
+        
+        it "should print an error" do
+          mock_error(subject, "command not found: #{command}") do
+            subject.run command
+          end
+        end
+      end
+      
+      describe "and a non-executable command" do
+        let(:command) { __FILE__ }
+        
+        it "should print an error" do
+          mock_error(subject, "not executable: #{command}") do
+            subject.run command
+          end
+        end
+      end
+    end
+  end
+
 end

spec/foreman/engine_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "foreman/engine"
 
 describe "Foreman::Engine" do
-  subject { Foreman::Engine.new("Procfile") }
+  subject { Foreman::Engine.new("Procfile", {}) }
 
   describe "initialize" do
     describe "without an existing Procfile" do
@@ -12,10 +12,11 @@ describe "Foreman::Engine" do
     end
 
     describe "with a Procfile" do
+      before { write_procfile }
+
       it "reads the processes" do
-        write_procfile
-        subject.processes["alpha"].command.should == "./alpha"
-        subject.processes["bravo"].command.should == "./bravo"
+        subject.procfile["alpha"].command.should == "./alpha"
+        subject.procfile["bravo"].command.should == "./bravo"
       end
     end
   end
@@ -23,28 +24,63 @@ describe "Foreman::Engine" do
   describe "start" do
     it "forks the processes" do
       write_procfile
-      mock(subject).fork(subject.processes["alpha"], {})
-      mock(subject).fork(subject.processes["bravo"], {})
+      mock.instance_of(Foreman::Process).run_process("./alpha", is_a(IO))
+      mock.instance_of(Foreman::Process).run_process("./bravo", is_a(IO))
+      mock(subject).watch_for_output
       mock(subject).watch_for_termination
       subject.start
     end
 
     it "handles concurrency" do
       write_procfile
-      mock(subject).fork_individual(subject.processes["alpha"], 5000)
-      mock(subject).fork_individual(subject.processes["alpha"], 5001)
-      mock(subject).fork_individual(subject.processes["bravo"], 5100)
-      mock(subject).watch_for_termination
-      subject.start(:concurrency => "alpha=2")
+      engine = Foreman::Engine.new("Procfile",:concurrency => "alpha=2")
+      mock.instance_of(Foreman::Process).run_process("./alpha", is_a(IO)).twice
+      mock.instance_of(Foreman::Process).run_process("./bravo", is_a(IO)).never
+      mock(engine).watch_for_output
+      mock(engine).watch_for_termination
+      engine.start
     end
   end
 
-  describe "execute" do
-    it "runs the processes" do
+  describe "environment" do
+    before(:each) do
       write_procfile
-      mock(subject).fork(subject.processes["alpha"], {})
-      mock(subject).watch_for_termination
-      subject.execute("alpha")
+      stub(Process).fork
+    end
+
+    it "should read if specified" do
+      File.open("/tmp/env", "w") { |f| f.puts("FOO=baz") }
+      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
+      stub(engine).info
+      mock(engine).spawn_processes
+      mock(engine).watch_for_termination
+      engine.environment.should == {"FOO"=>"baz"}
+      engine.start
+    end
+
+    it "should read more than one if specified" do
+      File.open("/tmp/env1", "w") { |f| f.puts("FOO=bar") }
+      File.open("/tmp/env2", "w") { |f| f.puts("BAZ=qux") }
+      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env1,/tmp/env2")
+      stub(engine).info
+      mock(engine).spawn_processes
+      mock(engine).watch_for_termination
+      engine.environment.should == { "FOO"=>"bar", "BAZ"=>"qux" }
+      engine.start
+    end
+
+    it "should fail if specified and doesnt exist" do
+      mock.instance_of(Foreman::Engine).error("No such file: /tmp/env")
+      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
+    end
+
+    it "should read .env if none specified" do
+      File.open(".env", "w") { |f| f.puts("FOO=qoo") }
+      engine = Foreman::Engine.new("Procfile")
+      mock(engine).spawn_processes
+      mock(engine).watch_for_termination
+      engine.environment.should == {"FOO"=>"qoo"}
+      engine.start
     end
   end
 end

spec/foreman/export/bluepill_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/bluepill"
+require "tmpdir"
+
+describe Foreman::Export::Bluepill do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:engine) { Foreman::Engine.new(procfile) }
+  let(:bluepill) { Foreman::Export::Bluepill.new(engine) }
+
+  before(:each) { load_export_templates_into_fakefs("bluepill") }
+  before(:each) { stub(bluepill).say }
+
+  it "exports to the filesystem" do
+    bluepill.export("/tmp/init")
+    normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app.pill"))
+  end
+
+  it "exports to the filesystem with concurrency" do
+    bluepill.export("/tmp/init", :concurrency => "alpha=2")
+    
+    normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app-concurrency.pill"))
+  end
+end

spec/foreman/export/runit_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/runit"
+require "tmpdir"
+
+describe Foreman::Export::Runit do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile", 'bar=baz') }
+  let(:engine) { Foreman::Engine.new(procfile) }
+  let(:runit) { Foreman::Export::Runit.new(engine) }
+  
+  before(:each) { load_export_templates_into_fakefs("runit") }
+  before(:each) { stub(runit).say }
+  before(:each) { stub(FakeFS::FileUtils).chmod }
+  
+  it "exports to the filesystem" do
+    FileUtils.mkdir_p('/tmp/init')
+    runit.export('/tmp/init', :concurrency => "alpha=2,bravo=1")
+    
+    File.read("/tmp/init/app-alpha-1/run").should == example_export_file('runit/app-alpha-1-run')
+    File.read("/tmp/init/app-alpha-1/log/run").should == 
+        example_export_file('runit/app-alpha-1-log-run')
+    File.read("/tmp/init/app-alpha-1/env/PORT").should == "5000\n"
+    File.read("/tmp/init/app-alpha-1/env/BAR").should == "baz\n"
+    
+    File.read("/tmp/init/app-alpha-2/run").should == example_export_file('runit/app-alpha-2-run')
+    File.read("/tmp/init/app-alpha-2/log/run").should == 
+        example_export_file('runit/app-alpha-2-log-run')
+    File.read("/tmp/init/app-alpha-2/env/PORT").should == "5001\n"
+    File.read("/tmp/init/app-alpha-2/env/BAR").should == "baz\n"
+    
+    File.read("/tmp/init/app-bravo-1/run").should == example_export_file('runit/app-bravo-1-run')
+    File.read("/tmp/init/app-bravo-1/log/run").should == 
+        example_export_file('runit/app-bravo-1-log-run')
+    File.read("/tmp/init/app-bravo-1/env/PORT").should == "5100\n"
+  end
+end

spec/foreman/export/upstart_spec.rb

@@ -1,2 +1,70 @@
 require "spec_helper"
+require "foreman/engine"
 require "foreman/export/upstart"
+require "tmpdir"
+
+describe Foreman::Export::Upstart do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:engine) { Foreman::Engine.new(procfile) }
+  let(:upstart) { Foreman::Export::Upstart.new(engine) }
+
+  before(:each) { load_export_templates_into_fakefs("upstart") }
+  before(:each) { stub(upstart).say }
+
+  it "exports to the filesystem" do
+    upstart.export("/tmp/init")
+
+    File.read("/tmp/init/app.conf").should         == example_export_file("upstart/app.conf")
+    File.read("/tmp/init/app-alpha.conf").should   == example_export_file("upstart/app-alpha.conf")
+    File.read("/tmp/init/app-alpha-1.conf").should == example_export_file("upstart/app-alpha-1.conf")
+    File.read("/tmp/init/app-bravo.conf").should   == example_export_file("upstart/app-bravo.conf")
+    File.read("/tmp/init/app-bravo-1.conf").should == example_export_file("upstart/app-bravo-1.conf")
+  end
+
+  it "exports to the filesystem with concurrency" do
+    upstart.export("/tmp/init", :concurrency => "alpha=2")
+
+    File.read("/tmp/init/app.conf").should         == example_export_file("upstart/app.conf")
+    File.read("/tmp/init/app-alpha.conf").should   == example_export_file("upstart/app-alpha.conf")
+    File.read("/tmp/init/app-alpha-1.conf").should == example_export_file("upstart/app-alpha-1.conf")
+    File.read("/tmp/init/app-alpha-2.conf").should == example_export_file("upstart/app-alpha-2.conf")
+    File.exists?("/tmp/init/app-bravo-1.conf").should == false
+  end
+
+  context "with alternate templates" do
+    let(:template_root) { "/tmp/alternate" }
+
+    before do
+      FileUtils.mkdir_p template_root
+      File.open("#{template_root}/master.conf.erb", "w") { |f| f.puts "alternate_template" }
+    end
+
+    it "can export with alternate template files" do
+      upstart.export("/tmp/init", :template => template_root)
+
+      File.read("/tmp/init/app.conf").should == "alternate_template\n"
+    end
+  end
+
+  context "with alternate templates from home dir" do
+    let(:default_template_root) {File.expand_path("#{ENV['HOME']}/.foreman/templates")}
+
+    before do
+      ENV['_FOREMAN_SPEC_HOME'] = ENV['HOME']
+      ENV['HOME'] = "/home/appuser"
+      FileUtils.mkdir_p default_template_root
+      File.open("#{default_template_root}/master.conf.erb", "w") { |f| f.puts "default_alternate_template" }
+    end
+
+    after do
+      ENV['HOME'] = ENV.delete('_FOREMAN_SPEC_HOME')
+    end
+
+    it "can export with alternate template files" do
+      upstart.export("/tmp/init")
+
+      File.read("/tmp/init/app.conf").should == "default_alternate_template\n"
+    end
+  end
+
+end

spec/foreman_spec.rb

@@ -8,4 +8,26 @@ describe Foreman do
     it { should be_a String }
   end
 
+  describe "::load_env!(env_file)" do
+    before do
+      FakeFS.activate!
+    end
+
+    after do
+      FakeFS.deactivate!
+      ENV['FOO'] = nil
+    end
+
+    it "should load env_file into ENV" do
+      File.open("/tmp/env1", "w") { |f| f.puts("FOO=bar") }
+      Foreman.load_env!("/tmp/env1")
+      ENV['FOO'].should == 'bar'
+    end 
+
+    it "should assume env_file in ./.env" do
+      File.open("./.env", "w") { |f| f.puts("FOO=bar") }
+      Foreman.load_env!
+      ENV['FOO'].should == 'bar'
+    end
+  end
 end

spec/helper_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe "spec helpers" do
+  describe "#preserving_env" do
+    after { ENV.delete "FOO" }
+    
+    it "should remove added environment vars" do
+      preserving_env { ENV["FOO"] = "baz" }
+      ENV["FOO"].should == nil
+    end
+    
+    it "should reset modified environment vars" do
+      ENV["FOO"] = "bar"
+      preserving_env { ENV["FOO"] = "baz"}
+      ENV["FOO"].should == "bar"
+    end
+  end
+end

spec/resources/export/bluepill/app-concurrency.pill

@@ -0,0 +1,47 @@
+Bluepill.application("app", :foreground => false, :log_file => "/var/log/bluepill.log") do |app|
+
+  app.uid = "app"
+  app.gid = "app"
+
+
+
+
+  app.process("alpha-1") do |process|
+    process.start_command = "./alpha"
+
+    process.working_dir = "/tmp/app"
+    process.daemonize = true
+    process.environment = {"PORT" => "5000"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+
+    process.stdout = process.stderr = "/var/log/app/app-alpha-1.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill -QUIT {{PID}}"
+    end
+    
+    process.group = "app-alpha"
+  end
+
+
+  app.process("alpha-2") do |process|
+    process.start_command = "./alpha"
+
+    process.working_dir = "/tmp/app"
+    process.daemonize = true
+    process.environment = {"PORT" => "5001"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+
+    process.stdout = process.stderr = "/var/log/app/app-alpha-2.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill -QUIT {{PID}}"
+    end
+    
+    process.group = "app-alpha"
+  end
+
+
+
+
+end

spec/resources/export/bluepill/app.pill

@@ -0,0 +1,44 @@
+Bluepill.application("app", :foreground => false, :log_file => "/var/log/bluepill.log") do |app|
+
+  app.uid = "app"
+  app.gid = "app"
+
+
+
+
+  app.process("alpha-1") do |process|
+    process.start_command = "./alpha"
+
+    process.working_dir = "/tmp/app"
+    process.daemonize = true
+    process.environment = {"PORT" => "5000"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+
+    process.stdout = process.stderr = "/var/log/app/app-alpha-1.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill -QUIT {{PID}}"
+    end
+
+    process.group = "app-alpha"
+  end
+
+  app.process("bravo-1") do |process|
+    process.start_command = "./bravo"
+
+    process.working_dir = "/tmp/app"
+    process.daemonize = true
+    process.environment = {"PORT" => "5100"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+
+    process.stdout = process.stderr = "/var/log/app/app-bravo-1.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill -QUIT {{PID}}"
+    end
+
+    process.group = "app-bravo"
+  end
+
+
+end

spec/resources/export/runit/app-alpha-1-log-run

@@ -0,0 +1,7 @@
+#!/bin/sh
+set -e
+
+LOG=/var/log/app/alpha-1
+
+test -d "$LOG" || mkdir -p m2750 "$LOG" && chown app "$LOG"
+exec chpst -u app svlogd "$LOG"

spec/resources/export/runit/app-alpha-1-run

@@ -0,0 +1,3 @@
+#!/bin/sh
+cd /tmp/app
+exec chpst -u app -e /tmp/init/app-alpha-1/env ./alpha bar=baz

spec/resources/export/runit/app-alpha-2-log-run

@@ -0,0 +1,7 @@
+#!/bin/sh
+set -e
+
+LOG=/var/log/app/alpha-2
+
+test -d "$LOG" || mkdir -p m2750 "$LOG" && chown app "$LOG"
+exec chpst -u app svlogd "$LOG"

spec/resources/export/runit/app-alpha-2-run

@@ -0,0 +1,3 @@
+#!/bin/sh
+cd /tmp/app
+exec chpst -u app -e /tmp/init/app-alpha-2/env ./alpha bar=baz

spec/resources/export/runit/app-bravo-1-log-run

@@ -0,0 +1,7 @@
+#!/bin/sh
+set -e
+
+LOG=/var/log/app/bravo-1
+
+test -d "$LOG" || mkdir -p m2750 "$LOG" && chown app "$LOG"
+exec chpst -u app svlogd "$LOG"

spec/resources/export/runit/app-bravo-1-run

@@ -0,0 +1,3 @@
+#!/bin/sh
+cd /tmp/app
+exec chpst -u app -e /tmp/init/app-bravo-1/env ./bravo

spec/resources/export/upstart/app-alpha-1.conf

@@ -0,0 +1,5 @@
+start on starting app-alpha
+stop on stopping app-alpha
+respawn
+
+exec su - app -c 'cd /tmp/app; export PORT=5000; ./alpha >> /var/log/app/alpha-1.log 2>&1'

spec/resources/export/upstart/app-alpha-2.conf

@@ -0,0 +1,5 @@
+start on starting app-alpha
+stop on stopping app-alpha
+respawn
+
+exec su - app -c 'cd /tmp/app; export PORT=5001; ./alpha >> /var/log/app/alpha-2.log 2>&1'

spec/resources/export/upstart/app-alpha.conf

@@ -0,0 +1,2 @@
+start on starting app
+stop on stopping app

spec/resources/export/upstart/app-bravo-1.conf

@@ -0,0 +1,5 @@
+start on starting app-bravo
+stop on stopping app-bravo
+respawn
+
+exec su - app -c 'cd /tmp/app; export PORT=5100; ./bravo >> /var/log/app/bravo-1.log 2>&1'

spec/resources/export/upstart/app-bravo.conf

@@ -0,0 +1,2 @@
+start on starting app
+stop on stopping app

spec/resources/export/upstart/app.conf

@@ -0,0 +1,8 @@
+pre-start script
+
+bash << "EOF"
+  mkdir -p /var/log/app
+  chown -R app /var/log/app
+EOF
+
+end script

spec/spec_helper.rb

@@ -3,7 +3,7 @@ require "rspec"
 require "fakefs/safe"
 require "fakefs/spec_helpers"
 
-$:.unshift "lib"
+$:.unshift File.expand_path("../../lib", __FILE__)
 
 def mock_error(subject, message)
   mock_exit do
@@ -12,6 +12,10 @@ def mock_error(subject, message)
   end
 end
 
+def foreman(args)
+  Foreman::CLI.start(args.split(" "))
+end
+
 def mock_exit(&block)
   block.should raise_error(SystemExit)
 end
@@ -24,15 +28,58 @@ def write_foreman_config(app)
   end
 end
 
-def write_procfile(procfile="Procfile")
+def write_procfile(procfile="Procfile", alpha_env="")
   File.open(procfile, "w") do |file|
-    file.puts "alpha ./alpha"
-    file.puts "bravo ./bravo"
+    file.puts "alpha: ./alpha" + " #{alpha_env}".rstrip
+    file.puts "\n"
+    file.puts "bravo:\t./bravo"
+  end
+  File.expand_path(procfile)
+end
+
+def write_env(env=".env")
+  File.open(env, "w") do |file|
+    file.puts "FOO=bar"
   end
 end
 
-Rspec.configure do |config|
+def load_export_templates_into_fakefs(type)
+  FakeFS.deactivate!
+  files = Dir[File.expand_path("../../data/export/#{type}/**", __FILE__)].inject({}) do |hash, file|
+    hash.update(file => File.read(file))
+  end
+  FakeFS.activate!
+  files.each do |filename, contents|
+    File.open(filename, "w") do |f|
+      f.puts contents
+    end
+  end
+end
+
+def example_export_file(filename)
+  FakeFS.deactivate!
+  data = File.read(File.expand_path("../resources/export/#{filename}", __FILE__))
+  FakeFS.activate!
+  data
+end
+
+def preserving_env
+  old_env = ENV.to_hash
+  begin
+    yield
+  ensure
+    ENV.clear
+    ENV.update(old_env)
+  end
+end
+
+def normalize_space(s)
+  s.gsub(/\n[\n\s]*/, "\n")
+end
+  
+RSpec.configure do |config|
   config.color_enabled = true
+  config.order = 'rand'
   config.include FakeFS::SpecHelpers
   config.mock_with :rr
 end