update manual

Bluepill export

.env

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

.gitignore

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

Gemfile

@@ -1,16 +1,3 @@
 source "http://rubygems.org"
 
-group :development do
-  gem 'parka'
-  gem 'rake'
-end
-
-group :test do
-  gem 'fakefs', '~> 0.2.1'
-  gem 'rcov',   '~> 0.9.8'
-  gem 'rr',     '~> 0.10.11'
-  gem 'rspec',  '~> 2.0.0.beta.19'
-end
-
-gem 'term-ansicolor', '~> 1.0.5'
-gem 'thor',           '~> 0.13.6'
+gemspec

Gemfile.lock

@@ -1,37 +1,53 @@
+PATH
+  remote: .
+  specs:
+    foreman (0.21.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)
-    parka (0.3.1)
+    mustache (0.11.2)
+    parka (0.6.2)
+      crack
       rest-client
       thor
-    rake (0.8.7)
+    rake (0.9.2)
     rcov (0.9.8)
-    rest-client (1.6.0)
+    rdiscount (1.6.5)
+    rest-client (1.6.1)
       mime-types (>= 1.16)
-    rr (0.10.11)
-    rspec (2.0.0.beta.19)
-      rspec-core (= 2.0.0.beta.19)
-      rspec-expectations (= 2.0.0.beta.19)
-      rspec-mocks (= 2.0.0.beta.19)
-    rspec-core (2.0.0.beta.19)
-    rspec-expectations (2.0.0.beta.19)
-      diff-lcs (>= 1.1.2)
-    rspec-mocks (2.0.0.beta.19)
-    term-ansicolor (1.0.5)
-    thor (0.13.8)
+    ronn (0.7.3)
+      hpricot (>= 0.8.2)
+      mustache (>= 0.7.0)
+      rdiscount (>= 1.5.8)
+    rr (1.0.2)
+    rspec (2.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)
+    term-ansicolor (1.0.6)
+    thor (0.14.6)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   fakefs (~> 0.2.1)
+  foreman!
   parka
   rake
   rcov (~> 0.9.8)
-  rr (~> 0.10.11)
-  rspec (~> 2.0.0.beta.19)
-  term-ansicolor (~> 1.0.5)
-  thor (~> 0.13.6)
+  ronn
+  rr (~> 1.0.2)
+  rspec (~> 2.6.0)

README.markdown

@@ -1,4 +1,30 @@
-Foreman
-=======
+# 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.
+
+## Authorship
+
+Created by David Dollar
+
+Patches contributed by:
+
+* Adam Wiggins
+* clifff
+* Dan Peterson
+* Jay Zeschin
+* Keith Rarick
+* Ricardo Chimal, Jr
+
+## License
+
+MIT

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,10 +22,10 @@ task :rcov => "rcov:build" do
   %x{ open coverage/index.html }
 end
 
-Rspec::Core::RakeTask.new("rcov:build") do |t|
+RSpec::Core::RakeTask.new("rcov:build") do |t|
   t.pattern = 'spec/**/*_spec.rb'
   t.rcov = true
-  t.rcov_opts = [ "--exclude", Gem.default_dir , "--exclude", "spec" ]
+  t.rcov_opts = [ "--exclude", ".bundle", "--exclude", "spec" ]
 end
 
 desc 'Build the manual'
@@ -33,18 +33,23 @@ task :man do
   ENV['RONN_MANUAL']  = "Foreman Manual"
   ENV['RONN_ORGANIZATION'] = "Foreman #{Foreman::VERSION}"
   sh "ronn -w -s toc -r5 --markdown man/*.ronn"
+end
+
+desc "Commit the manual to git"
+task "man:commit" => :man do
   sh "git add README.markdown"
   sh "git commit -m 'update readme' || echo 'nothing to commit'"
 end
 
-task :pages => :man do
+desc "Generate the Github docs"
+task :pages => "man:commit" do
   sh %{
     cp man/foreman.1.html /tmp/foreman.1.html
     git checkout gh-pages
     rm ./index.html
     cp /tmp/foreman.1.html ./index.html
     git add -u index.html
-    git commit -m "rebuilding man page"
+    git commit -m "saving man page to github docs"
     git push origin -f gh-pages
     git checkout master
   }

