0.9.0.beta.1

Signed-off-by: David Dollar <ddollar@gmail.com>

.gitignore

@@ -1,3 +1,4 @@
+.bundle
 coverage
 example/log/*
 man/*.?

Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+group :development do
+  gem 'parka'
+  gem 'rake'
+  gem 'ronn'
+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'

Gemfile.lock

@@ -0,0 +1,45 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    fakefs (0.2.1)
+    hpricot (0.8.2)
+    mime-types (1.16)
+    mustache (0.11.2)
+    parka (0.3.1)
+      rest-client
+      thor
+    rake (0.8.7)
+    rcov (0.9.8)
+    rdiscount (1.6.5)
+    rest-client (1.6.0)
+      mime-types (>= 1.16)
+    ronn (0.7.3)
+      hpricot (>= 0.8.2)
+      mustache (>= 0.7.0)
+      rdiscount (>= 1.5.8)
+    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)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakefs (~> 0.2.1)
+  parka
+  rake
+  rcov (~> 0.9.8)
+  ronn
+  rr (~> 0.10.11)
+  rspec (~> 2.0.0.beta.19)
+  term-ansicolor (~> 1.0.5)
+  thor (~> 0.13.6)

README.markdown

@@ -1,103 +1,4 @@
-foreman(1) -- manage Procfile-based applications
-================================================
+Foreman
+=======
 
-## SYNOPSIS
-
-`foreman start [process]`<br>
-`foreman export <var>format</var> [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:
-
-  * `-s`, `--screen`:
-    Run the application as a series of screen windows rather than interleaved
-    in stdout.
-
-## 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.
-
-  * `-l`, `--log`:
-    Specify the directory to place process logs in.
-
-  * `-c`, `--concurrency`:
-    Specify the number of each process type to run. The value passed in
-    should be in the format `process=num,process=num`
-
-  * `-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.
-
-  * `-p`, `--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.
-
-## 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
-
-## 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 ~/app/Procfile
-
-## COPYRIGHT
-
-Foreman is Copyright (C) 2010 David Dollar <http://daviddollar.org>
-
-
-[SYNOPSIS]: #SYNOPSIS "SYNOPSIS"
-[DESCRIPTION]: #DESCRIPTION "DESCRIPTION"
-[RUNNING]: #RUNNING "RUNNING"
-[EXPORTING]: #EXPORTING "EXPORTING"
-[OPTIONS]: #OPTIONS "OPTIONS"
-[PROCFILE]: #PROCFILE "PROCFILE"
-[EXAMPLES]: #EXAMPLES "EXAMPLES"
-[COPYRIGHT]: #COPYRIGHT "COPYRIGHT"
-
-
-[foreman(1)]: foreman.1.html
+See the [man page](http://ddollar.github.com/foreman) for usage.

Rakefile

@@ -1,3 +1,7 @@
+require "rubygems"
+require "bundler"
+Bundler.setup
+
 require "rake"
 require "rspec"
 require "rspec/core/rake_task"
@@ -29,7 +33,6 @@ task :man do
   ENV['RONN_MANUAL']  = "Foreman Manual"
   ENV['RONN_ORGANIZATION'] = "Foreman #{Foreman::VERSION}"
   sh "ronn -w -s toc -r5 --markdown man/*.ronn"
-  sh "cp man/foreman.1.markdown README.markdown"
   sh "git add README.markdown"
   sh "git commit -m 'update readme' || echo 'nothing to commit'"
 end
@@ -46,41 +49,3 @@ task :pages => :man do
     git checkout master
   }
 end
-
-######################################################
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name    = "foreman"
-    s.version = Foreman::VERSION
-
-    s.summary     = "Process manager for applications with multiple components"
-    s.description = s.summary
-    s.author      = "David Dollar"
-    s.email       = "ddollar@gmail.com"
-    s.homepage    = "http://github.com/ddollar/foreman"
-
-    s.platform = Gem::Platform::RUBY
-    s.has_rdoc = false
-
-    s.files = %w(Rakefile README.md) + Dir["{bin,export,lib,spec}/**/*"]
-    s.require_path = "lib"
-
-    # #s.bindir             = "bin"
-    # s.executables        = Dir["bin/*"]
-    s.default_executable = "foreman"
-
-    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/Pstypes

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

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

data/export/upstart/process.conf.erb

