fix up readme

Change requires so export/upstart_spec can run on its own

.env

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

.gitignore

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

Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    foreman (0.16.0)
+      term-ansicolor (~> 1.0.5)
+      thor (>= 0.13.6)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    crack (0.1.8)
+    diff-lcs (1.1.2)
+    fakefs (0.2.1)
+    hpricot (0.8.2)
+    mime-types (1.16)
+    mustache (0.11.2)
+    parka (0.6.2)
+      crack
+      rest-client
+      thor
+    rake (0.8.7)
+    rcov (0.9.8)
+    rdiscount (1.6.5)
+    rest-client (1.6.1)
+      mime-types (>= 1.16)
+    ronn (0.7.3)
+      hpricot (>= 0.8.2)
+      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)
+    thor (0.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakefs (~> 0.2.1)
+  foreman!
+  parka
+  rake
+  rcov (~> 0.9.8)
+  ronn
+  rr (~> 1.0.2)
+  rspec (~> 2.0.0)

README.markdown

@@ -0,0 +1,29 @@
+# Foreman
+
+## Installation
+
+    gem install foreman
+
+## Description
+
+http://blog.daviddollar.org/2011/05/06/introducing-foreman.html
+
+## Manual
+
+See the [man page](http://ddollar.github.com/foreman) for usage.
+
+## Author
+
+David Dollar
+
+## Contributors
+
+Adam Wiggins
+clifff
+Dan Peterson
+Keith Rarick
+Ricardo Chimal, Jr
+
+## License
+
+MIT

README.rdoc

@@ -1,85 +0,0 @@
-= Foreman
-
-== Procfile
-
-    alpha ./bin/alpha
-    bravo ./bin/bravo some args
-    charlie ./bin/charlie -n 5
-
-== Development mode
-
-=== Running
-
-Log files will be output to standard out, colorized to aid in visual separation.
-
-    $ foreman start
-    [01:27:08] [alpha] started with pid 4393
-    [01:27:08] [bravo] started with pid 4394
-    [01:27:08] [charlie] started with pid 4395
-    [01:27:08] [bravo] initializing...
-    [01:27:08] [bravo] complete
-
-=== Using Screen
-
-Launch the processes in a screen session in indivudal windows
-
-    $ foreman screen
-
-== Single Process Execution
-
-    $ foreman execute alpha
-
-== Exporting to Upstart
-
-=== Export to upstart scripts
-
-    $ foreman export sampleapp
-
-    $ initctl list | grep sampleapp
-    sampleapp start/running
-    sampleapp-alpha (1) start/running, process 4204
-    sampleapp-bravo (1) start/running, process 4589
-    sampleapp-charlie (1) start/running, process 4597
-
-=== Change process concurrency levels
-
-    $ foreman scale sampleapp alpha 4
-    sampleapp-alpha (2) start/running, process 4164
-    sampleapp-alpha (3) start/running, process 4166
-    sampleapp-alpha (4) start/running, process 4168
-
-    $ initctl list | grep sampleapp
-    sampleapp start/running
-    sampleapp-alpha (4) start/running, process 4168
-    sampleapp-alpha (3) start/running, process 4166
-    sampleapp-alpha (2) start/running, process 4164
-    sampleapp-alpha (1) start/running, process 4204
-    sampleapp-bravo (1) start/running, process 4589
-    sampleapp-charlie (1) start/running, process 4597
-
-    $ foreman scale sampleapp alpha 1
-    sampleapp-alpha stop/waiting
-    sampleapp-alpha stop/waiting
-    sampleapp-alpha stop/waiting
-
-=== Good Upstart citizen
-
-All Upstart commands work as expected
-
-    $ start sampleapp
-    $ stop sampleapp
-    $ restart sampleapp
-
-=== Standardized Logging
-
-    /var/log/sampleapp/alpha.log
-    /var/log/sampleapp/bravo.log
-    /var/log/sampleapp/charlie.log
-
-== License
-
-MIT
-
-== Copyright
-
-(c) 2010 David Dollar

Rakefile

@@ -1,3 +1,7 @@
+require "rubygems"
+require "bundler"
+Bundler.setup
+
 require "rake"
 require "rspec"
 require "rspec/core/rake_task"
@@ -6,6 +10,7 @@ $:.unshift File.expand_path("../lib", __FILE__)
 require "foreman"
 
 task :default => :spec
+task :release => :man
 
 desc "Run all specs"
 Rspec::Core::RakeTask.new(:spec) do |t|
@@ -20,43 +25,32 @@ end
 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'
-
+task :man do
-begin
+  ENV['RONN_MANUAL']  = "Foreman Manual"
-  require 'jeweler'
+  ENV['RONN_ORGANIZATION'] = "Foreman #{Foreman::VERSION}"
-  Jeweler::Tasks.new do |s|
+  sh "ronn -w -s toc -r5 --markdown man/*.ronn"
-    s.name    = "foreman"
+end
-    s.version = Foreman::VERSION
+
-
+desc "Commit the manual to git"
-    s.summary     = "Process manager for applications with multiple components"
+task "man:commit" => :man do
-    s.description = s.summary
+  sh "git add README.markdown"
-    s.author      = "David Dollar"
+  sh "git commit -m 'update readme' || echo 'nothing to commit'"
-    s.email       = "ddollar@gmail.com"
+end
-    s.homepage    = "http://github.com/ddollar/foreman"
+
-
+desc "Generate the Github docs"
-    s.platform = Gem::Platform::RUBY
+task :pages => "man:commit" do
-    s.has_rdoc = false
+  sh %{
-
+    cp man/foreman.1.html /tmp/foreman.1.html
-    s.files = %w(Rakefile README.md) + Dir["{bin,lib,spec}/**/*"]
+    git checkout gh-pages
-    s.require_path = "lib"
+    rm ./index.html
-
+    cp /tmp/foreman.1.html ./index.html
-    # #s.bindir             = "bin"
+    git add -u index.html
-    # s.executables        = Dir["bin/*"]
+    git commit -m "saving man page to github docs"
-    s.default_executable = "foreman"
+    git push origin -f gh-pages
-
+    git checkout master
-    s.add_development_dependency 'fakefs', '~> 0.2.1'
+  }
-    s.add_development_dependency 'rake',   '~> 0.8.7'
-    s.add_development_dependency 'rcov',   '~> 0.9.8'
-    s.add_development_dependency 'rr',     '~> 0.10.11'
-    s.add_development_dependency 'rspec',  '~> 2.0.0'
-
-    s.add_dependency 'term-ansicolor', '~> 1.0.5'
-    s.add_dependency 'thor', '~> 0.13.6'
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install jeweler"
 end

data/example/Procfile

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

data/example/Procfile.without_colon

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

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,6 @@
+#!/usr/bin/env ruby
+
+while true
+  puts "tick: #{ARGV.inspect} -- FOO:#{ENV["FOO"]}"
+  sleep 1
+end

data/export/upstart/master.conf.erb

@@ -0,0 +1,8 @@
+pre-start script
+
+bash << "EOF"
+  mkdir -p <%= log_root %>
+  chown -R <%= user %> <%= log_root %>
+EOF
+
+end script

data/export/upstart/process.conf.erb

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

data/export/upstart/process_master.conf.erb

@@ -0,0 +1,2 @@
+start on starting <%= app %>
+stop on stopping <%= app %>

example/Procfile

@@ -1,2 +0,0 @@
-ticker ./ticker
-error  ./error

example/ticker

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-while true
-  puts "tick"
-  sleep 1
-end

foreman.gemspec

@@ -1,87 +1,29 @@
-# Generated by jeweler
+$:.unshift File.expand_path("../lib", __FILE__)
-# DO NOT EDIT THIS FILE DIRECTLY
+require "foreman/version"
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
 
-Gem::Specification.new do |s|
+Gem::Specification.new do |gem|
-  s.name = %q{foreman}
+  gem.name     = "foreman"
-  s.version = "0.3.2"
+  gem.version  = Foreman::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  gem.author   = "David Dollar"
-  s.authors = ["David Dollar"]
+  gem.email    = "ddollar@gmail.com"
-  s.date = %q{2010-06-22}
+  gem.homepage = "http://github.com/ddollar/foreman"
-  s.default_executable = %q{foreman}
+  gem.summary  = "Process manager for applications with multiple components"
-  s.description = %q{Process manager for applications with multiple components}
-  s.email = %q{ddollar@gmail.com}
-  s.executables = ["foreman"]
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    "Rakefile",
-     "bin/foreman",
-     "lib/foreman.rb",
-     "lib/foreman/cli.rb",
-     "lib/foreman/configuration.rb",
-     "lib/foreman/engine.rb",
-     "lib/foreman/export.rb",
-     "lib/foreman/export/upstart.rb",
-     "lib/foreman/process.rb",
-     "spec/foreman/cli_spec.rb",
-     "spec/foreman/configuration_spec.rb",
-     "spec/foreman/engine_spec.rb",
-     "spec/foreman/export/upstart_spec.rb",
-     "spec/foreman/export_spec.rb",
-     "spec/foreman/process_spec.rb",
-     "spec/foreman_spec.rb",
-     "spec/spec_helper.rb"
-  ]
-  s.has_rdoc = false
-  s.homepage = %q{http://github.com/ddollar/foreman}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Process manager for applications with multiple components}
-  s.test_files = [
-    "spec/foreman/cli_spec.rb",
-     "spec/foreman/configuration_spec.rb",
-     "spec/foreman/engine_spec.rb",
-     "spec/foreman/export/upstart_spec.rb",
-     "spec/foreman/export_spec.rb",
-     "spec/foreman/process_spec.rb",
-     "spec/foreman_spec.rb",
-     "spec/spec_helper.rb"
-  ]
 
-  if s.respond_to? :specification_version then
+  gem.description = gem.summary
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+  gem.executables = "foreman"
-      s.add_development_dependency(%q<fakefs>, ["~> 0.2.1"])
+  gem.files = Dir["**/*"].select { |d| d =~ %r{^(README|bin/|data/|ext/|lib/|spec/|test/)} }
-      s.add_development_dependency(%q<rake>, ["~> 0.8.7"])
+  gem.files << "man/foreman.1"
-      s.add_development_dependency(%q<rcov>, ["~> 0.9.8"])
+
-      s.add_development_dependency(%q<rr>, ["~> 0.10.11"])
+  gem.add_dependency 'term-ansicolor', '~> 1.0.5'
-      s.add_development_dependency(%q<rspec>, ["~> 2.0.0"])
+  gem.add_dependency 'thor',           '>= 0.13.6'
-      s.add_runtime_dependency(%q<term-ansicolor>, ["~> 1.0.5"])
+
-      s.add_runtime_dependency(%q<thor>, ["~> 0.13.6"])
+  gem.add_development_dependency 'parka'
-    else
+  gem.add_development_dependency 'rake'
-      s.add_dependency(%q<fakefs>, ["~> 0.2.1"])
+  gem.add_development_dependency 'ronn'
-      s.add_dependency(%q<rake>, ["~> 0.8.7"])
+  gem.add_development_dependency 'fakefs', '~> 0.2.1'
-      s.add_dependency(%q<rcov>, ["~> 0.9.8"])
+  gem.add_development_dependency 'rcov',   '~> 0.9.8'
-      s.add_dependency(%q<rr>, ["~> 0.10.11"])
+  gem.add_development_dependency 'rr',     '~> 1.0.2'
-      s.add_dependency(%q<rspec>, ["~> 2.0.0"])
+  gem.add_development_dependency 'rspec',  '~> 2.0.0'
-      s.add_dependency(%q<term-ansicolor>, ["~> 1.0.5"])
-      s.add_dependency(%q<thor>, ["~> 0.13.6"])
-    end
-  else
-    s.add_dependency(%q<fakefs>, ["~> 0.2.1"])
-    s.add_dependency(%q<rake>, ["~> 0.8.7"])
-    s.add_dependency(%q<rcov>, ["~> 0.9.8"])
-    s.add_dependency(%q<rr>, ["~> 0.10.11"])
-    s.add_dependency(%q<rspec>, ["~> 2.0.0"])
-    s.add_dependency(%q<term-ansicolor>, ["~> 1.0.5"])
-    s.add_dependency(%q<thor>, ["~> 0.13.6"])
-  end
 end
-

lib/foreman.rb

@@ -1,6 +1,6 @@
-module Foreman
+require "foreman/version"
 
-  VERSION = "0.3.2"
+module Foreman
 
   class AppDoesNotExist < Exception; end
 

lib/foreman/cli.rb

@@ -1,55 +1,79 @@
 require "foreman"
-require "foreman/configuration"
 require "foreman/engine"
 require "foreman/export"
 require "thor"
+require "yaml"
 
 class Foreman::CLI < Thor
 
-  desc "start [PROCFILE]", "Run the app described in PROCFILE"
+  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
 
-  def start(procfile="Procfile")
+  desc "start [PROCESS]", "Start the application, or a specific process"
-    error "#{procfile} does not exist." unless procfile_exists?(procfile)
+
-    Foreman::Engine.new(procfile).start
+  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)
+    end
   end
 
-  desc "execute PROCESS [PROCFILE]", "Run an instance of the specified process from PROCFILE"
+  desc "export FORMAT LOCATION", "Export the application to another process management format"
 
-  def execute(process, procfile="Procfile")
+  method_option :app,         :type => :string,  :aliases => "-a"
-    error "#{procfile} does not exist." unless procfile_exists?(procfile)
+  method_option :log,         :type => :string,  :aliases => "-l"
-    Foreman::Engine.new(procfile).execute(process)
+  method_option :port,        :type => :numeric, :aliases => "-p"
-  end
+  method_option :user,        :type => :string,  :aliases => "-u"
+  method_option :concurrency, :type => :string,  :aliases => "-c",
+    :banner => '"alpha=5,bar=3"'
 
-  desc "screen [PROCFILE]", "Run the app described in PROCFILE as screen windows"
+  def export(format, location=nil)
-
+    check_procfile!
-  def screen(procfile="Procfile")
-    error "#{procfile} does not exist." unless procfile_exists?(procfile)
-    Foreman::Engine.new(procfile).screen
-  end
-
-  desc "export APP [PROCFILE] [FORMAT]", "Export the app described in PROCFILE as APP to another FORMAT"
-
-  def export(app, procfile="Procfile", format="upstart")
-    error "#{procfile} does not exist." unless procfile_exists?(procfile)
 
     formatter = case format
+      when "inittab" then Foreman::Export::Inittab
       when "upstart" then Foreman::Export::Upstart
       else error "Unknown export format: #{format}."
     end
 
-    formatter.new(Foreman::Engine.new(procfile)).export(app)
+    formatter.new(engine).export(location, options)
+
+  rescue Foreman::Export::Exception => ex
+    error ex.message
   end
 
-  desc "scale APP PROCESS AMOUNT", "Change the concurrency of a given process type"
+  desc "check", "Validate your application's Procfile"
 
-  def scale(app, process, amount)
+  def check
-    config = Foreman::Configuration.new(app)
+    processes = engine.processes_in_order.map { |p| p.first }
-    error "No such process: #{process}." unless config.processes[process]
+    error "no processes defined" unless processes.length > 0
-    config.scale(process, amount)
+    display "valid procfile detected (#{processes.join(', ')})"
   end
 
 private ######################################################################
 
+  def check_procfile!
+    error("#{procfile} does not exist.") unless File.exist?(procfile)
+  end
+
+  def engine
+    @engine ||= Foreman::Engine.new(procfile)
+  end
+
+  def procfile
+    options[:procfile] || "Procfile"
+  end
+
+  def display(message)
+    puts message
+  end
+
   def error(message)
     puts "ERROR: #{message}"
     exit 1
@@ -59,4 +83,11 @@ 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/configuration.rb

@@ -1,55 +0,0 @@
-require "foreman"
-
-class Foreman::Configuration
-
-  attr_reader :app
-  attr_reader :processes
-
-  def initialize(app)
-    @app = app
-    @processes = {}
-    read_initial_config
-  end
-
-  def scale(process, amount)
-    old_amount = processes[process].to_i
-    processes[process] = amount.to_i
-    amount = amount.to_i
-
-    if (old_amount < amount)
-      ((old_amount + 1) .. amount).each { |num| system "start #{app}-#{process} NUM=#{num}" }
-    elsif (amount < old_amount)
-      ((amount + 1) .. old_amount).each { |num| system "stop #{app}-#{process} NUM=#{num}" }
-    end
-
-    write
-  end
-
-  def write
-    write_file "/etc/foreman/#{app}.conf", <<-UPSTART_CONFIG
-#{app}_processes="#{processes.keys.sort.join(' ')}"
-#{processes.keys.sort.map { |k| "#{app}_#{k}=\"#{processes[k]}\"" }.join("\n")}
-    UPSTART_CONFIG
-  end
-
-private ######################################################################
-
-  def read_initial_config
-    config = File.read("/etc/foreman/#{app}.conf").split("\n").inject({}) do |accum, line|
-      key, value = line.match(/^(.+?)\s*=\s*"(.+?)"\s*$/).captures
-      #accum.update(parts(1) => parts(2))
-      accum.update(key => value)
-    end
-    config["#{app}_processes"].split(" ").each do |process|
-      processes[process] = config["#{app}_#{process}"].to_i
-    end
-  rescue Errno::ENOENT
-  end
-
-  def write_file(filename, contents)
-    File.open(filename, "w") do |file|
-      file.puts contents
-    end
-  end
-
-end

lib/foreman/engine.rb

@@ -1,8 +1,10 @@
 require "foreman"
 require "foreman/process"
+require "foreman/utils"
 require "pty"
 require "tempfile"
 require "term/ansicolor"
+require "fileutils"
 
 class Foreman::Engine
 
@@ -11,7 +13,7 @@ class Foreman::Engine
 
   extend Term::ANSIColor
 
-  COLORS = [ cyan, yellow, green, magenta, on_blue ]
+  COLORS = [ cyan, yellow, green, magenta, red ]
 
   def initialize(procfile)
     @procfile  = read_procfile(procfile)
@@ -20,48 +22,81 @@ class Foreman::Engine
 
   def processes
     @processes ||= begin
+      @order = []
       procfile.split("\n").inject({}) do |hash, line|
         next if line.strip == ""
-        process = Foreman::Process.new(*line.split(" ", 2))
+        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
   end
 
-  def start
+  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])
+
     proctitle "ruby: foreman master"
 