bin/foreman-runner

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

data/example/Procfile

@@ -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,12 @@
+#!/usr/bin/env ruby
+
+%w( SIGINT SIGTERM SIGHUP ).each do |signal|
+  trap(signal) do
+    puts "received #{signal} but i'm ignoring it!"
+  end
+end
+
+while true
+  puts "tick: #{ARGV.inspect} -- FOO:#{ENV["FOO"]}"
+  sleep 1
+end

data/export/bluepill/master.pill.erb

@@ -0,0 +1,27 @@
+Bluepill.application("<%= app %>", :foreground => false, :log_file => "/var/log/bluepill.log") do |app|
+
+  app.uid = "<%= user %>"
+  app.gid = "<%= user %>"
+
+<% engine.processes.values.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/upstart/process.conf.erb

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

example/ticker

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

export/upstart/process.conf.erb

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

foreman.gemspec

@@ -1,9 +1,29 @@
-require "rubygems"
-require "parka/specification"
+$:.unshift File.expand_path("../lib", __FILE__)
+require "foreman/version"
 
-Parka::Specification.new do |gem|
+Gem::Specification.new do |gem|
   gem.name     = "foreman"
   gem.version  = Foreman::VERSION
-  gem.summary  = "Process manager for applications with multiple components"
+
+  gem.author   = "David Dollar"
+  gem.email    = "ddollar@gmail.com"
   gem.homepage = "http://github.com/ddollar/foreman"
+  gem.summary  = "Process manager for applications with multiple components"
+
+  gem.description = gem.summary
+
+  gem.executables = "foreman"
+  gem.files = Dir["**/*"].select { |d| d =~ %r{^(README|bin/|data/|ext/|lib/|spec/|test/)} }
+  gem.files << "man/foreman.1"
+
+  gem.add_dependency 'term-ansicolor', '~> 1.0.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.6.0'
 end

lib/foreman.rb

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

lib/foreman/cli.rb

@@ -2,24 +2,25 @@ require "foreman"
 require "foreman/engine"
 require "foreman/export"
 require "thor"
+require "yaml"
 
 class Foreman::CLI < Thor
 
-  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: ./Procfile"
+  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
 
   desc "start [PROCESS]", "Start the application, or a specific process"
 
+  method_option :env,         :type => :string,  :aliases => "-e", :desc => "Specify an environment file to load, defaults to .env"
   method_option :port,        :type => :numeric, :aliases => "-p"
-  method_option :concurrency, :type => :string,  :aliases => "-c",
-    :banner => '"alpha=5,bar=3"'
+  method_option :concurrency, :type => :string,  :aliases => "-c", :banner => '"alpha=5,bar=3"'
 
   def start(process=nil)
     check_procfile!
 
     if process
-      engine.execute(process, options)
+      engine.execute(process)
     else
-      engine.start(options)
+      engine.start
     end
   end
 
@@ -29,6 +30,7 @@ class Foreman::CLI < Thor
   method_option :log,         :type => :string,  :aliases => "-l"
   method_option :port,        :type => :numeric, :aliases => "-p"
   method_option :user,        :type => :string,  :aliases => "-u"
+  method_option :template,    :type => :string,  :aliases => "-t"
   method_option :concurrency, :type => :string,  :aliases => "-c",
     :banner => '"alpha=5,bar=3"'
 
@@ -36,8 +38,9 @@ class Foreman::CLI < Thor
     check_procfile!
 
     formatter = case format
-      when "upstart" then Foreman::Export::Upstart
       when "inittab" then Foreman::Export::Inittab
+      when "upstart" then Foreman::Export::Upstart
+      when "bluepill" then Foreman::Export::Bluepill
       else error "Unknown export format: #{format}."
     end
 
@@ -47,21 +50,31 @@ class Foreman::CLI < Thor
     error ex.message
   end
 
+  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(', ')})"
+  end
+
 private ######################################################################
 
   def check_procfile!
-    error("Procfile does not exist.") unless File.exist?(procfile)
+    error("#{procfile} does not exist.") unless File.exist?(procfile)
   end
 
   def engine
-    @engine ||= Foreman::Engine.new(procfile)
+    @engine ||= Foreman::Engine.new(procfile, options)
   end
 
   def procfile
