0.37.0.pre4

---

Because `Your::Runit::Env != My::Runit::Env` I thought that it would be nice to be able to include your own export format as a another gem along side Foreman; similar to MultiJson’s engines but using constantize because we are specifying formats via the command line.

Cheers,
Chris

.env

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

.travis.yml

@@ -11,4 +11,4 @@ notifications:
     on_success: always
     on_failure: always
     urls:
-      - https://dx-helper.herokuapp.com/travis
+      - http://dx-helper.herokuapp.com/travis

Gemfile

@@ -2,6 +2,10 @@ source "http://rubygems.org"
 
 gemspec
 
+platform :mingw do
+  gem "win32console", "~> 1.3.0"
+end
+
 platform :jruby do
   gem "posix-spawn", "~> 0.3.6"
 end
@@ -14,6 +18,7 @@ group :development do
   gem 'rcov',   '~> 0.9.8'
   gem 'rr',     '~> 1.0.2'
   gem 'rspec',  '~> 2.0'
+  gem 'ZenTest'
   gem 'aws-s3'
   gem "rubyzip"
 end

Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    foreman (0.37.0.pre2)
+    foreman (0.37.0.pre4)
       term-ansicolor (~> 1.0.7)
       thor (>= 0.13.6)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    ZenTest (4.6.2)
     aws-s3 (0.6.2)
       builder
       mime-types
@@ -47,13 +48,16 @@ GEM
     rubyzip (0.9.4)
     term-ansicolor (1.0.7)
     thor (0.14.6)
+    win32console (1.3.0-x86-mingw32)
     xml-simple (1.0.15)
 
 PLATFORMS
   java
   ruby
+  x86-mingw32
 
 DEPENDENCIES
+  ZenTest
   aws-s3
   fakefs (~> 0.3.2)
   foreman!
@@ -65,3 +69,4 @@ DEPENDENCIES
   rr (~> 1.0.2)
   rspec (~> 2.0)
   rubyzip
+  win32console (~> 1.3.0)

README.markdown

@@ -1,49 +1,38 @@
 # Foreman
 
-## Installation
+Manage Procfile-based applications
 
-* Rubygems
+<table>
+  <tr>
+    <th>If you have...</th>
+    <th>Install with...</th>
+  </tr>
+  <tr>
+    <td>Ruby (MRI, JRuby, Windows)</td>
+    <td><pre>$ gem install foreman</pre></td>
+  </tr>
+  <tr>
+    <td>Mac OS X</td>
+    <td><a href="http://assets.foreman.io/foreman/foreman.pkg">foreman.pkg</a></td>
+  </tr>
+</table>
 
-    gem install foreman
+## Getting Started
 
-* OSX
+* http://blog.daviddollar.org/2011/05/06/introducing-foreman.html
 
-    http://assets.foreman.io/foreman/foreman.pkg
+## Documentation
-
-* 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
+## Authors
 
-Created by David Dollar
+#### Created and maintained by
+David Dollar
 
-Patches contributed by:
+#### Patches contributed by
-
+Adam Wiggins, Chris Continanza, Chris Lowder, Craig R Webster, Dan Farina, Dan Peterson, David Dollar, Fletcher Nichol, Gabriel Burt, Gamaliel Toro, Greg Reinacker, Hugues Le Gendre, Hunter Nield, Iain Hecker, Jay Zeschin, Keith Rarick, Khaja Minhajuddin, Lincoln Stoll, Marcos Muino Garcia, Mark McGranaghan, Matt Griffin, Matt Haynes, Matthijs Langenberg, Michael Dwan, Michael van Rooijen, Mike Javorski, Nathan Broadbent, Nathan L Smith, Nick Zadrozny, Phil Hagelberg, Ricardo Chimal, Jr, Thom May, Tom Ward, brainopia, clifff, jc00ke
-* 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
 

Rakefile

@@ -51,6 +51,11 @@ task :pages => "man:commit" do
   }
 end
 
+task :authors do
+  authors = %x{ git log --pretty=format:"%an" | sort -u }.split("\n")
+  puts authors.join(", ")
+end
+
 ## dist
 
 require "erb"

data/export/bluepill/master.pill.erb

