0.7.4

Gemfile

@@ -3,7 +3,6 @@ source "http://rubygems.org"
 group :development do
   gem 'parka'
   gem 'rake'
-  gem 'ronn'
 end
 
 group :test do

Gemfile.lock

@@ -3,21 +3,14 @@ GEM
   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)
@@ -38,7 +31,6 @@ DEPENDENCIES
   parka
   rake
   rcov (~> 0.9.8)
-  ronn
   rr (~> 0.10.11)
   rspec (~> 2.0.0.beta.19)
   term-ansicolor (~> 1.0.5)

data/example/log/neverdie.log

@@ -1,4 +0,0 @@
-tick
-tick
-./never_die:6:in `sleep': Interrupt
-	from ./never_die:6

export/upstart/process.conf.erb

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

foreman.gemspec

@@ -9,4 +9,5 @@ Parka::Specification.new do |gem|
 
   gem.executables  = "foreman"
   gem.files       << "man/foreman.1"
+  gem.files       << Dir["export/**/*"]
 end

lib/foreman.rb

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

lib/foreman/cli.rb

@@ -5,7 +5,7 @@ require "thor"
 
 class Foreman::CLI < Thor
 
-  class_option :pstypes, :type => :string, :aliases => "-f", :desc => "Default: Pstypes"
+  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: ./Procfile"
 
   desc "start [PROCESS]", "Start the application, or a specific process"
 
@@ -14,7 +14,7 @@ class Foreman::CLI < Thor
     :banner => '"alpha=5,bar=3"'
 
   def start(process=nil)
-    check_pstypes!
+    check_procfile!
 
     if process
       engine.execute(process, options)
@@ -33,7 +33,7 @@ class Foreman::CLI < Thor
     :banner => '"alpha=5,bar=3"'
 
   def export(format, location=nil)
-    check_pstypes!
+    check_procfile!
 
     formatter = case format
       when "upstart" then Foreman::Export::Upstart
@@ -49,16 +49,16 @@ class Foreman::CLI < Thor
 
 private ######################################################################
 
-  def check_pstypes!
+  def check_procfile!
-    error("#{pstypes} does not exist.") unless File.exist?(pstypes)
+    error("Procfile does not exist.") unless File.exist?(procfile)
   end
 
   def engine
-    @engine ||= Foreman::Engine.new(pstypes)
+    @engine ||= Foreman::Engine.new(procfile)
   end
 
-  def pstypes
+  def procfile
-    options[:pstypes] || "Pstypes"
+    options[:procfile] || "./Procfile"
   end
 
 private ######################################################################
@@ -68,8 +68,8 @@ private ######################################################################
     exit 1
   end
 
-  def pstypes_exists?(pstypes)
+  def procfile_exists?(procfile)
-    File.exist?(pstypes)
+    File.exist?(procfile)
   end
 
 end

lib/foreman/engine.rb

@@ -8,21 +8,21 @@ require "fileutils"
 
 class Foreman::Engine
 
-  attr_reader :pstypes
+  attr_reader :procfile
   attr_reader :directory
 
   extend Term::ANSIColor
 
   COLORS = [ cyan, yellow, green, magenta, red ]
 
-  def initialize(pstypes)
+  def initialize(procfile)
-    @pstypes   = read_pstypes(pstypes)
+    @procfile  = read_procfile(procfile)
-    @directory = File.expand_path(File.dirname(pstypes))
+    @directory = File.expand_path(File.dirname(procfile))
   end
 
   def processes
     @processes ||= begin
-      pstypes.split("\n").inject({}) do |hash, line|
+      procfile.split("\n").inject({}) do |hash, line|
         next if line.strip == ""
         name, command = line.split(" ", 2)
         process = Foreman::Process.new(name, command)
@@ -39,8 +39,8 @@ class Foreman::Engine
       fork process, options
     end
 
-    trap("TERM") { puts "SIGTERM received"; kill_all("TERM") }
+    trap("TERM") { kill_and_exit("TERM") }
-    trap("INT")  { puts "SIGINT received";  kill_all("INT")  }
+    trap("INT")  { kill_and_exit("INT")  }
 
     watch_for_termination
   end
@@ -48,8 +48,8 @@ class Foreman::Engine
   def execute(name, options={})
     fork processes[name], options
 
-    trap("TERM") { puts "SIGTERM received"; kill_all("TERM") }
+    trap("TERM") { kill_and_exit("TERM") }
-    trap("INT")  { puts "SIGINT received";  kill_all("INT")  }
+    trap("INT")  { kill_and_exit("INT")  }
 
     watch_for_termination
   end
@@ -66,50 +66,47 @@ private ######################################################################
     concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
 
     1.upto(concurrency[process.name]) do |num|
-      fork_individual(process, num, port_for(process, num, options[:port]))
+      fork_individual(process, port_for(process, num, options[:port]))
     end
   end
 
-  def fork_individual(process, num, port)
+  def fork_individual(process, port)
     ENV["PORT"] = port.to_s
-    ENV["PS"]   = "#{process.name}.#{num}"
 
     pid = Process.fork do
       run(process)
     end
 
-    info "started with pid #{pid}, PORT=#{port}", process
+    info "started with pid #{pid}", process
     running_processes[pid] = process
   end
 
   def run(process, log_to_file=true)
     proctitle "ruby: foreman #{process.name}"
 
-    begin
+    Dir.chdir directory do
-      Dir.chdir directory do
+      FileUtils.mkdir_p "log"
-        FileUtils.mkdir_p "log"
+      command = process.command
-        command = process.command
 
+      begin
         PTY.spawn("#{process.command} 2>&1") do |stdin, stdout, pid|
           until stdin.eof?
             info stdin.gets, process
           end
         end
-      end
+      rescue PTY::ChildExited, Interrupt
-    rescue PTY::ChildExited, Interrupt
-      begin
         info "process exiting", process
-      rescue Interrupt
       end
     end
   end
 
-  def kill_all(signal="TERM")
+  def kill_and_exit(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)
@@ -129,8 +126,8 @@ private ######################################################################
   end
 
   def pad_process_name(process)
-    name = process ? "#{ENV["PS"]}" : "system"
+    name = process ? "#{process.name}:#{ENV["PORT"]}" : "system"
-    name.ljust(longest_process_name + 3) # add 3 for process number padding
+    name.ljust(longest_process_name + 6) # add 6 for port padding
   end
 
   def print_info
@@ -144,16 +141,15 @@ private ######################################################################
     $0 = title
   end
 
-  def read_pstypes(pstypes)
+  def read_procfile(procfile)
-    File.read(pstypes)
+    File.read(procfile)
   end
 
   def watch_for_termination
     pid, status = Process.wait2
     process = running_processes.delete(pid)
     info "process terminated", process
-    kill_all
+    kill_and_exit
-    Process.waitall
   end
 
   def running_processes

lib/foreman/export/base.rb

@@ -24,7 +24,7 @@ private ######################################################################
   end
 
   def export_template(name)
-    File.read(File.expand_path("../../../../data/export/#{name}", __FILE__))
+    File.read(File.expand_path("../../../../export/#{name}", __FILE__))
   end
 
   def write_file(filename, contents)

lib/foreman/export/inittab.rb

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

man/foreman.1.ronn

@@ -1,4 +1,4 @@
-foreman(1) -- manage Pstypes-based applications
+foreman(1) -- manage Procfile-based applications
 ================================================
 
 ## SYNOPSIS
@@ -8,8 +8,8 @@ foreman(1) -- manage Pstypes-based applications
 
 ## DESCRIPTION
 
-**Foreman** is a manager for Pstypes-based applications. Its aim is to
+**Foreman** is a manager for Procfile-based applications. Its aim is to
-abstract away the details of the Pstypes format, and allow you to either run
+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.
 
@@ -18,7 +18,7 @@ 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 Pstypes.
+type of process defined in your Procfile.
 
 If a parameter is passed, foreman will run one instance of the specified
 application type.
@@ -66,8 +66,8 @@ The following options control how the application is run:
 
 These options control all modes of foreman's operation.
 
-  * `-f`, `--pstypes`:
+  * `-f`, `--procfile`:
-    Specify an alternate location for the application's Pstypes. This file's
+    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.
 
@@ -99,9 +99,9 @@ will be structured to make the following commands valid:
 
   `restart appname-processname-3`
 
-## PSTYPES
+## PROCFILE
 
-A Pstyes file should contain both a name for the process and the command used
+A Procfile should contain both a name for the process and the command used
 to run it.
 
     web  bundle exec thin start
@@ -117,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 Pstypes:
+Run one process type from the application defined in a specific Procfile:
 
-    $ foreman start alpha -p ~/app/Pstypes
+    $ foreman start alpha -p ~/app/Procfile
 
 ## COPYRIGHT
 

spec/foreman/cli_spec.rb

@@ -5,17 +5,17 @@ describe "Foreman::CLI" do
   subject { Foreman::CLI.new }
 
   describe "start" do
-    describe "with a non-existent Pstypes" do
+    describe "with a non-existent Procfile" do
       it "prints an error" do
-        mock_error(subject, "Pstypes does not exist.") do
+        mock_error(subject, "Procfile does not exist.") do
           dont_allow.instance_of(Foreman::Engine).start
           subject.start
         end
       end
     end
 
-    describe "with a Pstypes" do
+    describe "with a Procfile" do
-      before(:each) { write_pstypes }
+      before(:each) { write_procfile }
 
       it "runs successfully" do
         dont_allow(subject).error
@@ -26,17 +26,17 @@ describe "Foreman::CLI" do
   end
 
   describe "export" do
-    describe "with a non-existent Pstypes" do
+    describe "with a non-existent Procfile" do
       it "prints an error" do
-        mock_error(subject, "Pstypes does not exist.") do
+        mock_error(subject, "Procfile does not exist.") do
           dont_allow.instance_of(Foreman::Engine).export
           subject.export("testapp")
         end
       end
     end
 
-    describe "with a Pstypes" do
+    describe "with a Procfile" do
-      before(:each) { write_pstypes }
+      before(:each) { write_procfile }
 
       describe "with an invalid formatter" do
         it "prints an error" do

spec/foreman/engine_spec.rb

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

spec/spec_helper.rb

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