-    options[:procfile] || "./Procfile"
+    options[:procfile] || "Procfile"
   end
 
-private ######################################################################
+  def display(message)
+    puts message
+  end
 
   def error(message)
     puts "ERROR: #{message}"
@@ -72,4 +85,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/engine.rb

@@ -3,6 +3,7 @@ require "foreman/process"
 require "foreman/utils"
 require "pty"
 require "tempfile"
+require "timeout"
 require "term/ansicolor"
 require "fileutils"
 
@@ -10,68 +11,93 @@ class Foreman::Engine
 
   attr_reader :procfile
   attr_reader :directory
+  attr_reader :environment
+  attr_reader :options
 
   extend Term::ANSIColor
 
   COLORS = [ cyan, yellow, green, magenta, red ]
 
-  def initialize(procfile)
+  def initialize(procfile, options={})
     @procfile  = read_procfile(procfile)
     @directory = File.expand_path(File.dirname(procfile))
+    @options = options
+    @environment = read_environment(options[:env])
   end
 
   def processes
     @processes ||= begin
+      @order = []
       procfile.split("\n").inject({}) do |hash, line|
-        next if line.strip == ""
-        name, command = line.split(" ", 2)
+        next hash 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
   end
 
-  def start(options={})
+  def process_order
+    processes
+    @order.uniq
+  end
+
+  def processes_in_order
+    process_order.map do |name|
+      [name, processes[name]]
+    end
+  end
+
+  def start
     proctitle "ruby: foreman master"
 
-    processes.each do |name, process|
-      fork process, options
+    processes_in_order.each do |name, process|
+      fork process
     end
 
-    trap("TERM") { kill_and_exit("TERM") }
-    trap("INT")  { kill_and_exit("INT")  }
+    trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
+    trap("INT")  { puts "SIGINT received";  terminate_gracefully }
 
     watch_for_termination
   end
 
-  def execute(name, options={})
-    fork processes[name], options
+  def execute(name)
 
-    trap("TERM") { kill_and_exit("TERM") }
-    trap("INT")  { kill_and_exit("INT")  }
+    fork processes[name]
+
+    trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
+    trap("INT")  { puts "SIGINT received";  terminate_gracefully }
 
     watch_for_termination
   end
 
   def port_for(process, num, base_port=nil)
     base_port ||= 5000
-    offset = processes.keys.sort.index(process.name) * 100
+    offset = processes_in_order.map { |p| p.first }.index(process.name) * 100
     base_port.to_i + offset + num - 1
   end
 
 private ######################################################################
 
-  def fork(process, options={})
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+  def fork(process)
+    concurrency = Foreman::Utils.parse_concurrency(@options[:concurrency])
 
     1.upto(concurrency[process.name]) do |num|
-      fork_individual(process, port_for(process, num, options[:port]))
+      fork_individual(process, num, port_for(process, num, @options[:port]))
     end
   end
 
-  def fork_individual(process, port)
+  def fork_individual(process, num, port)
+    @environment.each { |k,v| ENV[k] = v }
+
     ENV["PORT"] = port.to_s
+    ENV["PS"]   = "#{process.name}.#{num}"
 
     pid = Process.fork do
       run(process)
@@ -81,32 +107,31 @@ private ######################################################################
     running_processes[pid] = process
   end
 
-  def run(process, log_to_file=true)
+  def run(process)
     proctitle "ruby: foreman #{process.name}"
+    trap("SIGINT", "IGNORE")
 
-    Dir.chdir directory do
-      FileUtils.mkdir_p "log"
-      command = process.command
-
-      begin
-        PTY.spawn("#{process.command} 2>&1") do |stdin, stdout, pid|
+    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
-      rescue PTY::ChildExited, Interrupt
+      end
+    rescue PTY::ChildExited, Interrupt, Errno::EIO
+      begin
         info "process exiting", process
+      rescue Interrupt
       end
     end
   end
 
-  def kill_and_exit(signal="TERM")
-    info "terminating"
+  def kill_all(signal="SIGTERM")
     running_processes.each do |pid, process|
-      info "killing #{process.name} in pid #{pid}"
-      Process.kill(signal, pid)
+      Process.kill(signal, pid) rescue Errno::ESRCH
     end