@@ -5,7 +5,7 @@ Bluepill.application("<%= app %>", :foreground => false, :log_file => "/var/log/
 
 <% engine.procfile.entries.each do |process| %>
 <% 1.upto(concurrency[process.name]) do |num| %>
-<% port = engine.port_for(process, num, options[:port]) %>
+<% port = engine.port_for(process, num, self.port) %>
   app.process("<%= process.name %>-<%=num%>") do |process|
     process.start_command = "<%= process.command.gsub("$PORT", port.to_s) %>"
 

dist/jruby.rake

@@ -1,5 +1,5 @@
 file pkg("foreman-#{version}-jruby.gem") => distribution_files do |t|
-  sh "env PLATFORM=jruby gem build foreman.gemspec"
+  sh "env PLATFORM=java gem build foreman.gemspec"
   sh "mv foreman-#{version}-java.gem #{t.name}"
 end
 

dist/mingw32.rake

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

foreman.gemspec

@@ -19,8 +19,13 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'term-ansicolor', '~> 1.0.7'
   gem.add_dependency 'thor',           '>= 0.13.6'
 
-  if ENV["PLATFORM"] == "jruby"
+  if ENV["PLATFORM"] == "java"
     gem.add_dependency "posix-spawn", "~> 0.3.6"
     gem.platform = Gem::Platform.new("java")
   end
+
+  if ENV["PLATFORM"] == "mingw32"
+    gem.add_dependency "win32console", "~> 1.3.0"
+    gem.platform = Gem::Platform.new("mingw32")
+  end
 end

lib/foreman.rb

@@ -14,5 +14,12 @@ module Foreman
     File.expand_path("../../bin/runner", __FILE__)
   end
 
-end
+  def self.jruby?
+    defined?(RUBY_PLATFORM) and RUBY_PLATFORM == "java"
+  end
 
+  def self.windows?
+    defined?(RUBY_PLATFORM) and RUBY_PLATFORM =~ /(win|w)32$/
+  end
+
+end

lib/foreman/cli.rb

@@ -1,10 +1,14 @@
 require "foreman"
+require "foreman/helpers"
 require "foreman/engine"
 require "foreman/export"
 require "thor"
 require "yaml"
 
 class Foreman::CLI < Thor
+  include Foreman::Helpers
+
+  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
 
   desc "start", "Start the application"
 
@@ -42,16 +46,17 @@ class Foreman::CLI < Thor
   def export(format, location=nil)
     check_procfile!
 
-    formatter = case format
+    begin
-      when "inittab" then Foreman::Export::Inittab
+      require "foreman/export/#{ format.tr('-', '_') }"
-      when "upstart" then Foreman::Export::Upstart
+      classy_format = classify(format)
-      when "bluepill" then Foreman::Export::Bluepill
+      formatter     = constantize("Foreman::Export::#{ classy_format }")
-      when "runit"    then Foreman::Export::Runit
+    rescue NameError => ex
-      else error "Unknown export format: #{format}."
+      error "Unknown export format: #{format} (no class Foreman::Export::#{ classy_format })."
+    rescue LoadError => ex
+      error "Unknown export format: #{format} (unable to load file 'foreman/export/#{ format.tr('-', '_') }')."
     end
 
-    formatter.new(engine).export(location, options)
+    formatter.new(location, engine, options).export
-
   rescue Foreman::Export::Exception => ex
     error ex.message
   end

lib/foreman/engine.rb

@@ -2,7 +2,6 @@ require "foreman"
 require "foreman/process"
 require "foreman/procfile"
 require "foreman/utils"
-require "pty"
 require "tempfile"
 require "timeout"
 require "term/ansicolor"
@@ -74,7 +73,7 @@ private ######################################################################
   def kill_all(signal="SIGTERM")
     running_processes.each do |pid, process|
       info "sending #{signal} to pid #{pid}"
-      Process.kill(signal, pid) rescue Errno::ESRCH
+      process.kill signal
     end
   end
 
@@ -89,11 +88,14 @@ private ######################################################################
 
   def watch_for_output
     Thread.new do
+      require "win32console" if Foreman.windows?
       begin
         loop do
           rs, ws = IO.select(readers.values, [], [], 1)
           (rs || []).each do |r|
-            ps, message = r.gets.split(",", 2)
+            data = r.gets
+            next unless data
+            ps, message = data.split(",", 2)
             color = colors[ps.split(".").first]
             info message, ps, color
           end
@@ -134,11 +136,6 @@ private ######################################################################
     end
   end
 
-  def error(message)
-    puts "ERROR: #{message}"
-    exit 1
-  end
-
   def longest_process_name
     @longest_process_name ||= begin
       longest = procfile.process_names.map { |name| name.length }.sort.last
@@ -156,7 +153,7 @@ private ######################################################################
   end
 
   def termtitle(title)
-    printf("\033]0;#{title}\007")
+    printf("\033]0;#{title}\007") unless Foreman.windows?
   end
 
   def running_processes
@@ -217,6 +214,11 @@ private ######################################################################
     def apply_environment!
       @environment.each { |k,v| ENV[k] = v }
     end
+
+    def error(message)
+      puts "ERROR: #{message}"
+      exit 1
+    end
   end
 
   include Env

lib/foreman/export/base.rb

@@ -3,10 +3,17 @@ require "foreman/utils"
 
 class Foreman::Export::Base
 
-  attr_reader :engine
+  attr_reader :location, :engine, :app, :log, :port, :user, :template, :concurrency
 
-  def initialize(engine)
+  def initialize(location, engine, options={})
-    @engine = engine
+    @location    = location
+    @engine      = engine
+    @app         = options[:app]
+    @log         = options[:log]
+    @port        = options[:port]
+    @user        = options[:user]
+    @template    = options[:template]
+    @concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
   end
 
   def export

lib/foreman/export/bluepill.rb

@@ -3,23 +3,21 @@ require "foreman/export"
 
 class Foreman::Export::Bluepill < Foreman::Export::Base
 
-  def export(location, options={})
+  def export
     error("Must specify a location") unless location
 
     FileUtils.mkdir_p location
 
-    app = options[:app] || File.basename(engine.directory)
+    app = self.app || File.basename(engine.directory)
-    user = options[:user] || app
+    user = self.user || app
-    log_root = options[:log] || "/var/log/#{app}"
+    log_root = self.log || "/var/log/#{app}"
-    template_root = options[:template]
+    template_root = self.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

lib/foreman/export/inittab.rb

@@ -2,20 +2,18 @@ require "foreman/export"
 
 class Foreman::Export::Inittab < Foreman::Export::Base
 
-  def export(fname=nil, options={})
+  def export
-    app = options[:app] || File.basename(engine.directory)
+    app = self.app || File.basename(engine.directory)
-    user = options[:user] || app
+    user = self.user || app
-    log_root = options[:log] || "/var/log/#{app}"
+    log_root = self.log || "/var/log/#{app}"
-
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
 
     inittab = []
     inittab << "# ----- foreman #{app} processes -----"
 
     engine.procfile.entries.inject(1) do |index, process|
-      1.upto(concurrency[process.name]) do |num|
+      1.upto(self.concurrency[process.name]) do |num|
         id = app.slice(0, 2).upcase + sprintf("%02d", index)
-        port = engine.port_for(process, num, options[:port])
+        port = engine.port_for(process, num, self.port)
         inittab << "#{id}:4:respawn:/bin/su - #{user} -c 'PORT=#{port} #{process.command} >> #{log_root}/#{process.name}-#{num}.log 2>&1'"
         index += 1
       end

lib/foreman/export/runit.rb

@@ -4,21 +4,19 @@ 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={})
+  def export
     error("Must specify a location") unless location
 