-    processes.each do |name, process|
+    processes_in_order.each do |name, process|
-      fork process
+      fork process, options, environment
     end
 
-    trap("TERM") { kill_and_exit("TERM") }
+    trap("TERM") { puts "SIGTERM received"; kill_all("TERM") }
-    trap("INT")  { kill_and_exit("INT")  }
+    trap("INT")  { puts "SIGINT received";  kill_all("TERM")  }
 
     watch_for_termination
   end
 
-  def screen
+  def execute(name, options={})
-    tempfile = Tempfile.new("foreman")
+    environment = read_environment(options[:env])
-    tempfile.puts "sessionname foreman"
-    processes.each do |name, process|
-      tempfile.puts "screen -t #{name} #{process.command}"
-    end
-    tempfile.close
 
-    system "screen -c #{tempfile.path}"
+    fork processes[name], options, environment
 
-    tempfile.delete
+    trap("TERM") { puts "SIGTERM received"; kill_all("TERM") }
+    trap("INT")  { puts "SIGINT received";  kill_all("TERM")  }
+
+    watch_for_termination
   end
 
-  def execute(name)
+  def port_for(process, num, base_port=nil)
-    run(processes[name], false)
+    base_port ||= 5000
+    offset = processes_in_order.map { |p| p.first }.index(process.name) * 100
+    base_port.to_i + offset + num - 1
   end
 
 private ######################################################################
 
