Regenerated gemspec for version 0.4.1

.gitignore

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

Rakefile

@@ -6,6 +6,7 @@ $:.unshift File.expand_path("../lib", __FILE__)
 require "foreman"
 
 task :default => :spec
+task :release => :man
 
 desc "Run all specs"
 Rspec::Core::RakeTask.new(:spec) do |t|
@@ -23,6 +24,16 @@ Rspec::Core::RakeTask.new("rcov:build") do |t|
   t.rcov_opts = [ "--exclude", Gem.default_dir , "--exclude", "spec" ]
 end
 
+desc 'Build the manual'
+task :man do
+  require 'ronn'
+  ENV['RONN_MANUAL']  = "Foreman Manual"
+  ENV['RONN_ORGANIZATION'] = "Foreman #{Foreman::VERSION}"
+  sh "ronn -w -s toc -r5 --markdown man/*.ronn"
+  sh "git add man/*.?"
+  sh "git commit -m \"updating man pages\""
+end
+
 ######################################################
 
 begin

export/upstart/master.conf.erb

@@ -0,0 +1,13 @@
+pre-start script
+
+bash << "EOF"
+  mkdir -p /var/log/<%= app %>
+
+  <% engine.processes.keys.sort.each do |process| %>
+    <% 1.upto(concurrency[process]).each do |num| %>
+      start <%=app%>-<%=process%>-<%=num%>
+    <% end %>
+  <% end %>
+EOF
+
+end script

export/upstart/process.conf.erb

@@ -0,0 +1,5 @@
+stop on stopping <%= app %>
+respawn
+
+chdir <%= engine.directory %>
+exec <%= process.command %> >> /var/log/<%=app%>/<%=process.name%>-<%=num%>.log 2>&1

foreman.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{foreman}
-  s.version = "0.3.0"
+  s.version = "0.4.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["David Dollar"]
-  s.date = %q{2010-06-22}
+  s.date = %q{2010-06-23}
   s.default_executable = %q{foreman}
   s.description = %q{Process manager for applications with multiple components}
   s.email = %q{ddollar@gmail.com}
@@ -25,6 +25,7 @@ Gem::Specification.new do |s|
      "lib/foreman/configuration.rb",
      "lib/foreman/engine.rb",
      "lib/foreman/export.rb",
+     "lib/foreman/export/base.rb",
      "lib/foreman/export/upstart.rb",
      "lib/foreman/process.rb",
      "spec/foreman/cli_spec.rb",

lib/foreman.rb

@@ -1,6 +1,6 @@
 module Foreman
 
-  VERSION = "0.3.0"
+  VERSION = "0.4.1"
 
   class AppDoesNotExist < Exception; end
 

lib/foreman/cli.rb

@@ -6,46 +6,58 @@ require "thor"
 
 class Foreman::CLI < Thor
 
-  desc "start [PROCFILE]", "Run the app described in PROCFILE"
+  class_option :procfile, :type => :string, :aliases => "-p", :desc => "Default: ./Procfile"
 
-  def start(procfile="Procfile")
-    error "#{procfile} does not exist." unless procfile_exists?(procfile)
-    Foreman::Engine.new(procfile).start
+  desc "start [PROCESS]", "Start the application, or a specific process"
+
+  method_option :screen,   :type => :boolean, :aliases => "-s"
+
+  def start(process=nil)
+    check_procfile!
+    
+    if process
+      engine.execute(process)
+    elsif options[:screen]
+      engine.screen
+    else
+      engine.start
+    end
   end
 
-  desc "execute PROCESS [PROCFILE]", "Run an instance of the specified process from PROCFILE"
+  desc "export FORMAT LOCATION", "Export the application to another process management format"
 
-  def execute(process, procfile="Procfile")
-    error "#{procfile} does not exist." unless procfile_exists?(procfile)
-    Foreman::Engine.new(procfile).execute(process)
-  end
+  method_option :app,         :type => :string, :aliases => "-a"
+  method_option :concurrency, :type => :string, :aliases => "-c",
+    :banner => '"alpha=5,bar=3"'
 