@@ -3,4 +3,4 @@ stop on stopping <%= app %>-<%= process.name %>
 respawn
 
 chdir <%= engine.directory %>
-exec su <%= user %> -c "<%= process.command %> >> <%= log_root %>/<%=process.name%>-<%=num%>.log 2>&1"
+exec su - <%= user %> -c 'export PORT=<%= port %>; <%= process.command %> >> <%= log_root %>/<%=process.name%>-<%=num%>.log 2>&1'

example/Procfile

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

foreman.gemspec

@@ -1,89 +1,12 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
+require "rubygems"
+require "parka/specification"
 
-Gem::Specification.new do |s|
-  s.name = %q{foreman}
-  s.version = "0.4.7"
+Parka::Specification.new do |gem|
+  gem.name     = "foreman"
+  gem.version  = Foreman::VERSION
+  gem.summary  = "Process manager for applications with multiple components"
+  gem.homepage = "http://github.com/ddollar/foreman"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["David Dollar"]
-  s.date = %q{2010-06-29}
-  s.default_executable = %q{foreman}
-  s.description = %q{Process manager for applications with multiple components}
-  s.email = %q{ddollar@gmail.com}
-  s.executables = ["foreman"]
-  s.extra_rdoc_files = [
-    "README.markdown"
-  ]
-  s.files = [
-    "Rakefile",
-     "bin/foreman",
-     "export/upstart/master.conf.erb",
-     "export/upstart/process.conf.erb",
-     "export/upstart/process_master.conf.erb",
-     "lib/foreman.rb",
-     "lib/foreman/cli.rb",
-     "lib/foreman/engine.rb",
-     "lib/foreman/export.rb",
-     "lib/foreman/export/base.rb",
-     "lib/foreman/export/inittab.rb",
-     "lib/foreman/export/upstart.rb",
-     "lib/foreman/process.rb",
-     "spec/foreman/cli_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/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
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<fakefs>, ["~> 0.2.1"])
-      s.add_development_dependency(%q<rake>, ["~> 0.8.7"])
-      s.add_development_dependency(%q<rcov>, ["~> 0.9.8"])
-      s.add_development_dependency(%q<rr>, ["~> 0.10.11"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.0.0"])
-      s.add_runtime_dependency(%q<term-ansicolor>, ["~> 1.0.5"])
-      s.add_runtime_dependency(%q<thor>, ["~> 0.13.6"])
-    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
-  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
+  gem.executables  = "foreman"
+  gem.files       << "man/foreman.1"
 end
-

lib/foreman.rb

@@ -1,6 +1,6 @@
 module Foreman
 
-  VERSION = "0.4.7"
+  VERSION = "0.9.0.beta.1"
 
   class AppDoesNotExist < Exception; end
 

lib/foreman/cli.rb

@@ -5,33 +5,35 @@ require "thor"
 
 class Foreman::CLI < Thor
 
-  class_option :procfile, :type => :string, :aliases => "-p", :desc => "Default: ./Procfile"
+  class_option :pstypes, :type => :string, :aliases => "-f", :desc => "Default: Pstypes"
 
   desc "start [PROCESS]", "Start the application, or a specific process"
 
-  method_option :screen,   :type => :boolean, :aliases => "-s"
+  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!
-    
+    check_pstypes!
+
     if process
-      engine.execute(process)
-    elsif options[:screen]
-      engine.screen
+      engine.execute(process, options)
     else
-      engine.start
+      engine.start(options)
     end
   end
 
   desc "export FORMAT LOCATION", "Export the application to another process management format"
 
-  method_option :app,         :type => :string, :aliases => "-a"
-  method_option :log,         :type => :string, :aliases => "-l"
-  method_option :user,        :type => :string, :aliases => "-u"
-  method_option :concurrency, :type => :string, :aliases => "-c",
+  method_option :app,         :type => :string,  :aliases => "-a"
+  method_option :log,         :type => :string,  :aliases => "-l"
+  method_option :port,        :type => :numeric, :aliases => "-p"
+  method_option :user,        :type => :string,  :aliases => "-u"
+  method_option :concurrency, :type => :string,  :aliases => "-c",
     :banner => '"alpha=5,bar=3"'
+
   def export(format, location=nil)
-    check_procfile!
+    check_pstypes!
 
     formatter = case format
       when "upstart" then Foreman::Export::Upstart
@@ -39,28 +41,24 @@ class Foreman::CLI < Thor
       else error "Unknown export format: #{format}."
     end
 
-    formatter.new(engine).export(location,
-      :name        => options[:app],
-      :user        => options[:user],
-      :log         => options[:log],
-      :concurrency => options[:concurrency]
-    )
+    formatter.new(engine).export(location, options)
+
   rescue Foreman::Export::Exception => ex
     error ex.message
   end
 
 private ######################################################################
 
-  def check_procfile!
-    error("Procfile does not exist.") unless File.exist?(procfile)
+  def check_pstypes!
+    error("#{pstypes} does not exist.") unless File.exist?(pstypes)
   end
 
   def engine
-    @engine ||= Foreman::Engine.new(procfile)
+    @engine ||= Foreman::Engine.new(pstypes)
   end
 
-  def procfile
-    options[:procfile] || "./Procfile"
+  def pstypes
+    options[:pstypes] || "Pstypes"
   end
 
 private ######################################################################
@@ -70,8 +68,8 @@ private ######################################################################
     exit 1
   end
 
-  def procfile_exists?(procfile)
-    File.exist?(procfile)
+  def pstypes_exists?(pstypes)
+    File.exist?(pstypes)
   end
 
 end

lib/foreman/engine.rb

@@ -1,101 +1,115 @@
 require "foreman"
 require "foreman/process"
+require "foreman/utils"
 require "pty"
 require "tempfile"
 require "term/ansicolor"
+require "fileutils"
 
 class Foreman::Engine
 
-  attr_reader :procfile
+  attr_reader :pstypes
   attr_reader :directory
 
   extend Term::ANSIColor
 
-  COLORS = [ cyan, yellow, green, magenta, on_blue ]
+  COLORS = [ cyan, yellow, green, magenta, red ]
 
-  def initialize(procfile)
-    @procfile  = read_procfile(procfile)
-    @directory = File.expand_path(File.dirname(procfile))
+  def initialize(pstypes)
+    @pstypes   = read_pstypes(pstypes)
+    @directory = File.expand_path(File.dirname(pstypes))
   end
 
   def processes
     @processes ||= begin
-      procfile.split("\n").inject({}) do |hash, line|
+      pstypes.split("\n").inject({}) do |hash, line|
         next if line.strip == ""
-        process = Foreman::Process.new(*line.split(" ", 2))
+        name, command = line.split(" ", 2)
+        process = Foreman::Process.new(name, command)
         process.color = next_color
         hash.update(process.name => process)
       end
     end
   end
 
-  def start
+  def start(options={})
     proctitle "ruby: foreman master"
 
     processes.each do |name, process|
-      fork process
+      fork process, options
     end
 
-    trap("TERM") { kill_and_exit("TERM") }
-    trap("INT")  { kill_and_exit("INT")  }
+    trap("TERM") { puts "SIGTERM received"; kill_all("TERM") }
+    trap("INT")  { puts "SIGINT received";  kill_all("INT")  }
 
     watch_for_termination
   end
 
-  def screen
-    tempfile = Tempfile.new("foreman")
-    tempfile.puts "sessionname foreman"
-    processes.each do |name, process|
-      tempfile.puts "screen -t #{name} #{process.command}"
-    end
-    tempfile.close
+  def execute(name, options={})
+    fork processes[name], options
 
-    system "screen -c #{tempfile.path}"
+    trap("TERM") { puts "SIGTERM received"; kill_all("TERM") }
+    trap("INT")  { puts "SIGINT received";  kill_all("INT")  }
 
-    tempfile.delete
+    watch_for_termination
   end
 
-  def execute(name)
-    run(processes[name], false)
+  def port_for(process, num, base_port=nil)
+    base_port ||= 5000
+    offset = processes.keys.sort.index(process.name) * 100
+    base_port.to_i + offset + num - 1
   end
 
 private ######################################################################
 
-  def fork(process)
+  def fork(process, options={})
+    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+
+    1.upto(concurrency[process.name]) do |num|
+      fork_individual(process, num, port_for(process, num, options[:port]))
+    end
+  end
+
+  def fork_individual(process, num, port)
+    ENV["PORT"] = port.to_s
+    ENV["PS"]   = "#{process.name}.#{num}"
+
     pid = Process.fork do
       run(process)
     end
 
-    info "started with pid #{pid}", process
+    info "started with pid #{pid}, PORT=#{port}", process
     running_processes[pid] = process
   end
 
   def run(process, log_to_file=true)
     proctitle "ruby: foreman #{process.name}"
 
-    Dir.chdir directory do
-      FileUtils.mkdir_p "log"
-      command = process.command
+    begin
+      Dir.chdir directory do
+        FileUtils.mkdir_p "log"
+        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, Interrupt
+      end
+    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)
@@ -115,8 +129,8 @@ private ######################################################################
   end
 
   def pad_process_name(process)
-    name = process ? process.name : "system"
-    name.ljust(longest_process_name)
+    name = process ? "#{ENV["PS"]}" : "system"
+    name.ljust(longest_process_name + 3) # add 3 for process number padding
   end
 
   def print_info
@@ -130,15 +144,16 @@ private ######################################################################
     $0 = title
   end
 
-  def read_procfile(procfile)
-    File.read(procfile)
+  def read_pstypes(pstypes)
+    File.read(pstypes)
   end
 
   def watch_for_termination
     pid, status = Process.wait2
     process = running_processes.delete(pid)
     info "process terminated", process
-    kill_and_exit
+    kill_all
+    Process.waitall
   end
 
   def running_processes

lib/foreman/export/base.rb

@@ -1,4 +1,5 @@
 require "foreman/export"
+require "foreman/utils"
 
 class Foreman::Export::Base
 
@@ -23,17 +24,7 @@ private ######################################################################
   end
 
   def export_template(name)
-    File.read(File.expand_path("../../../../export/#{name}", __FILE__))
-  end
-
-  def 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
+    File.read(File.expand_path("../../../../data/export/#{name}", __FILE__))
   end
 
   def write_file(filename, contents)

lib/foreman/export/inittab.rb

@@ -5,23 +5,30 @@ 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"
+    log_root = options[:log] || "/var/log/#{app}"
 
-    concurrency = parse_concurrency(options[:concurrency])
+    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
 
     inittab = []
     inittab << "# ----- foreman #{app} processes -----"
-    engine.processes.values.each_with_index do |process, num|
-      id = app.slice(0, 2).upcase + sprintf("%02d", num+1)
-      inittab << "#{id}:4:respawn:/bin/su - #{user} -c '#{process.command} >> #{log_root}/#{process.name}-#{num+1}.log 2>&1'"
+
+    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)
-      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