-  def fork(process)
+  def fork(process, options={}, environment={})
+    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)
+    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
@@ -70,32 +105,33 @@ private ######################################################################
     running_processes[pid] = process
   end
 
-  def run(process, log_to_file=true)
+  def run(process)
     proctitle "ruby: foreman #{process.name}"
 
-    Dir.chdir directory do
+    begin
-      FileUtils.mkdir_p "log"
+      Dir.chdir directory do
-      command = process.command
+        command = process.command
 
-      begin
         PTY.spawn("#{process.command} 2>&1") do |stdin, stdout, pid|
           until stdin.eof?
             info stdin.gets, process
           end
         end
-      rescue PTY::ChildExited
+      end
-        # exited
+    rescue PTY::ChildExited, Interrupt
+      begin
+        info "process exiting", process
+      rescue Interrupt
       end
     end
   end
 
-  def kill_and_exit(signal="TERM")
+  def kill_all(signal="TERM")
     info "terminating"
     running_processes.each do |pid, process|
       info "killing #{process.name} in pid #{pid}"
       Process.kill(signal, pid)
     end
-    exit 0
   end
 
   def info(message, process=nil)
@@ -106,6 +142,11 @@ private ######################################################################
     puts
   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
@@ -115,8 +156,8 @@ private ######################################################################
   end
 
   def pad_process_name(process)