-  desc "screen [PROCFILE]", "Run the app described in PROCFILE as screen windows"
-
-  def screen(procfile="Procfile")
-    error "#{procfile} does not exist." unless procfile_exists?(procfile)
-    Foreman::Engine.new(procfile).screen
-  end
-
-  desc "export APP [PROCFILE] [FORMAT]", "Export the app described in PROCFILE as APP to another FORMAT"
-
-  def export(app, procfile="Procfile", format="upstart")
-    error "#{procfile} does not exist." unless procfile_exists?(procfile)
+  def export(format, location=nil)
+    check_procfile!
 
     formatter = case format
       when "upstart" then Foreman::Export::Upstart
       else error "Unknown export format: #{format}."
     end
 
-    formatter.new(Foreman::Engine.new(procfile)).export(app)
+    formatter.new(engine).export(location,
+      :name        => options[:app],
+      :concurrency => options[:concurrency]
+    )
+  rescue Foreman::Export::Exception => ex
+    error ex.message
   end
 
-  desc "scale APP PROCESS AMOUNT", "Change the concurrency of a given process type"
+private ######################################################################
 
-  def scale(app, process, amount)
-    config = Foreman::Configuration.new(app)
-    error "No such process: #{process}." unless config.processes[process]
-    config.scale(process, amount)
+  def check_procfile!
+    error("Procfile does not exist.") unless File.exist?(procfile)
+  end
+
+  def engine
+    @engine ||= Foreman::Engine.new(procfile)
+  end
+
+  def procfile
+    options[:procfile] || "./Procfile"
   end
 
 private ######################################################################

lib/foreman/engine.rb

@@ -77,16 +77,20 @@ private ######################################################################
       FileUtils.mkdir_p "log"
       command = process.command
 
-      PTY.spawn("#{process.command} 2>&1") do |stdin, stdout, pid|
-        until stdin.eof?
-          info stdin.gets, process
+      begin
+        PTY.spawn("#{process.command} 2>&1") do |stdin, stdout, pid|
+          until stdin.eof?
+            info stdin.gets, process
+          end
         end
+      rescue PTY::ChildExited, Interrupt
+        info "process exiting", process
       end
     end
   end
 
   def kill_and_exit(signal="TERM")
-    info "termination requested"
+    info "terminating"
     running_processes.each do |pid, process|
       info "killing #{process.name} in pid #{pid}"
       Process.kill(signal, pid)
@@ -96,11 +100,25 @@ private ######################################################################
 
   def info(message, process=nil)
     print process.color if process
-    print "[#{Time.now.strftime("%H:%M:%S")}] [#{process ? process.name : "system"}] #{message.chomp}"
+    print "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(process)} | "
     print Term::ANSIColor.reset
+    print message.chomp
     puts
   end
 
+  def longest_process_name
+    @longest_process_name ||= begin
+      longest = processes.keys.map { |name| name.length }.sort.last
+      longest = 6 if longest < 6 # system
+      longest
+    end
+  end
+
+  def pad_process_name(process)
+    name = process ? process.name : "system"
+    name.ljust(longest_process_name)
+  end
+
   def print_info
     info "currently running processes:"
     running_processes.each do |pid, process|

lib/foreman/export.rb

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

lib/foreman/export/base.rb

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

lib/foreman/export/upstart.rb

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

man/foreman.1