-    exit 0
   end
 
   def info(message, process=nil)
@@ -117,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
@@ -126,8 +156,8 @@ private ######################################################################
   end
 
   def pad_process_name(process)
-    name = process ? "#{process.name}:#{ENV["PORT"]}" : "system"
-    name.ljust(longest_process_name + 6) # add 6 for port padding
+    name = process ? "#{ENV["PS"]}" : "system"
+    name.ljust(longest_process_name + 3) # add 3 for process number padding
   end
 
   def print_info
@@ -149,7 +179,9 @@ private ######################################################################
     pid, status = Process.wait2
     process = running_processes.delete(pid)
     info "process terminated", process
-    kill_and_exit
+    terminate_gracefully
+    kill_all
+  rescue Errno::ECHILD
   end
 
   def running_processes
@@ -162,4 +194,41 @@ 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
+
+  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"
+  end
+
 end

lib/foreman/export.rb

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

lib/foreman/export/base.rb

@@ -23,8 +23,14 @@ private ######################################################################
     puts "[foreman export] %s" % message
   end
 
-  def export_template(name)
-    File.read(File.expand_path("../../../../export/#{name}", __FILE__))
+  def export_template(exporter, file, template_root)
+    if template_root && File.exist?(file_path = File.join(template_root, file))
+      File.read(file_path)
+    elsif File.exist?(file_path = File.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,29 @@
+require "erb"
+require "foreman/export"
+
+class Foreman::Export::Bluepill < Foreman::Export::Base
+
+  def export(location, options={})
+    error("Must specify a location") unless location
+
+    FileUtils.mkdir_p location
+
+    app = options[:app] || File.basename(engine.directory)
+    user = options[:user] || app
+    log_root = options[:log] || "/var/log/#{app}"
+    template_root = options[:template]
+
+    Dir["#{location}/#{app}.pill"].each do |file|
+      say "cleaning up: #{file}"
+      FileUtils.rm(file)
+    end
+
+    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+
+    master_template = export_template("bluepill", "master.pill.erb", template_root)
+    master_config   = ERB.new(master_template).result(binding)
+    write_file "#{location}/#{app}.pill", master_config
+
+  end
+
+end

lib/foreman/export/inittab.rb

@@ -1,4 +1,4 @@
-require "foreman/export/base"
+require "foreman/export"
 
 class Foreman::Export::Inittab < Foreman::Export::Base
 
@@ -27,8 +27,8 @@ class Foreman::Export::Inittab < Foreman::Export::Base
     inittab = inittab.join("\n") + "\n"
 
     if fname
-      FileUtils.mkdir_p(log_root)
-      FileUtils.chown(user, nil, log_root)
+      FileUtils.mkdir_p(log_root) rescue error "could not create #{log_root}"
+      FileUtils.chown(user, nil, log_root) rescue error "could not chown #{log_root} to #{user}"
       write_file(fname, inittab)
     else
       puts inittab

lib/foreman/export/upstart.rb

@@ -1,5 +1,5 @@
 require "erb"
-require "foreman/export/base"
+require "foreman/export"
 
 class Foreman::Export::Upstart < Foreman::Export::Base
 
@@ -11,6 +11,7 @@ class Foreman::Export::Upstart < Foreman::Export::Base
     app = options[:app] || File.basename(engine.directory)
     user = options[:user] || app
     log_root = options[:log] || "/var/log/#{app}"
+    template_root = options[:template]
 
     Dir["#{location}/#{app}*.conf"].each do |file|
       say "cleaning up: #{file}"
@@ -19,14 +20,14 @@ 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")
+      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/version.rb

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

man/foreman.1

@@ -0,0 +1,215 @@
+.\" generated with Ronn/v0.7.3
+.\" http://github.com/rtomayko/ronn/tree/0.7.3
+.
+.TH "FOREMAN" "1" "September 2011" "Foreman 0.21.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 an alternate environment file\.
+.
+.TP
+\fB\-f\fR, \fB\-\-procfile\fR
+Specify an alternate location for the application\'s Procfile\. This file\'s containing directory will be assumed to be the root directory of the application\.
+.
+.SH "EXPORT FORMATS"
+foreman currently supports the following output formats:
+.
+.IP "\(bu" 4
+bluepill
+.
+.IP "\(bu" 4
+inittab
+.
+.IP "\(bu" 4
+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 "ENVIRONMENT"
+If a \fB\.env\fR file exists in the current directory, the default environment will be read from it\. This file should contain key/value pairs, separated by \fB=\fR, with one key/value pair per line\.
+.
+.IP "" 4
+.
+.nf
+
+FOO=bar
+BAZ=qux
+.
+.fi
+.
+.IP "" 0
+.
+.SH "DEFAULT OPTIONS"
+If a \fB\.foreman\fR file exists in the current directory, default options will be read from it\. This file should be in YAML format with the long option name as keys\. Example:
+.
+.IP "" 4
+.
+.nf
+
+concurrency: alpha=0
+port: 15000
+.
+.fi
+.
+.IP "" 0
+.
+.SH "EXAMPLES"
+Start one instance of each process type, interleave the output on stdout:
+.
+.IP "" 4
+.
+.nf
+
+$ foreman start
+.
+.fi
+.
+.IP "" 0
+.
+.P
+Export the application in upstart format:
+.
+.IP "" 4
+.
+.nf
+
+$ foreman export upstart /etc/init
+.
+.fi
+.
+.IP "" 0
+.
+.P
+Run one process type from the application defined in a specific Procfile:
+.
+.IP "" 4
+.
+.nf
+
+$ foreman start alpha \-p ~/myapp/Procfile
+.
+.fi
+.
+.IP "" 0
+.
+.SH "COPYRIGHT"
+Foreman is Copyright (C) 2010 David Dollar \fIhttp://daviddollar\.org\fR

man/foreman.1.ronn

@@ -66,6 +66,9 @@ The following options control how the application is run:
 
 These options control all modes of foreman's operation.
 
+  * `-e`, `--env`:
+    Specify an alternate environment file.
+
   * `-f`, `--procfile`:
     Specify an alternate location for the application's Procfile. This file's
     containing directory will be assumed to be the root directory of the
@@ -75,6 +78,8 @@ These options control all modes of foreman's operation.
 
 foreman currently supports the following output formats:
 
+  * bluepill
+
   * inittab
 
   * upstart
@@ -104,8 +109,30 @@ will be structured to make the following commands valid:
 A Procfile should contain both a name for the process and the command used
 to run it.
 
-    web  bundle exec thin start
-    job  bundle exec rake jobs:work
+    web: bundle exec thin start
+    job: bundle exec rake jobs:work
+
+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
+    port: 15000
 
 ## EXAMPLES
 
@@ -119,7 +146,7 @@ Export the application in upstart format:
 
 Run one process type from the application defined in a specific Procfile:
 
-    $ foreman start alpha -p ~/app/Procfile
+    $ foreman start alpha -p ~/myapp/Procfile
 
 ## COPYRIGHT
 

spec/foreman/cli_spec.rb

@@ -19,7 +19,7 @@ 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
@@ -58,4 +58,27 @@ describe "Foreman::CLI" do
     end
   end
 
+  describe "check" do
+    describe "with a valid Procfile" do
+      before { write_procfile }
+
+      it "displays the jobs" do
+        mock(subject).display("valid procfile detected (alpha, bravo)")
+        subject.check
+      end
+    end
+
+    describe "with a blank Procfile" do
+      before do
+        FileUtils.touch("Procfile")
+      end
+
+      it "displays an error" do
+        mock_error(subject, "no processes defined") do
+          subject.check
+        end
+      end
+    end
+  end
+
 end

spec/foreman/engine_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "foreman/engine"
 
 describe "Foreman::Engine" do
-  subject { Foreman::Engine.new("Procfile") }
+  subject { Foreman::Engine.new("Procfile", {}) }
 
   describe "initialize" do
     describe "without an existing Procfile" do
@@ -12,39 +12,86 @@ describe "Foreman::Engine" do
     end
 
     describe "with a Procfile" do
+      before { write_procfile }
+
       it "reads the processes" do
-        write_procfile
         subject.processes["alpha"].command.should == "./alpha"
         subject.processes["bravo"].command.should == "./bravo"
       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["bravo"], {})