-    app = options[:app] || File.basename(engine.directory)
+    app = self.app || File.basename(engine.directory)
-    user = options[:user] || app
+    user = self.user || app
-    log_root = options[:log] || "/var/log/#{app}"
+    log_root = self.log || "/var/log/#{app}"
-    template_root = options[:template]
+    template_root = self.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|
+      1.upto(self.concurrency[process.name]) do |num|
         process_directory     = "#{location}/#{app}-#{process.name}-#{num}"
         process_env_directory = "#{process_directory}/env"
         process_log_directory = "#{process_directory}/log"
@@ -31,7 +29,7 @@ class Foreman::Export::Runit < Foreman::Export::Base
         write_file "#{process_directory}/run", run
         FileUtils.chmod 0755, "#{process_directory}/run"
 
-        port = engine.port_for(process, num, options[:port])
+        port = engine.port_for(process, num, self.port)
         environment_variables = {'PORT' => port}.
             merge(engine.environment).
             merge(inline_variables(process.command))
@@ -51,7 +49,7 @@ class Foreman::Export::Runit < Foreman::Export::Base
   private
   def create_directory(location)
     say "creating: #{location}"
-    FileUtils.mkdir(location)
+    FileUtils.mkdir_p(location)
   end
 
   def inline_variables(command)

