update manual

Bluepill export

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    foreman (0.17.0)
+    foreman (0.21.0)
       term-ansicolor (~> 1.0.5)
       thor (>= 0.13.6)
 
@@ -18,7 +18,7 @@ GEM
       crack
       rest-client
       thor
-    rake (0.8.7)
+    rake (0.9.2)
     rcov (0.9.8)
     rdiscount (1.6.5)
     rest-client (1.6.1)
@@ -28,17 +28,15 @@ GEM
       mustache (>= 0.7.0)
       rdiscount (>= 1.5.8)
     rr (1.0.2)
-    rspec (2.0.1)
-      rspec-core (~> 2.0.1)
-      rspec-expectations (~> 2.0.1)
-      rspec-mocks (~> 2.0.1)
-    rspec-core (2.0.1)
-    rspec-expectations (2.0.1)
-      diff-lcs (>= 1.1.2)
-    rspec-mocks (2.0.1)
-      rspec-core (~> 2.0.1)
-      rspec-expectations (~> 2.0.1)
-    term-ansicolor (1.0.5)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    term-ansicolor (1.0.6)
     thor (0.14.6)
 
 PLATFORMS
@@ -52,4 +50,4 @@ DEPENDENCIES
   rcov (~> 0.9.8)
   ronn
   rr (~> 1.0.2)
-  rspec (~> 2.0.0)
+  rspec (~> 2.6.0)

Rakefile

@@ -13,7 +13,7 @@ task :default => :spec
 task :release => :man
 
 desc "Run all specs"
-Rspec::Core::RakeTask.new(:spec) do |t|
+RSpec::Core::RakeTask.new(:spec) do |t|
   t.pattern = 'spec/**/*_spec.rb'
 end
 
@@ -22,7 +22,7 @@ task :rcov => "rcov:build" do
   %x{ open coverage/index.html }
 end
 
-Rspec::Core::RakeTask.new("rcov:build") do |t|
+RSpec::Core::RakeTask.new("rcov:build") do |t|
   t.pattern = 'spec/**/*_spec.rb'
   t.rcov = true
   t.rcov_opts = [ "--exclude", ".bundle", "--exclude", "spec" ]

bin/foreman-runner

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

data/example/ticker

@@ -1,5 +1,11 @@
 #!/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

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

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

foreman.gemspec

@@ -25,5 +25,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'fakefs', '~> 0.2.1'
   gem.add_development_dependency 'rcov',   '~> 0.9.8'
   gem.add_development_dependency 'rr',     '~> 1.0.2'
-  gem.add_development_dependency 'rspec',  '~> 2.0.0'
+  gem.add_development_dependency 'rspec',  '~> 2.6.0'
 end

lib/foreman/cli.rb

@@ -18,9 +18,9 @@ class Foreman::CLI < Thor
     check_procfile!
 
     if process
-      engine.execute(process, options)
+      engine.execute(process)
     else
-      engine.start(options)
+      engine.start
     end
   end
 
@@ -30,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"'
 
@@ -39,6 +40,7 @@ class Foreman::CLI < Thor
     formatter = case format
       when "inittab" then Foreman::Export::Inittab
       when "upstart" then Foreman::Export::Upstart
+      when "bluepill" then Foreman::Export::Bluepill
       else error "Unknown export format: #{format}."
     end
 
@@ -63,7 +65,7 @@ private ######################################################################
   end
 
   def engine
-    @engine ||= Foreman::Engine.new(procfile)
+    @engine ||= Foreman::Engine.new(procfile, options)
   end
 
   def procfile
@@ -86,7 +88,7 @@ private ######################################################################
   def options
     original_options = super
     return original_options unless File.exists?(".foreman")
-    defaults = YAML::load_file(".foreman")
+    defaults = YAML::load_file(".foreman") || {}
     Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
   end
 

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,21 +11,25 @@ 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 == ""
+        next hash if line.strip == ""
         name, command = line.split(/ *: +/, 2)
         unless command
           warn_deprecated_procfile!
@@ -49,28 +54,25 @@ class Foreman::Engine
     end
   end
 
-  def start(options={})
-    environment = read_environment(options[:env])
-
+  def start
     proctitle "ruby: foreman master"
 
     processes_in_order.each do |name, process|
-      fork process, options, environment
+      fork process
     end
 
-    trap("TERM") { puts "SIGTERM received"; kill_all("TERM") }
-    trap("INT")  { puts "SIGINT received";  kill_all("TERM")  }
+    trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
+    trap("INT")  { puts "SIGINT received";  terminate_gracefully }
 
     watch_for_termination
   end
 