+      mock(subject).fork(subject.processes["alpha"])
+      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"], 5000)
-      mock(subject).fork_individual(subject.processes["alpha"], 5001)
-      mock(subject).fork_individual(subject.processes["bravo"], 5100)
-      mock(subject).watch_for_termination
-      subject.start(:concurrency => "alpha=2")
+      engine = Foreman::Engine.new("Procfile",:concurrency => "alpha=2")
+      mock(engine).fork_individual(engine.processes["alpha"], 1, 5000)
+      mock(engine).fork_individual(engine.processes["alpha"], 2, 5001)
+      mock(engine).fork_individual(engine.processes["bravo"], 1, 5100)
+      mock(engine).watch_for_termination
+      engine.start
     end
   end
 
   describe "execute" do
     it "runs the processes" do
       write_procfile
-      mock(subject).fork(subject.processes["alpha"], {})
+      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
+    end
+
+    it "should read if specified" do
+      File.open("/tmp/env", "w") { |f| f.puts("FOO=baz") }
+      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
+      stub(engine).info
+      mock(engine).watch_for_termination
+      engine.environment.should == {"FOO"=>"baz"}
+      engine.execute("alpha")
+    end
+
+    it "should fail if specified and doesnt exist" do
+      mock.instance_of(Foreman::Engine).error("No such file: /tmp/env")
+      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
+    end
+
+    it "should read .env if none specified" do
+      File.open(".env", "w") { |f| f.puts("FOO=qoo") }
+      engine = Foreman::Engine.new("Procfile")
+      stub(engine).info
+      mock(engine).watch_for_termination
+      mock(engine).fork_individual(anything, anything, anything)
+      engine.environment.should == {"FOO"=>"qoo"}
+      engine.execute("bravo")
+    end
+  end
 end