-    name = process ? process.name : "system"
+    name = process ? "#{ENV["PS"]}" : "system"
-    name.ljust(longest_process_name)
+    name.ljust(longest_process_name + 3) # add 3 for process number padding
   end
 
   def print_info
@@ -138,7 +179,8 @@ private ######################################################################
     pid, status = Process.wait2
     process = running_processes.delete(pid)
     info "process terminated", process
-    kill_and_exit
+    kill_all
+    Process.waitall
   end
 
   def running_processes
@@ -151,4 +193,28 @@ private ######################################################################
     @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
+
+  def read_environment(filename)
+    error "No such file: #{filename}" if filename && !File.exists?(filename)
+    filename ||= ".env"
+    environment = {}
+
+    if File.exists?(filename)
+      File.read(filename).split("\n").each do |line|
+        if line =~ /\A([A-Za-z_]+)=(.*)\z/
+          environment[$1] = $2
+        end
+      end
+    end
+
+    environment
+  end
+
 end

lib/foreman/export.rb

@@ -1,6 +1,9 @@
 require "foreman"
 
 module Foreman::Export
+  class Exception < ::Exception; end
 end
 
+require "foreman/export/base"
+require "foreman/export/inittab"
 require "foreman/export/upstart"

lib/foreman/export/base.rb