lib/foreman/export/upstart.rb

@@ -3,23 +3,21 @@ require "foreman/export"
 
 class Foreman::Export::Upstart < Foreman::Export::Base
 
-  def export(location, options={})
+  def export
     error("Must specify a location") unless location
 
     FileUtils.mkdir_p location
 
-    app = options[:app] || File.basename(engine.directory)
+    app = self.app || File.basename(engine.directory)
-    user = options[:user] || app
+    user = self.user || app
-    log_root = options[:log] || "/var/log/#{app}"
+    log_root = self.log || "/var/log/#{app}"
-    template_root = options[:template]
+    template_root = self.template
 
     Dir["#{location}/#{app}*.conf"].each do |file|
       say "cleaning up: #{file}"
       FileUtils.rm(file)
     end
 
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
-
     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
@@ -27,13 +25,13 @@ class Foreman::Export::Upstart < Foreman::Export::Base
     process_template = export_template("upstart", "process.conf.erb", template_root)
 
     engine.procfile.entries.each do |process|
-      next if (conc = concurrency[process.name]) < 1
+      next if (conc = self.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
 
-      1.upto(concurrency[process.name]) do |num|
+      1.upto(self.concurrency[process.name]) do |num|
-        port = engine.port_for(process, num, options[:port])
+        port = engine.port_for(process, num, self.port)
         process_config = ERB.new(process_template).result(binding)
         write_file "#{location}/#{app}-#{process.name}-#{num}.conf", process_config
       end

lib/foreman/helpers.rb

@@ -0,0 +1,50 @@
+module Foreman::Helpers
+  # Copied whole sale from, https://github.com/defunkt/resque/
+
+  # Given a word with dashes, returns a camel cased version of it.
+  #
+  # classify('job-name') # => 'JobName'
+  def classify(dashed_word)
+    dashed_word.split('-').each { |part| part[0] = part[0].chr.upcase }.join
+  end
+
+  # Tries to find a constant with the name specified in the argument string:
+  #
+  # constantize("Module") # => Module
+  # constantize("Test::Unit") # => Test::Unit
+  #
+  # The name is assumed to be the one of a top-level constant, no matter
+  # whether it starts with "::" or not. No lexical context is taken into
+  # account:
+  #
+  # C = 'outside'
+  # module M
+  #   C = 'inside'
+  #   C # => 'inside'
+  #   constantize("C") # => 'outside', same as ::C
+  # end
+  #
+  # NameError is raised when the constant is unknown.
+  def constantize(camel_cased_word)
+    camel_cased_word = camel_cased_word.to_s
+
+    if camel_cased_word.include?('-')
+      camel_cased_word = classify(camel_cased_word)
+    end
+
+    names = camel_cased_word.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      args = Module.method(:const_get).arity != 1 ? [false] : []
+
+      if constant.const_defined?(name, *args)
+        constant = constant.const_get(name)
+      else
+        constant = constant.const_missing(name)
+      end
+    end
+    constant
+  end
+end

lib/foreman/process.rb

@@ -24,29 +24,46 @@ class Foreman::Process
     "%s.%s" % [ entry.name, num ]
   end
 
-private
+  def kill(signal)
-
+    pid && Process.kill(signal, pid)
-  def jruby?
+  rescue Errno::ESRCH
-    defined?(RUBY_PLATFORM) and RUBY_PLATFORM == "java"
+    false
   end
 
+  def detach
+    pid && Process.detach(pid)
+  end
+
+  def alive?
+    kill(0)
+  end
+
+  def dead?
+    !alive?
+  end
+
+private
+
   def fork_with_io(command, basedir)
     reader, writer = IO.pipe
     command = replace_command_env(command)
-    pid = if jruby?
+    pid = if Foreman.windows?
+      Dir.chdir(basedir) do
+        Process.spawn command, :out => writer, :err => writer
+      end
+    elsif Foreman.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
     end
     [ reader, pid ]
   end
@@ -70,12 +87,10 @@ private
   end
 
   def with_environment(environment)
-    old_env = ENV.each_pair.inject({}) { |h,(k,v)| h.update(k => v) }
+    original = ENV.to_hash
-    environment.each { |k,v| ENV[k] = v }
+    ENV.update environment
-    ret = yield
+    yield
-    ENV.clear
+  ensure
-    old_env.each { |k,v| ENV[k] = v}
+    ENV.replace original
-    ret
   end
-
 end

lib/foreman/version.rb

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

spec/foreman/cli_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "foreman/cli"
 
-describe "Foreman::CLI" do
+describe "Foreman::CLI", :fakefs do
   subject { Foreman::CLI.new }
 
   describe "start" do
@@ -30,7 +30,9 @@ describe "Foreman::CLI" do
       it "respects --env" do
         write_procfile
         write_env("envfile")
-        mock.instance_of(Foreman::Export::Upstart).export("/upstart", { "env" => "envfile" })
+        mock_export = mock(Foreman::Export::Upstart)
+        mock(Foreman::Export::Upstart).new("/upstart", is_a(Foreman::Engine), { "env" => "envfile" }) { mock_export }
+        mock_export.export
         foreman %{ export upstart /upstart --env envfile }
       end
     end
@@ -49,7 +51,7 @@ describe "Foreman::CLI" do
 
       describe "with an invalid formatter" do
         it "prints an error" do
-          mock_error(subject, "Unknown export format: invalidformatter.") do
+          mock_error(subject, "Unknown export format: invalidformatter (unable to load file 'foreman/export/invalidformatter').") do
             subject.export("invalidformatter")
           end
         end
@@ -60,7 +62,9 @@ describe "Foreman::CLI" do
 
         it "runs successfully" do
           dont_allow(subject).error
-          mock.instance_of(Foreman::Export::Upstart).export("/tmp/foo", {})
+          mock_export = mock(Foreman::Export::Upstart)
+          mock(Foreman::Export::Upstart).new("/tmp/foo", is_a(Foreman::Engine), {}) { mock_export }
+          mock_export.export
           subject.export("upstart", "/tmp/foo")
         end
       end

spec/foreman/engine_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "foreman/engine"
 
-describe "Foreman::Engine" do
+describe "Foreman::Engine", :fakefs do
   subject { Foreman::Engine.new("Procfile", {}) }
 
   describe "initialize" do
@@ -24,8 +24,8 @@ describe "Foreman::Engine" do
   describe "start" do
     it "forks the processes" do
       write_procfile
-      mock.instance_of(Foreman::Process).run_process("./alpha", is_a(IO))
+      mock.instance_of(Foreman::Process).run_process(Dir.pwd, "./alpha", is_a(IO))
-      mock.instance_of(Foreman::Process).run_process("./bravo", is_a(IO))
+      mock.instance_of(Foreman::Process).run_process(Dir.pwd, "./bravo", is_a(IO))
       mock(subject).watch_for_output
       mock(subject).watch_for_termination
       subject.start
@@ -34,8 +34,8 @@ describe "Foreman::Engine" do
     it "handles concurrency" do
       write_procfile
       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(Dir.pwd, "./alpha", is_a(IO)).twice
-      mock.instance_of(Foreman::Process).run_process("./bravo", is_a(IO)).never
+      mock.instance_of(Foreman::Process).run_process(Dir.pwd, "./bravo", is_a(IO)).never
       mock(engine).watch_for_output
       mock(engine).watch_for_termination
       engine.start

spec/foreman/export/bluepill_spec.rb

@@ -3,22 +3,27 @@ require "foreman/engine"
 require "foreman/export/bluepill"
 require "tmpdir"
 
-describe Foreman::Export::Bluepill do
+describe Foreman::Export::Bluepill, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
-  let(:engine) { Foreman::Engine.new(procfile) }
+  let(:engine)   { Foreman::Engine.new(procfile) }
-  let(:bluepill) { Foreman::Export::Bluepill.new(engine) }
+  let(:options)  { Hash.new }
+  let(:bluepill) { Foreman::Export::Bluepill.new("/tmp/init", engine, options) }
 
   before(:each) { load_export_templates_into_fakefs("bluepill") }
   before(:each) { stub(bluepill).say }
 
   it "exports to the filesystem" do
-    bluepill.export("/tmp/init")
+    bluepill.export
     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
+  context "with concurrency" do
-    bluepill.export("/tmp/init", :concurrency => "alpha=2")
+    let(:options) { Hash[:concurrency => "alpha=2"] }
 
-    normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app-concurrency.pill"))
+    it "exports to the filesystem with concurrency" do
+      bluepill.export
+      normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app-concurrency.pill"))
+    end
   end
+
 end

spec/foreman/export/runit_spec.rb

@@ -3,10 +3,10 @@ require "foreman/engine"
 require "foreman/export/runit"
 require "tmpdir"
 
-describe Foreman::Export::Runit do
+describe Foreman::Export::Runit, :fakefs 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) }
+  let(:runit) { Foreman::Export::Runit.new('/tmp/init', engine, :concurrency => 'alpha=2,bravo=1') }
 
   before(:each) { load_export_templates_into_fakefs("runit") }
   before(:each) { stub(runit).say }