spec/foreman/export/bluepill_spec.rb

@@ -0,0 +1,20 @@
+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")
+    
+    File.read("/tmp/init/app.pill").should == example_export_file("bluepill/app.pill")
+  end
+
+end

spec/foreman/export/upstart_spec.rb

@@ -1,2 +1,55 @@
 require "spec_helper"
+require "foreman/engine"
 require "foreman/export/upstart"
+require "tmpdir"
+
+describe Foreman::Export::Upstart do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:engine) { Foreman::Engine.new(procfile) }
+  let(:upstart) { Foreman::Export::Upstart.new(engine) }
+
+  before(:each) { load_export_templates_into_fakefs("upstart") }
+  before(:each) { stub(upstart).say }
+
+  it "exports to the filesystem" do
+    upstart.export("/tmp/init")
+
+    File.read("/tmp/init/app.conf").should         == example_export_file("upstart/app.conf")
+    File.read("/tmp/init/app-alpha.conf").should   == example_export_file("upstart/app-alpha.conf")
+    File.read("/tmp/init/app-alpha-1.conf").should == example_export_file("upstart/app-alpha-1.conf")
+    File.read("/tmp/init/app-alpha-2.conf").should == example_export_file("upstart/app-alpha-2.conf")
+    File.read("/tmp/init/app-bravo.conf").should   == example_export_file("upstart/app-bravo.conf")
+    File.read("/tmp/init/app-bravo-1.conf").should == example_export_file("upstart/app-bravo-1.conf")
+  end
+
+  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/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/upstart/app-alpha-1.conf

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

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

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

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

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

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

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

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

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

spec/resources/export/upstart/app.conf

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

spec/spec_helper.rb

@@ -3,7 +3,7 @@ require "rspec"
 require "fakefs/safe"
 require "fakefs/spec_helpers"
 
-$:.unshift "lib"
+$:.unshift File.expand_path("../../lib", __FILE__)
 
 def mock_error(subject, message)
   mock_exit do
@@ -26,12 +26,34 @@ end
 
 def write_procfile(procfile="Procfile")
   File.open(procfile, "w") do |file|
-    file.puts "alpha ./alpha"
-    file.puts "bravo ./bravo"
+    file.puts "alpha: ./alpha"
+    file.puts "\n"
+    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
 
-Rspec.configure do |config|
+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|
   config.color_enabled = true
   config.include FakeFS::SpecHelpers
   config.mock_with :rr