@@ -0,0 +1,38 @@
+require "foreman/export"
+require "foreman/utils"
+
+class Foreman::Export::Base
+
+  attr_reader :engine
+
+  def initialize(engine)
+    @engine = engine
+  end
+
+  def export
+    raise "export method must be overridden"
+  end
+
+private ######################################################################
+
+  def error(message)
+    raise Foreman::Export::Exception.new(message)
+  end
+
+  def say(message)
+    puts "[foreman export] %s" % message
+  end
+
+  def export_template(name)
+    File.read(File.expand_path("../../../../data/export/#{name}", __FILE__))
+  end
+
+  def write_file(filename, contents)
+    say "writing: #{filename}"
+
+    File.open(filename, "w") do |file|
+      file.puts contents
+    end
+  end
+
+end

lib/foreman/export/inittab.rb

@@ -0,0 +1,38 @@
+require "foreman/export"
+
+class Foreman::Export::Inittab < Foreman::Export::Base
+
+  def export(fname=nil, options={})
+    app = options[:app] || File.basename(engine.directory)
+    user = options[:user] || app
+    log_root = options[:log] || "/var/log/#{app}"
+
+    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+
+    inittab = []
+    inittab << "# ----- foreman #{app} processes -----"
+
+    engine.processes.values.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])
+        inittab << "#{id}:4:respawn:/bin/su - #{user} -c 'PORT=#{port} #{process.command} >> #{log_root}/#{process.name}-#{num}.log 2>&1'"
+        index += 1
+      end
+      index
+    end
+
+    inittab << "# ----- end foreman #{app} processes -----"
+
+    inittab = inittab.join("\n") + "\n"
+
+    if fname
+      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
+    end
+  end
+
+end