@@ -14,7 +14,8 @@ describe Foreman::Export::Runit do
 
   it "exports to the filesystem" do
     FileUtils.mkdir_p('/tmp/init')
-    runit.export('/tmp/init', :concurrency => "alpha=2,bravo=1")
+
+    runit.export
 
     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 ==
@@ -33,4 +34,8 @@ describe Foreman::Export::Runit do
         example_export_file('runit/app-bravo-1-log-run')
     File.read("/tmp/init/app-bravo-1/env/PORT").should == "5100\n"
   end
+
+  it "creates a full path to the export directory" do
+    expect { runit.export }.to_not raise_error(Errno::ENOENT)
+  end
 end

spec/foreman/export/upstart_spec.rb

@@ -3,16 +3,17 @@ require "foreman/engine"
 require "foreman/export/upstart"
 require "tmpdir"
 
-describe Foreman::Export::Upstart do
+describe Foreman::Export::Upstart, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
-  let(:engine) { Foreman::Engine.new(procfile) }
+  let(:engine)   { Foreman::Engine.new(procfile) }
-  let(:upstart) { Foreman::Export::Upstart.new(engine) }
+  let(:options)  { Hash.new }
+  let(:upstart)  { Foreman::Export::Upstart.new("/tmp/init", engine, options) }
 
   before(:each) { load_export_templates_into_fakefs("upstart") }
   before(:each) { stub(upstart).say }
 
   it "exports to the filesystem" do
