0.32.0

Support for complex cmds in Procfile

.gitignore

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

.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,3 +1,15 @@
 source "http://rubygems.org"
 
 gemspec
+
+group :development do
+  gem 'parka'
+  gem 'rake'
+  gem 'ronn'
+  gem 'fakefs', '~> 0.3.2'
+  gem 'rcov',   '~> 0.9.8'
+  gem 'rr',     '~> 1.0.2'
+  gem 'rspec',  '~> 2.6.0'
+  gem 'aws-s3'
+  gem "rubyzip"
+end

Gemfile.lock

@@ -1,16 +1,21 @@
 PATH
   remote: .
   specs:
-    foreman (0.18.0)
+    foreman (0.32.0)
       term-ansicolor (~> 1.0.5)
       thor (>= 0.13.6)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    aws-s3 (0.6.2)
+      builder
+      mime-types
+      xml-simple
+    builder (3.0.0)
     crack (0.1.8)
     diff-lcs (1.1.2)
-    fakefs (0.2.1)
+    fakefs (0.3.2)
     hpricot (0.8.2)
     mime-types (1.16)
     mustache (0.11.2)
@@ -18,7 +23,7 @@ GEM
       crack
       rest-client
       thor
-    rake (0.8.7)
+    rake (0.9.2)
     rcov (0.9.8)
     rdiscount (1.6.5)
     rest-client (1.6.1)
@@ -28,28 +33,30 @@ GEM
       mustache (>= 0.7.0)
       rdiscount (>= 1.5.8)
     rr (1.0.2)
-    rspec (2.0.1)
-      rspec-core (~> 2.0.1)
-      rspec-expectations (~> 2.0.1)
-      rspec-mocks (~> 2.0.1)
-    rspec-core (2.0.1)
-    rspec-expectations (2.0.1)
-      diff-lcs (>= 1.1.2)
-    rspec-mocks (2.0.1)
-      rspec-core (~> 2.0.1)
-      rspec-expectations (~> 2.0.1)
-    term-ansicolor (1.0.5)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    rubyzip (0.9.4)
+    term-ansicolor (1.0.7)
     thor (0.14.6)
+    xml-simple (1.0.15)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  fakefs (~> 0.2.1)
+  aws-s3
+  fakefs (~> 0.3.2)
   foreman!
   parka
   rake
   rcov (~> 0.9.8)
   ronn
   rr (~> 1.0.2)
-  rspec (~> 2.0.0)
+  rspec (~> 2.6.0)
+  rubyzip

README.markdown

@@ -2,15 +2,26 @@
 
 ## 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
 