@@ -17,7 +17,7 @@ class Foreman::Export::Upstart < Foreman::Export::Base
       FileUtils.rm(file)
     end
 
-    concurrency = parse_concurrency(options[:concurrency])
+    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
 
     master_template = export_template("upstart/master.conf.erb")
     master_config   = ERB.new(master_template).result(binding)
@@ -31,6 +31,7 @@ class Foreman::Export::Upstart < Foreman::Export::Base
       write_file "#{location}/#{app}-#{process.name}.conf", process_master_config
 
       1.upto(concurrency[process.name]) do |num|
+        port = engine.port_for(process, num, options[:port])
         process_config = ERB.new(process_template).result(binding)
         write_file "#{location}/#{app}-#{process.name}-#{num}.conf", process_config
       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

man/foreman.1.ronn

@@ -1,4 +1,4 @@
-foreman(1) -- manage Procfile-based applications
+foreman(1) -- manage Pstypes-based applications
 ================================================
 
 ## SYNOPSIS
@@ -8,8 +8,8 @@ foreman(1) -- manage Procfile-based applications
 
 ## 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
+**Foreman** is a manager for Pstypes-based applications. Its aim is to
+abstract away the details of the Pstypes format, and allow you to either run
 your application directly or export it to some other process management
 format.
 