@@ -0,0 +1,99 @@
+.\" generated with Ronn/v0.7.0
+.\" http://github.com/rtomayko/ronn/tree/0.7.0
+.
+.TH "FOREMAN" "1" "June 2010" "Foreman 0.4.1" "Foreman Manual"
+.
+.SH "NAME"
+\fBforeman\fR \- manage Procfile\-based applications
+.
+.SH "SYNOPSIS"
+\fBforeman\fR start [process]
+.
+.br
+\fBforeman\fR export \fIformat\fR [location]
+.
+.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\-s\fR, \fB\-\-screen\fR
+Run the application as a series of screen windows rather than interleaved in stdout\.
+.
+.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\.
+.
+.SH "OPTIONS"
+These options control all modes of foreman\'s operation\.
+.
+.IP "\(bu" 4
+\fB\-p\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\.
+.
+.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 ~/app/Procfile
+.
+.fi
+.
+.IP "" 0
+.
+.SH "COPYRIGHT"
+Foreman is Copyright (C) 2010 David Dollar \fIhttp://daviddollar\.org\fR

man/foreman.1.ronn

@@ -0,0 +1,75 @@
+foreman(1) -- manage Procfile-based applications
+================================================
+
+## SYNOPSIS
+
+`foreman` start [process]<br>
+`foreman` export <format> [location]
+
+## DESCRIPTION
+
+**Foreman** is a manager for Procfile-based applications. Its aim is to
+abstract away the details of the Procfile format, and allow you to either run
+your application directly or export it to some other process management
+format.
+
+## RUNNING
+
+`foreman start` is used to run your application directly from the command line. 
+
+If no additional parameters are passed, foreman will run one instance of each
+type of process defined in your Procfile.
+
+If a parameter is passed, foreman will run one instance of the specified
+application type.
+
+The following options control how the application is run:
+
+  * `-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.
+    
+  * `-c`, `--concurrency`:
+    Specify the number of each process type to run. The value passed in
+    should be in the format `process=num,process=num`.
+
+## 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.
+
+## 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>

spec/foreman/cli_spec.rb

@@ -25,27 +25,6 @@ describe "Foreman::CLI" do
     end
   end
 
-  describe "execute" do
-    describe "with a non-existent Procfile" do
-      it "prints an error" do
-        mock_error(subject, "Procfile does not exist.") do
-          dont_allow.instance_of(Foreman::Engine).start
-          subject.execute("alpha")
-        end
-      end
-    end
-
-    describe "with a Procfile" do
-      before(:each) { write_procfile }
-
-      it "runs successfully" do
-        dont_allow(subject).error
-        mock.instance_of(Foreman::Engine).execute("alpha")
-        subject.execute("alpha")
-      end
-    end
-  end
-
   describe "export" do
     describe "with a non-existent Procfile" do
       it "prints an error" do
@@ -62,7 +41,7 @@ describe "Foreman::CLI" do
       describe "with an invalid formatter" do
         it "prints an error" do
           mock_error(subject, "Unknown export format: invalidformatter.") do
-            subject.export("testapp", "Procfile", "invalidformatter")
+            subject.export("invalidformatter")
           end
         end
       end
@@ -72,33 +51,11 @@ describe "Foreman::CLI" do
 
         it "runs successfully" do
           dont_allow(subject).error
-          subject.export("testapp")
-        end
-      end
-    end
-  end
-
-  describe "scale" do
-    describe "without an existing configuration" do
-      it "displays an error" do
-        mock_error(subject, "No such process: alpha.") do
-          subject.scale("testapp", "alpha", "2")
-        end
-      end
-    end
-
-    describe "with an existing configuration" do
-      before(:each) { write_foreman_config("testapp") }
-
-      it "scales a process that exists" do
-        mock.instance_of(Foreman::Configuration).scale("alpha", "2")
-        subject.scale("testapp", "alpha", "2")
-      end
-
-      it "errors if a process that does not exist is specified" do
-        mock_error(subject, "No such process: invalidprocess.") do
-          dont_allow.instance_of(Foreman::Configuration).scale
-          subject.scale("testapp", "invalidprocess", "2")
+          mock.instance_of(Foreman::Export::Upstart).export("/tmp/foo", {
+            :concurrency => nil,
+            :name => nil
+          })
+          subject.export("upstart", "/tmp/foo")
         end
       end
     end