-See the [man page](http://ddollar.github.com/foreman) for usage.
+* [man page](http://ddollar.github.com/foreman)
+* [wiki](http://github.com/ddollar/foreman/wiki)
 
 ## Authorship
 
@@ -19,11 +30,20 @@ Created by David Dollar
 Patches contributed by:
 
 * Adam Wiggins
-* clifff
 * 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
 

Rakefile

@@ -13,7 +13,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,7 +22,7 @@ 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", ".bundle", "--exclude", "spec" ]
@@ -54,3 +54,134 @@ task :pages => "man:commit" do
     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
+  require "foreman/distribution"
+  Foreman::Distribution.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/foreman-runner

@@ -1,2 +0,0 @@
-#!/usr/bin/env ruby
-exec ARGV.join(" ")

bin/runner

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec "#{ARGV.join(' ')} 2>&1"

data/example/Procfile

@@ -1,2 +1,2 @@
-ticker: ./ticker $PORT
-error : ./error
+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/ticker

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 
-%w( SIGINT SIGTERM SIGHUP ).each do |signal|
+$stdout.sync = true
+
+%w( SIGINT SIGTERM ).each do |signal|
   trap(signal) do
     puts "received #{signal} but i'm ignoring it!"
   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

@@ -2,4 +2,4 @@ start on starting <%= app %>-<%= process.name %>
 stop on stopping <%= app %>-<%= process.name %>
 respawn
 
-exec su - <%= user %> -c 'cd <%= engine.directory %>; export PORT=<%= port %>; <%= process.command %> >> <%= log_root %>/<%=process.name%>-<%=num%>.log 2>&1'
+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/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/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/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

foreman.gemspec

@@ -18,12 +18,4 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency 'term-ansicolor', '~> 1.0.5'
   gem.add_dependency 'thor',           '>= 0.13.6'
-
-  gem.add_development_dependency 'parka'
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'ronn'
-  gem.add_development_dependency 'fakefs', '~> 0.2.1'
-  gem.add_development_dependency 'rcov',   '~> 0.9.8'
-  gem.add_development_dependency 'rr',     '~> 1.0.2'
-  gem.add_development_dependency 'rspec',  '~> 2.0.0'
 end

lib/foreman.rb

@@ -4,5 +4,15 @@ 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

@@ -5,31 +5,36 @@ require "thor"
 require "yaml"
 
 class Foreman::CLI < Thor
-
+  
   class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
-
-  desc "start [PROCESS]", "Start the application, or a specific process"
+  
+  desc "start", "Start the application"
 
   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"'
 
-  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"'
 
@@ -39,6 +44,8 @@ class Foreman::CLI < Thor
     formatter = case format
       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
 
@@ -51,11 +58,23 @@ class Foreman::CLI < Thor
   desc "check", "Validate your application's Procfile"
 
   def check
-    processes = engine.processes_in_order.map { |p| p.first }
-    error "no processes defined" unless processes.length > 0
-    display "valid procfile detected (#{processes.join(', ')})"
+    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!
@@ -63,7 +82,7 @@ private ######################################################################
   end
 
   def engine
-    @engine ||= Foreman::Engine.new(procfile)
+    @engine ||= Foreman::Engine.new(procfile, options)
   end
 
   def procfile
@@ -86,8 +105,7 @@ private ######################################################################
   def options
     original_options = super
     return original_options unless File.exists?(".foreman")
-    defaults = YAML::load_file(".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,144 +1,141 @@
 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 ]
 
-  def initialize(procfile)
-    @procfile  = read_procfile(procfile)
+  def initialize(procfile, options={})
+    @procfile  = Foreman::Procfile.new(procfile)
     @directory = File.expand_path(File.dirname(procfile))
+    @options = options
+    @environment = read_environment_files(options[:env])
+    @output_mutex = Mutex.new
   end
 
-  def processes
-    @processes ||= begin
-      @order = []
-      procfile.split("\n").inject({}) do |hash, line|
-        next if line.strip == ""
-        name, command = line.split(/ *: +/, 2)
-        unless command
-          warn_deprecated_procfile!
-          name, command = line.split(/ +/, 2)
-        end
-        process = Foreman::Process.new(name, command)
-        process.color = next_color
-        @order << process.name
-        hash.update(process.name => process)
-      end
-    end
+  def self.load_env!(env_file)
+    @environment = read_environment_files(env_file)
+    apply_environment!
   end
 
-  def process_order
-    processes
-    @order.uniq
-  end
-
-  def processes_in_order
-    process_order.map do |name|
-      [name, processes[name]]
-    end
-  end
-
-  def start(options={})
-    environment = read_environment(options[:env])
-
+  def start
     proctitle "ruby: foreman master"
-
-    processes_in_order.each do |name, process|
-      fork process, options, environment
-    end
-
-    trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
-    trap("INT")  { puts "SIGINT received";  terminate_gracefully }
-
-    watch_for_termination
-  end
-
-  def execute(name, options={})
-    environment = read_environment(options[:env])
-
-    fork processes[name], options, environment
+    termtitle "#{File.basename(@directory)} - foreman"
 
     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_in_order.map { |p| p.first }.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={}, environment={})
-    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, num, port_for(process, num, options[:port]), environment)
+    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, num, port, environment)
-    environment.each { |k,v| ENV[k] = v }
-
-    ENV["PORT"] = port.to_s
-    ENV["PS"]   = "#{process.name}.#{num}"
-
-    pid = Process.fork do
-      run(process)
-    end
-
-    info "started with pid #{pid}", process
-    running_processes[pid] = process
-  end
-
-  def run(process)
-    proctitle "ruby: foreman #{process.name}"
-    trap("SIGINT", "IGNORE")
-
-    begin
-      Dir.chdir directory do
-        PTY.spawn(runner, process.command) do |stdin, stdout, pid|
-          trap("SIGTERM") { Process.kill("SIGTERM", pid) }
-          until stdin.eof?
-            info stdin.gets, process
-          end
-        end
-      end
-    rescue PTY::ChildExited, Interrupt
-      begin
-        info "process exiting", process
-      rescue Interrupt
-      end
-    end
+  def base_port
+    options[:port] || 5000
   end
 
   def kill_all(signal="SIGTERM")
     running_processes.each do |pid, process|
-      Process.kill(signal, pid) rescue Errno::ESRCH
+      info "sending #{signal} to pid #{pid}"
+      kill(signal, -pid) or kill(signal, pid)
     end
   end
 
-  def info(message, process=nil)
-    print process.color if process
-    print "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(process)} | "
+  def kill(signal, pid)
+    Process.kill signal, pid
+  rescue Errno::ESRCH
+    false
+  end
+
+  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
+        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 Exception => ex
+        puts ex.message
+        puts ex.backtrace
+      end
+    end
+  end
+
+  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, 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)
@@ -148,86 +145,83 @@ private ######################################################################
 
   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 ? "#{ENV["PS"]}" : "system"