@@ -18,16 +18,20 @@ format.
 `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.
+type of process defined in your Pstypes.
 
 If a parameter is passed, foreman will run one instance of the specified
 application type.
 
 The following options control how the application is run:
 
-  * `-s`, `--screen`:
-    Run the application as a series of screen windows rather than interleaved
-    in stdout.
+  * `-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
 
@@ -43,13 +47,17 @@ The following options control how the application is run:
     Use this name rather than the application's root directory name as the
     name of the application when exporting.
 
-  * `-l`, `--log`:
-    Specify the directory to place process logs in.
-
   * `-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
@@ -58,14 +66,42 @@ The following options control how the application is run:
 
 These options control all modes of foreman's operation.
 
-  * `-p`, `--procfile`
-    Specify an alternate location for the application's Procfile. This file's
+  * `-f`, `--pstypes`:
+    Specify an alternate location for the application's Pstypes. This file's
     containing directory will be assumed to be the root directory of the
     application.
 
-## PROCFILE
+## EXPORT FORMATS
 
-A Procfile should contain both a name for the process and the command used
+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`
+
+## PSTYPES
+
+A Pstyes file should contain both a name for the process and the command used
 to run it.
 
     web  bundle exec thin start
@@ -81,9 +117,9 @@ Export the application in upstart format:
 
     $ foreman export upstart /etc/init
 