-  def execute(name, options={})
-    environment = read_environment(options[:env])
+  def execute(name)
 
-    fork processes[name], options, environment
+    fork processes[name]
 
-    trap("TERM") { puts "SIGTERM received"; kill_all("TERM") }
-    trap("INT")  { puts "SIGINT received";  kill_all("TERM")  }
+    trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
+    trap("INT")  { puts "SIGINT received";  terminate_gracefully }
 
     watch_for_termination
   end
@@ -83,16 +85,16 @@ class Foreman::Engine
 
 private ######################################################################
 
-  def fork(process, options={}, environment={})
-    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, num, port_for(process, num, options[:port]), environment)
+      fork_individual(process, num, port_for(process, num, @options[:port]))
     end
   end
 
-  def fork_individual(process, num, port, environment)
-    environment.each { |k,v| ENV[k] = v }
+  def fork_individual(process, num, port)
+    @environment.each { |k,v| ENV[k] = v }
 
     ENV["PORT"] = port.to_s
     ENV["PS"]   = "#{process.name}.#{num}"
@@ -107,18 +109,18 @@ private ######################################################################
 
   def run(process)
     proctitle "ruby: foreman #{process.name}"
+    trap("SIGINT", "IGNORE")
 
     begin
       Dir.chdir directory do
-        command = process.command
-
-        PTY.spawn("#{process.command} 2>&1") do |stdin, stdout, pid|
+        PTY.spawn(runner, process.command) do |stdin, stdout, pid|
+          trap("SIGTERM") { Process.kill("SIGTERM", pid) }
           until stdin.eof?
             info stdin.gets, process
           end
         end
       end
-    rescue PTY::ChildExited, Interrupt
+    rescue PTY::ChildExited, Interrupt, Errno::EIO
       begin
         info "process exiting", process
       rescue Interrupt
@@ -126,11 +128,9 @@ private ######################################################################
     end
   end
 
-  def kill_all(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
   end
 
@@ -179,8 +179,9 @@ private ######################################################################
     pid, status = Process.wait2
     process = running_processes.delete(pid)
     info "process terminated", process
+    terminate_gracefully
     kill_all
-    Process.waitall
+  rescue Errno::ECHILD
   end
 
   def running_processes
@@ -217,4 +218,17 @@ private ######################################################################
     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

@@ -7,3 +7,4 @@ end
 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("../../../../data/export/#{name}", __FILE__))
+  def export_template(exporter, file, template_root)
+    if template_root && File.exist?(file_path = File.join(template_root, file))
+      File.read(file_path)
+    elsif File.exist?(file_path = File.join("~/.foreman/templates", file))
+      File.read(file_path)
+    else
+      File.read(File.expand_path("../../../../data/export/#{exporter}/#{file}", __FILE__))
+    end
   end
 
   def write_file(filename, contents)

lib/foreman/export/bluepill.rb

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

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

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

man/foreman.1

@@ -1,7 +1,7 @@
 .\" generated with Ronn/v0.7.3
 .\" http://github.com/rtomayko/ronn/tree/0.7.3
 .
-.TH "FOREMAN" "1" "May 2011" "Foreman 0.15.0" "Foreman Manual"
+.TH "FOREMAN" "1" "September 2011" "Foreman 0.21.0" "Foreman Manual"
 .
 .SH "NAME"
 \fBforeman\fR \- manage Procfile\-based applications
@@ -69,7 +69,7 @@ These options control all modes of foreman\'s operation\.
 .
 .TP
 \fB\-e\fR, \fB\-\-env\fR
-Specify a file containing the environment that should be set up for each child process\. The file should be key/value pairs separated by \fB=\fR, with one key/value pair per line\.
+Specify an alternate environment file\.
 .
 .TP
 \fB\-f\fR, \fB\-\-procfile\fR
@@ -79,6 +79,9 @@ Specify an alternate location for the application\'s Procfile\. This file\'s con
 foreman currently supports the following output formats:
 .
 .IP "\(bu" 4
+bluepill
+.
+.IP "\(bu" 4
 inittab
 .
 .IP "\(bu" 4
@@ -141,6 +144,20 @@ $ foreman check
 .
 .IP "" 0
 .