-    name.ljust(longest_process_name + 3) # add 3 for process number 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
-    terminate_gracefully
-    kill_all
-  rescue Errno::ECHILD
+  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]
   end
 
-  def warn_deprecated_procfile!
-    return if @already_warned_deprecated
-    @already_warned_deprecated = true
-    puts "!!! This format of Procfile is deprecated, and will not work starting in v0.12"
-    puts "!!! Use a colon to separate the process name from the command"
-    puts "!!! e.g.   web: thin start"
-  end
+  module Env
+    attr_reader :environment
 
-  def read_environment(filename)
-    error "No such file: #{filename}" if filename && !File.exists?(filename)
-    filename ||= ".env"
-    environment = {}
+    def read_environment_files(filenames)
+      environment = {}
 
-    if File.exists?(filename)
-      File.read(filename).split("\n").each do |line|
-        if line =~ /\A([A-Za-z_]+)=(.*)\z/
-          environment[$1] = $2
+      (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
 
-    environment
-  end
-
-  def runner
-    File.expand_path("../../../bin/foreman-runner", __FILE__)
-  end
-
-  def terminate_gracefully
-    info "sending SIGTERM to all processes"
-    kill_all "SIGTERM"
-    Timeout.timeout(3) { Process.waitall }
-  rescue Timeout::Error
-    info "sending SIGKILL to all processes"
-    kill_all "SIGKILL"
+    def apply_environment!
+      @environment.each { |k,v| ENV[k] = v }
+    end
   end
 
+  include Env
+  extend  Env
 end

lib/foreman/export.rb

@@ -7,3 +7,5 @@ end
 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("../../../../data/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.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

@@ -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])

lib/foreman/export/runit.rb

@@ -0,0 +1,60 @@
+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
+
+        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
+
+      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

@@ -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

@@ -2,13 +2,69 @@ require "foreman"
 
 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)
+    Dir.chdir(basedir) do
+      with_environment(environment.merge("PORT" => port.to_s)) do
+        run_process entry.command, pipe
+      end
+    end
+  end
+
+  def name
+    "%s.%s" % [ entry.name, num ]
+  end
+
+private
+
+  def fork_with_io(command)
+    reader, writer = IO.pipe
+    pid = fork do
+      Process.setpgrp
+      trap("INT", "IGNORE")
+      $stdout.reopen writer
+      reader.close
+      exec Foreman.runner, replace_command_env(command)
+    end
+    Process.detach pid
+    [ reader, pid ]
+  end
+
+  def run_process(command, pipe)
+    io, @pid = fork_with_io(command)
+    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,7 +3,7 @@ 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|
         process, amount = pair.split("=")

lib/foreman/version.rb

@@ -1,5 +1,5 @@
 module Foreman
 
-  VERSION = "0.18.0"
+  VERSION = "0.32.0"
 
 end

man/foreman.1

@@ -1,7 +1,7 @@
 .\" generated with Ronn/v0.7.3
 .\" http://github.com/rtomayko/ronn/tree/0.7.3
 .
-.TH "FOREMAN" "1" "May 2011" "Foreman 0.15.0" "Foreman Manual"
+.TH "FOREMAN" "1" "November 2011" "Foreman 0.26.0" "Foreman Manual"
 .
 .SH "NAME"
 \fBforeman\fR \- manage Procfile\-based applications
@@ -69,7 +69,7 @@ These options control all modes of foreman\'s operation\.
 .
 .TP
 \fB\-e\fR, \fB\-\-env\fR
-Specify a file containing the environment that should be set up for each child process\. The file should be key/value pairs separated by \fB=\fR, with one key/value pair per line\.
+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
@@ -79,9 +79,15 @@ Specify an alternate location for the application\'s Procfile\. This file\'s con
 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
@@ -129,7 +135,7 @@ job: bundle exec rake jobs:work
 .IP "" 0
 .
 .P
-You can validate your Procfile format using the \fBcheck\fR command
+A process name may contain letters, numbers amd the underscore character\. You can validate your Procfile format using the \fBcheck\fR command:
 .
 .IP "" 4
 .
@@ -141,6 +147,20 @@ $ foreman check
 .
 .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:
 .
@@ -148,7 +168,7 @@ If a \fB\.foreman\fR file exists in the current directory, default options will
 .
 .nf
 
-concurrency: alpha=0
+concurrency: alpha=0,bravo=1
 port: 15000
 .
 .fi

man/foreman.1.ronn

@@ -67,9 +67,8 @@ The following options control how the application is run:
 These options control all modes of foreman's operation.
 
   * `-e`, `--env`:
-    Specify a file containing the environment that should be set up for each
-    child process. The file should be key/value pairs separated by `=`, with
-    one key/value pair per line.
+    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
@@ -80,8 +79,12 @@ These options control all modes of foreman's operation.
 
 foreman currently supports the following output formats:
 
+  * bluepill
+
   * inittab
 
+  * runit
+
   * upstart
 
 ## INITTAB EXPORT
@@ -112,17 +115,27 @@ to run it.
     web: bundle exec thin start
     job: bundle exec rake jobs:work
 
-You can validate your Procfile format using the `check` command
+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
+    concurrency: alpha=0,bravo=1
     port: 15000
 
 ## EXAMPLES

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
@@ -80,5 +89,54 @@ describe "Foreman::CLI" do
       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
@@ -15,21 +15,8 @@ describe "Foreman::Engine" do
       before { write_procfile }
 
       it "reads the processes" do
-        subject.processes["alpha"].command.should == "./alpha"
-        subject.processes["bravo"].command.should == "./bravo"
-      end
-    end
-
-    describe "with a deprecated Procfile" do
-      before do
-        File.open("Procfile", "w") do |file|
-          file.puts "name command"
-        end
-      end
-
-      it "should print a deprecation warning" do
-        mock(subject).warn_deprecated_procfile!
-        subject.processes.length.should == 1
+        subject.procfile["alpha"].command.should == "./alpha"
+        subject.procfile["bravo"].command.should == "./bravo"
       end
     end
   end
@@ -37,28 +24,21 @@ 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"], 1, 5000, {})
-      mock(subject).fork_individual(subject.processes["alpha"], 2, 5001, {})
-      mock(subject).fork_individual(subject.processes["bravo"], 1, 5100, {})
-      mock(subject).watch_for_termination
-      subject.start(:concurrency => "alpha=2")
-    end
-  end
-
-  describe "execute" do
-    it "runs the processes" do
-      write_procfile
-      mock(subject).fork(subject.processes["alpha"], {}, {})
-      mock(subject).watch_for_termination
-      subject.execute("alpha")
+      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))
+      mock(engine).watch_for_output
+      mock(engine).watch_for_termination
+      engine.start
     end
   end
 
@@ -66,24 +46,41 @@ describe "Foreman::Engine" do
     before(:each) do
       write_procfile
       stub(Process).fork
-      stub(subject).info
-      mock(subject).watch_for_termination
     end
 
     it "should read if specified" do
       File.open("/tmp/env", "w") { |f| f.puts("FOO=baz") }
-      subject.execute("alpha", :env => "/tmp/env")
+      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(subject).error("No such file: /tmp/env")
-      subject.execute("alpha", :env => "/tmp/env")
+      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") }
-      mock(subject).fork_individual(anything, anything, anything, { "FOO" => "qoo" })
-      subject.execute("bravo")
+      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,19 @@
+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", :concurrency => "alpha=2")
+    File.read("/tmp/init/app.pill").should == example_export_file("bluepill/app.pill")
+  end
+
+end

spec/foreman/export/runit_spec.rb

@@ -0,0 +1,35 @@
+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 }
+  
+  it "exports to the filesystem" do
+    FileUtils.mkdir_p('/tmp/init')
+    runit.export('/tmp/init', :concurrency => 'alpha=2')
+    
+    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

@@ -12,7 +12,7 @@ describe Foreman::Export::Upstart do
   before(:each) { stub(upstart).say }
 
   it "exports to the filesystem" do
-    upstart.export("/tmp/init")
+    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")
@@ -21,4 +21,35 @@ describe Foreman::Export::Upstart do
     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
+
+  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("~/.foreman/templates")}
+
+    before do
+      FileUtils.mkdir_p default_template_root
+      File.open("#{default_template_root}/master.conf.erb", "w") { |f| f.puts "default_alternate_template" }
+    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.pill

@@ -0,0 +1,65 @@
+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
+
+
+
+
+  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/spec_helper.rb

@@ -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,14 +28,21 @@ 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
+
 def load_export_templates_into_fakefs(type)
   FakeFS.deactivate!
   files = Dir[File.expand_path("../../data/export/#{type}/**", __FILE__)].inject({}) do |hash, file|
@@ -52,7 +63,17 @@ def example_export_file(filename)
   data
 end
 
-Rspec.configure do |config|
+def preserving_env
+  old_env = ENV.to_hash
+  begin
+    yield
+  ensure
+    ENV.clear
+    ENV.update(old_env)
+  end
+end
+
+RSpec.configure do |config|
   config.color_enabled = true
   config.include FakeFS::SpecHelpers
   config.mock_with :rr