-Run one process type from the application defined in a specific Procfile:
+Run one process type from the application defined in a specific Pstypes:
 
-    $ foreman start alpha -p ~/app/Procfile
+    $ foreman start alpha -p ~/app/Pstypes
 
 ## COPYRIGHT
 

spec/foreman/cli_spec.rb

@@ -5,38 +5,38 @@ describe "Foreman::CLI" do
   subject { Foreman::CLI.new }
 
   describe "start" do
-    describe "with a non-existent Procfile" do
+    describe "with a non-existent Pstypes" do
       it "prints an error" do
-        mock_error(subject, "Procfile does not exist.") do
+        mock_error(subject, "Pstypes does not exist.") do
           dont_allow.instance_of(Foreman::Engine).start
           subject.start
         end
       end
     end
 
-    describe "with a Procfile" do
-      before(:each) { write_procfile }
+    describe "with a Pstypes" do
+      before(:each) { write_pstypes }
 
       it "runs successfully" do
         dont_allow(subject).error
-        mock.instance_of(Foreman::Engine).start
+        mock.instance_of(Foreman::Engine).start({})
         subject.start
       end
     end
   end
 
   describe "export" do
-    describe "with a non-existent Procfile" do
+    describe "with a non-existent Pstypes" do
       it "prints an error" do
-        mock_error(subject, "Procfile does not exist.") do
+        mock_error(subject, "Pstypes does not exist.") do
           dont_allow.instance_of(Foreman::Engine).export
           subject.export("testapp")
         end
       end
     end
 
-    describe "with a Procfile" do
-      before(:each) { write_procfile }
+    describe "with a Pstypes" do
+      before(:each) { write_pstypes }
 
       describe "with an invalid formatter" do
         it "prints an error" do
@@ -51,10 +51,7 @@ describe "Foreman::CLI" do
 
         it "runs successfully" do
           dont_allow(subject).error
-          mock.instance_of(Foreman::Export::Upstart).export("/tmp/foo", {
-            :concurrency => nil,
-            :name => nil
-          })
+          mock.instance_of(Foreman::Export::Upstart).export("/tmp/foo", {})
           subject.export("upstart", "/tmp/foo")
         end
       end

spec/foreman/engine_spec.rb

@@ -2,38 +2,48 @@ require "spec_helper"
 require "foreman/engine"
 
 describe "Foreman::Engine" do
-  subject { Foreman::Engine.new("Procfile") }
+  subject { Foreman::Engine.new("Pstypes") }
 
   describe "initialize" do
-    describe "without an existing Procfile" do
+    describe "without an existing Pstypes" do
       it "raises an error" do
         lambda { subject }.should raise_error
       end
     end
-    
-    describe "with a Procfile" do
+
+    describe "with a Pstypes" do
       it "reads the processes" do
-        write_procfile
+        write_pstypes
         subject.processes["alpha"].command.should == "./alpha"
         subject.processes["bravo"].command.should == "./bravo"
       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"])
+      write_pstypes
+      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_pstypes
+      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")
+    end
   end
 
   describe "execute" do
     it "runs the processes" do
-      write_procfile
-      mock(subject).run(subject.processes["alpha"], false)
+      write_pstypes
+      mock(subject).fork(subject.processes["alpha"], {})
+      mock(subject).watch_for_termination
       subject.execute("alpha")
     end
   end

spec/spec_helper.rb

@@ -24,8 +24,8 @@ def write_foreman_config(app)
   end
 end
 
-def write_procfile(procfile="Procfile")
-  File.open(procfile, "w") do |file|
+def write_pstypes(pstypes="Pstypes")
+  File.open(pstypes, "w") do |file|
     file.puts "alpha ./alpha"
     file.puts "bravo ./bravo"
   end