-    upstart.export("/tmp/init")
+    upstart.export
 
     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,18 +22,23 @@ describe Foreman::Export::Upstart do
     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
+  context "with concurrency" do
-    upstart.export("/tmp/init", :concurrency => "alpha=2")
+    let(:options) { Hash[:concurrency => "alpha=2"] }
 
-    File.read("/tmp/init/app.conf").should         == example_export_file("upstart/app.conf")
+    it "exports to the filesystem with concurrency" do
-    File.read("/tmp/init/app-alpha.conf").should   == example_export_file("upstart/app-alpha.conf")
+      upstart.export
-    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.read("/tmp/init/app.conf").should            == example_export_file("upstart/app.conf")
-    File.exists?("/tmp/init/app-bravo-1.conf").should == false
+      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
   end
 
   context "with alternate templates" do
     let(:template_root) { "/tmp/alternate" }
+    let(:upstart) { Foreman::Export::Upstart.new("/tmp/init", engine, :template => template_root) }
 
     before do
       FileUtils.mkdir_p template_root
@@ -40,7 +46,7 @@ describe Foreman::Export::Upstart do
     end
 
     it "can export with alternate template files" do
-      upstart.export("/tmp/init", :template => template_root)
+      upstart.export
 
       File.read("/tmp/init/app.conf").should == "alternate_template\n"
     end
@@ -61,7 +67,7 @@ describe Foreman::Export::Upstart do
     end
 
     it "can export with alternate template files" do
-      upstart.export("/tmp/init")
+      upstart.export
 
       File.read("/tmp/init/app.conf").should == "default_alternate_template\n"
     end

spec/foreman/process_spec.rb