lib/foreman/export/upstart.rb

@@ -1,65 +1,40 @@
-require "foreman/configuration"
+require "erb"
 require "foreman/export"
 
-class Foreman::Export::Upstart
+class Foreman::Export::Upstart < Foreman::Export::Base
 
-  attr_reader :engine
+  def export(location, options={})
+    error("Must specify a location") unless location
 
-  def initialize(engine)
+    FileUtils.mkdir_p location
-    @engine = engine
-  end
 
-  def export(app)
+    app = options[:app] || File.basename(engine.directory)
-    FileUtils.mkdir_p "/etc/foreman"
+    user = options[:user] || app
-    FileUtils.mkdir_p "/etc/init"
+    log_root = options[:log] || "/var/log/#{app}"
 
-    config = Foreman::Configuration.new(app)
+    Dir["#{location}/#{app}*.conf"].each do |file|
+      say "cleaning up: #{file}"
+      FileUtils.rm(file)
+    end
 
-    write_file "/etc/init/#{app}.conf", <<-UPSTART_MASTER
+    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
-pre-start script
 
-bash << "EOF"
+    master_template = export_template("upstart/master.conf.erb")
-  mkdir -p /var/log/#{app}
+    master_config   = ERB.new(master_template).result(binding)
+    write_file "#{location}/#{app}.conf", master_config
 