+.SH "ENVIRONMENT"
+If a \fB\.env\fR file exists in the current directory, the default environment will be read from it\. This file should contain key/value pairs, separated by \fB=\fR, with one key/value pair per line\.
+.
+.IP "" 4
+.
+.nf
+
+FOO=bar
+BAZ=qux
+.
+.fi
+.
+.IP "" 0
+.
 .SH "DEFAULT OPTIONS"
 If a \fB\.foreman\fR file exists in the current directory, default options will be read from it\. This file should be in YAML format with the long option name as keys\. Example:
 .

man/foreman.1.ronn

@@ -67,9 +67,7 @@ The following options control how the application is run:
 These options control all modes of foreman's operation.
 
   * `-e`, `--env`:
-    Specify a file containing the environment that should be set up for each
-    child process. The file should be key/value pairs separated by `=`, with
-    one key/value pair per line.
+    Specify an alternate environment file.
 
   * `-f`, `--procfile`:
     Specify an alternate location for the application's Procfile. This file's
@@ -80,6 +78,8 @@ These options control all modes of foreman's operation.
 
 foreman currently supports the following output formats:
 
+  * bluepill
+
   * inittab
 
   * upstart
@@ -116,6 +116,15 @@ 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

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

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
@@ -37,53 +37,61 @@ describe "Foreman::Engine" do
   describe "start" do
     it "forks the processes" do
       write_procfile
-      mock(subject).fork(subject.processes["alpha"], {}, {})
-      mock(subject).fork(subject.processes["bravo"], {}, {})
+      mock(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"], 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")
+      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
-      stub(subject).info
-      mock(subject).watch_for_termination
     end
 
     it "should read if specified" do
       File.open("/tmp/env", "w") { |f| f.puts("FOO=baz") }
-      subject.execute("alpha", :env => "/tmp/env")
+      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
+      stub(engine).info
+      mock(engine).watch_for_termination
+      engine.environment.should == {"FOO"=>"baz"}
+      engine.execute("alpha")
     end
 
     it "should fail if specified and doesnt exist" do
-      mock(subject).error("No such file: /tmp/env")
-      subject.execute("alpha", :env => "/tmp/env")
+      mock.instance_of(Foreman::Engine).error("No such file: /tmp/env")
+      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
     end
 
     it "should read .env if none specified" do
       File.open(".env", "w") { |f| f.puts("FOO=qoo") }
-      mock(subject).fork_individual(anything, anything, anything, { "FOO" => "qoo" })
-      subject.execute("bravo")
+      engine = Foreman::Engine.new("Procfile")
+      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

@@ -13,7 +13,6 @@ describe Foreman::Export::Upstart do
 
   it "exports to the filesystem" do
     upstart.export("/tmp/init")
-    p [:d, Dir["/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")
@@ -22,4 +21,35 @@ describe Foreman::Export::Upstart do
     File.read("/tmp/init/app-bravo.conf").should   == example_export_file("upstart/app-bravo.conf")
     File.read("/tmp/init/app-bravo-1.conf").should == example_export_file("upstart/app-bravo-1.conf")
   end
+
+  context "with alternate templates" do
+    let(:template_root) { "/tmp/alternate" }
+
+    before do
+      FileUtils.mkdir_p template_root
+      File.open("#{template_root}/master.conf.erb", "w") { |f| f.puts "alternate_template" }
+    end
+
+    it "can export with alternate template files" do
+      upstart.export("/tmp/init", :template => template_root)
+
+      File.read("/tmp/init/app.conf").should == "alternate_template\n"
+    end
+  end
+
+  context "with alternate templates from home dir" do
+    let(:default_template_root) {File.expand_path("~/.foreman/templates")}
+
+    before do
+      FileUtils.mkdir_p default_template_root
+      File.open("#{default_template_root}/master.conf.erb", "w") { |f| f.puts "default_alternate_template" }
+    end
+
+    it "can export with alternate template files" do
+      upstart.export("/tmp/init")
+
+      File.read("/tmp/init/app.conf").should == "default_alternate_template\n"
+    end
+  end
+
 end

spec/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/spec_helper.rb

@@ -27,6 +27,7 @@ end
 def write_procfile(procfile="Procfile")
   File.open(procfile, "w") do |file|
     file.puts "alpha: ./alpha"
+    file.puts "\n"
     file.puts "bravo: ./bravo"
   end
   File.expand_path(procfile)
@@ -52,7 +53,7 @@ def example_export_file(filename)
   data
 end
 
-Rspec.configure do |config|
+RSpec.configure do |config|
   config.color_enabled = true
   config.include FakeFS::SpecHelpers
   config.mock_with :rr