@@ -1,2 +1,131 @@
-require "spec_helper"
+require 'spec_helper'
-require "foreman/process"
+require 'foreman/process'
+require 'ostruct'
+require 'timeout'
+require 'tmpdir'
+
+describe Foreman::Process do
+  subject { described_class.new entry, number, port }
+
+  let(:number)  { 1 }
+  let(:port)    { 777 }
+  let(:command) { "script" }
+  let(:name)    { "foobar" }
+  let(:entry)   { OpenStruct.new :name => name, :command => command }
+
+  its(:entry) { entry }
+  its(:num)   { number }
+  its(:port)  { port }
+  its(:name)  { "#{name}.#{port}" }
+  its(:pid)   { nil }
+
+  describe '#run' do
+    let(:pipe)       { :pipe }
+    let(:basedir)    { Dir.mktmpdir }
+    let(:env)        {{ 'foo' => 'bar' }}
+    let(:init_delta) { 0.1 }
+
+    after { FileUtils.remove_entry_secure basedir }
+
+    def run(cmd=command)
+      entry.command = cmd
+      subject.run pipe, basedir, env
+      subject.detach && sleep(init_delta)
+    end
+
+    def run_file(executable, code)
+      file = File.open("#{basedir}/script", 'w') {|it| it << code }
+      run "#{executable} #{file.path}"
+    end
+
+    context 'options' do
+      it 'should set PORT for environment' do
+        mock(subject).run_process(basedir, command, pipe) do
+          ENV['PORT'].should == port.to_s
+        end
+        run
+      end
+
+      it 'should set custom variables for environment' do
+        mock(subject).run_process(basedir, command, pipe) do
+          ENV['foo'].should == 'bar'
+        end
+        run
+      end
+
+      it 'should restore environment afterwards' do
+        mock(subject).run_process(basedir, command, pipe)
+        run
+        ENV.should_not include('PORT', 'foo')
+      end
+    end
+
+    context 'process' do
+      around do |spec|
+        IO.pipe do |reader, writer|
+          @reader, @writer = reader, writer
+          spec.run
+        end
+      end
+
+      let(:pipe) { @writer }
+      let(:output) { @reader.read_nonblock 1024 }
+
+      it 'should not block' do
+        expect {
+          Timeout.timeout(2*init_delta) { run 'sleep 2' }
+        }.should_not raise_exception
+      end
+
+      it 'should be alive' do
+        run 'sleep 1'
+        subject.should be_alive
+      end
+
+      it 'should be dead' do
+        run 'exit'
+        subject.should be_dead
+      end
+
+      it 'should be killable' do
+        run 'sleep 1'
+        subject.kill 'TERM'
+        subject.should be_dead
+      end
+
+      it 'should send different signals' do
+        run_file 'ruby', <<-CODE
+          trap "TERM", "IGNORE"
+          loop { sleep 1 }
+        CODE
+        sleep 1  # wait for ruby to start
+        subject.should be_alive
+        subject.kill 'TERM'
+        subject.should be_alive
+        subject.kill 'KILL'
+        subject.should be_dead
+      end
+
+      it 'should redirect stdout' do
+        run 'echo hey'
+        output.should include('hey')
+      end
+
+      it 'should redirect stderr' do
+        run 'echo hey >2'
+        output.should include('hey')
+      end
+
+      it 'should handle variables' do
+        run 'echo $PORT'
+        output.should include('777')
+      end
+
+      it 'should handle arguments' do
+        pending
+        run %{ sh -c "trap '' TERM; sleep 10" }
+        subject.should be_alive
+      end
+    end
+  end
+end

spec/foreman_spec.rb

@@ -8,13 +8,8 @@ describe Foreman do
     it { should be_a String }
   end
 
-  describe "::load_env!(env_file)" do
+  describe "::load_env!(env_file)", :fakefs do
-    before do
-      FakeFS.activate!
-    end
-
     after do
-      FakeFS.deactivate!
       ENV['FOO'] = nil
     end
 

spec/spec_helper.rb

@@ -78,8 +78,9 @@ def normalize_space(s)
 end
 
 RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.color_enabled = true
   config.order = 'rand'
-  config.include FakeFS::SpecHelpers
+  config.include FakeFS::SpecHelpers, :fakefs
   config.mock_with :rr
 end