-  if [ -f /etc/foreman/#{app}.conf ]; then
+    process_template = export_template("upstart/process.conf.erb")
-    source /etc/foreman/#{app}.conf
-  fi
-
-  for process in $( echo "$#{app}_processes" ); do
-    process_count_config="#{app}_$process"
-    process_count=${!process_count_config}
-
-    for ((i=1; i<=${process_count:=1}; i+=1)); do
-      start #{app}-$process NUM=$i
-    done
-  done
-EOF
-
-end script
-    UPSTART_MASTER
 
     engine.processes.values.each do |process|
-      write_file "/etc/init/#{app}-#{process.name}.conf", <<-UPSTART_CHILD
+      process_master_template = export_template("upstart/process_master.conf.erb")
-instance $NUM
+      process_master_config   = ERB.new(process_master_template).result(binding)
-stop on stopping #{app}
+      write_file "#{location}/#{app}-#{process.name}.conf", process_master_config
-respawn
 
-chdir #{engine.directory}
+      1.upto(concurrency[process.name]) do |num|
-exec #{process.command} >>/var/log/#{app}/#{process.name}.log 2>&1
+        port = engine.port_for(process, num, options[:port])
-      UPSTART_CHILD
+        process_config = ERB.new(process_template).result(binding)
-    end
+        write_file "#{location}/#{app}-#{process.name}-#{num}.conf", process_config
-
+      end
-    engine.processes.each do |name, process|
-      config.processes[name] ||= 1
-    end
-    config.write
-  end
-
-private ######################################################################
-
-  def write_file(filename, contents)
-    File.open(filename, "w") do |file|
-      file.puts contents
     end
   end
 

lib/foreman/utils.rb

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

lib/foreman/version.rb

@@ -0,0 +1,5 @@
+module Foreman
+
+  VERSION = "0.16.0"
+
+end

man/foreman.1

@@ -0,0 +1,198 @@
+.\" 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"
+.
+.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\-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\.
+.
+.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
+inittab
+.
+.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
+You can validate your Procfile format using the \fBcheck\fR command
+.
+.IP "" 4
+.
+.nf
+
+$ foreman check
+.
+.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
+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

@@ -0,0 +1,144 @@
+foreman(1) -- manage Procfile-based applications
+================================================
+
+## SYNOPSIS
+
+`foreman start [process]`<br>
+`foreman export <format> [location]`
+
+## DESCRIPTION
+
+**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.
+
+## RUNNING
+
+`foreman start` is used to run your application directly from the command line.
+
+If no additional parameters are passed, foreman will run one instance of each
+type of process defined in your Procfile.
+
+If a parameter is passed, foreman will run one instance of the specified
+application type.
+
+The following options control how the application is run:
+
+  * `-c`, `--concurrency`:
+    Specify the number of each process type to run. The value passed in
+    should be in the format `process=num,process=num`
+
+  * `-p`, `--port`:
+    Specify which port to use as the base for this application. Should be
+    a multiple of 1000.
+
+## EXPORTING
+
+`foreman export` is used to export your application to another process
+management format.
+
+An location to export can be passed as an argument. This argument may be
+either required or optional depending on the export format.
+
+The following options control how the application is run:
+
+  * `-a`, `--app`:
+    Use this name rather than the application's root directory name as the
+    name of the application when exporting.
+
+  * `-c`, `--concurrency`:
+    Specify the number of each process type to run. The value passed in
+    should be in the format `process=num,process=num`
+
+  * `-l`, `--log`:
+    Specify the directory to place process logs in.
+
+  * `-p`, `--port`:
+    Specify which port to use as the base for this application. Should be
+    a multiple of 1000.
+
+  * `-u`, `--user`:
+    Specify the user the application should be run as. Defaults to the
+    app name
+
+## OPTIONS
+
+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.
+
+  * `-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
+    application.
+
+## EXPORT FORMATS
+
+foreman currently supports the following output formats:
+
+  * inittab
+
+  * upstart
+
+## INITTAB EXPORT
+
+Will export a chunk of inittab-compatible configuration:
+
+    # ----- 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 -----
+
+## UPSTART EXPORT
+
+Will create a series of upstart scripts in the location you specify. Scripts
+will be structured to make the following commands valid:
+
+  `start appname`
+
+  `stop appname-processname`
+
+  `restart appname-processname-3`
+
+## PROCFILE
+
+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
+
+You can validate your Procfile format using the `check` command
+
+    $ foreman check
+
+## 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
+    port: 15000
+
+## EXAMPLES
+
+Start one instance of each process type, interleave the output on stdout:
+
+    $ foreman start
+
+Export the application in upstart format:
+
+    $ foreman export upstart /etc/init
+
+Run one process type from the application defined in a specific Procfile:
+
+    $ foreman start alpha -p ~/myapp/Procfile
+
+## COPYRIGHT
+
+Foreman is Copyright (C) 2010 David Dollar <http://daviddollar.org>

spec/foreman/cli_spec.rb

@@ -19,33 +19,12 @@ 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 "execute" do
-    describe "with a non-existent Procfile" do
-      it "prints an error" do
-        mock_error(subject, "Procfile does not exist.") do
-          dont_allow.instance_of(Foreman::Engine).start
-          subject.execute("alpha")
-        end
-      end
-    end
-
-    describe "with a Procfile" do
-      before(:each) { write_procfile }
-
-      it "runs successfully" do
-        dont_allow(subject).error
-        mock.instance_of(Foreman::Engine).execute("alpha")
-        subject.execute("alpha")
-      end
-    end
-  end
-
   describe "export" do
     describe "with a non-existent Procfile" do
       it "prints an error" do
@@ -62,7 +41,7 @@ describe "Foreman::CLI" do
       describe "with an invalid formatter" do
         it "prints an error" do
           mock_error(subject, "Unknown export format: invalidformatter.") do
-            subject.export("testapp", "Procfile", "invalidformatter")
+            subject.export("invalidformatter")
           end
         end
       end
@@ -72,33 +51,31 @@ describe "Foreman::CLI" do
 
         it "runs successfully" do
           dont_allow(subject).error
-          subject.export("testapp")
+          mock.instance_of(Foreman::Export::Upstart).export("/tmp/foo", {})
+          subject.export("upstart", "/tmp/foo")
         end
       end
     end
   end
 
-  describe "scale" do
+  describe "check" do
-    describe "without an existing configuration" do
+    describe "with a valid Procfile" do
-      it "displays an error" do
+      before { write_procfile }
-        mock_error(subject, "No such process: alpha.") do
+
-          subject.scale("testapp", "alpha", "2")
+      it "displays the jobs" do
-        end
+        mock(subject).display("valid procfile detected (alpha, bravo)")
+        subject.check
       end
     end
 
-    describe "with an existing configuration" do
+    describe "with a blank Procfile" do
-      before(:each) { write_foreman_config("testapp") }
+      before do
-
+        FileUtils.touch("Procfile")
-      it "scales a process that exists" do
-        mock.instance_of(Foreman::Configuration).scale("alpha", "2")
-        subject.scale("testapp", "alpha", "2")
       end
 
-      it "errors if a process that does not exist is specified" do
+      it "displays an error" do
-        mock_error(subject, "No such process: invalidprocess.") do
+        mock_error(subject, "no processes defined") do
-          dont_allow.instance_of(Foreman::Configuration).scale
+          subject.check
-          subject.scale("testapp", "invalidprocess", "2")
         end
       end
     end

spec/foreman/configuration_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-require "foreman/configuration"
-
-describe "Foreman::Configuration" do
-  subject { Foreman::Configuration.new("testapp") }
-
-  describe "initialize" do
-    describe "without an existing config" do
-      it "has no processes" do
-        subject.processes.length.should == 0
-      end
-    end
-
-    describe "with an existing config" do
-      it "has processes" do
-        write_foreman_config("testapp")
-        subject.processes["alpha"].should == 1
-        subject.processes["bravo"].should == 2
-      end
-    end
-  end
-
-  describe "scale" do
-    before(:each) { write_foreman_config("testapp") }
-
-    it "can scale up" do
-      mock(subject).system("start testapp-alpha NUM=2")
-      mock(subject).system("start testapp-alpha NUM=3")
-      subject.scale("alpha", 3)
-    end
-
-    it "can scale down" do
-      mock(subject).system("stop testapp-bravo NUM=2")
-      subject.scale("bravo", 1)
-    end
-  end
-  
-  describe "wite" do
-    it "can write a configuration file" do
-      subject.scale("charlie", 3)
-      subject.scale("delta", 4)
-      File.read("/etc/foreman/testapp.conf").should == <<-FOREMAN_CONFIG
-testapp_processes="charlie delta"
-testapp_charlie="3"
-testapp_delta="4"
-      FOREMAN_CONFIG
-    end
-  end
-end

spec/foreman/engine_spec.rb

@@ -10,31 +10,80 @@ describe "Foreman::Engine" do
         lambda { subject }.should raise_error
       end
     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"
       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
+      end
+    end
   end
-  
+
   describe "start" do
     it "forks the processes" do
       write_procfile
-      mock(subject).fork(subject.processes["alpha"])
+      mock(subject).fork(subject.processes["alpha"], {}, {})
-      mock(subject).fork(subject.processes["bravo"])
+      mock(subject).fork(subject.processes["bravo"], {}, {})
       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).run(subject.processes["alpha"], false)
+      mock(subject).fork(subject.processes["alpha"], {}, {})
+      mock(subject).watch_for_termination
       subject.execute("alpha")
     end
   end
+
+  describe "environment" 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")
+    end
+
+    it "should fail if specified and doesnt exist" do
+      mock(subject).error("No such file: /tmp/env")
+      subject.execute("alpha", :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")
+    end
+  end
 end

spec/foreman/export/upstart_spec.rb

@@ -1,2 +1,22 @@
 require "spec_helper"
+require "foreman/engine"
 require "foreman/export/upstart"
+
+describe Foreman::Export::Upstart do
+  let(:engine) { Foreman::Engine.new(write_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/foreman.conf").should         == example_export_file("upstart/foreman.conf")
+    File.read("/tmp/init/foreman-alpha.conf").should   == example_export_file("upstart/foreman-alpha.conf")
+    File.read("/tmp/init/foreman-alpha-1.conf").should == example_export_file("upstart/foreman-alpha-1.conf")
+    File.read("/tmp/init/foreman-alpha-2.conf").should == example_export_file("upstart/foreman-alpha-2.conf")
+    File.read("/tmp/init/foreman-bravo.conf").should   == example_export_file("upstart/foreman.bravo.conf")
+    File.read("/tmp/init/foreman-bravo-1.conf").should == example_export_file("upstart/foreman-bravo-1.conf")
+  end
+end

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

@@ -0,0 +1,6 @@
+start on starting foreman-alpha
+stop on stopping foreman-alpha
+respawn
+
+chdir /Users/david/Code/foreman
+exec su foreman -c 'export PORT=5000; ./alpha >> /var/log/foreman/alpha-1.log 2>&1'

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

@@ -0,0 +1,6 @@
+start on starting foreman-alpha
+stop on stopping foreman-alpha
+respawn
+
+chdir /Users/david/Code/foreman
+exec su foreman -c 'export PORT=5001; ./alpha >> /var/log/foreman/alpha-2.log 2>&1'

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

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

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

@@ -0,0 +1,6 @@
+start on starting foreman-bravo
+stop on stopping foreman-bravo
+respawn
+
+chdir /Users/david/Code/foreman
+exec su foreman -c 'export PORT=5100; ./bravo >> /var/log/foreman/bravo-1.log 2>&1'

spec/resources/export/upstart/foreman.bravo.conf

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

spec/resources/export/upstart/foreman.conf

@@ -0,0 +1,8 @@
+pre-start script
+
+bash << "EOF"
+  mkdir -p /var/log/foreman
+  chown -R foreman /var/log/foreman
+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
@@ -26,9 +26,30 @@ end
 
 def write_procfile(procfile="Procfile")
   File.open(procfile, "w") do |file|
-    file.puts "alpha ./alpha"
+    file.puts "alpha: ./alpha"
-    file.puts "bravo ./bravo"
+    file.puts "bravo: ./bravo"
   end
+  File.expand_path(procfile)
+end
+
+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
 
 Rspec.configure do |config|