0.7.4

.gitignore

@@ -5,5 +5,3 @@ man/*.?
 man/*.html
 man/*.markdown
 pkg
-tags
-

Gemfile

@@ -3,16 +3,14 @@ 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',     '~> 1.0.2'
-  gem 'rspec',  '~> 2.0.0'
+  gem 'rr',     '~> 0.10.11'
+  gem 'rspec',  '~> 2.0.0.beta.19'
 end
 
-gem 'json',           '~> 1.5.1'
 gem 'term-ansicolor', '~> 1.0.5'
-gem 'thor',           '>= 0.13.6'
+gem 'thor',           '~> 0.13.6'

Gemfile.lock

@@ -3,47 +3,35 @@ GEM
   specs:
     diff-lcs (1.1.2)
     fakefs (0.2.1)
-    hpricot (0.8.2)
-    json (1.5.1)
     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 (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)
+    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.1)
-      rspec-core (~> 2.0.1)
-      rspec-expectations (~> 2.0.1)
+    rspec-mocks (2.0.0.beta.19)
     term-ansicolor (1.0.5)
-    thor (0.14.6)
+    thor (0.13.8)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   fakefs (~> 0.2.1)
-  json (~> 1.5.1)
   parka
   rake
   rcov (~> 0.9.8)
-  ronn
-  rr (~> 1.0.2)
-  rspec (~> 2.0.0)
+  rr (~> 0.10.11)
+  rspec (~> 2.0.0.beta.19)
   term-ansicolor (~> 1.0.5)
-  thor (>= 0.13.6)
+  thor (~> 0.13.6)

README.markdown

@@ -1,9 +1,4 @@
-# Foreman
-
-## Manual
+Foreman
+=======
 
 See the [man page](http://ddollar.github.com/foreman) for usage.
-
-## License
-
-MIT

Rakefile

@@ -25,7 +25,7 @@ end
 Rspec::Core::RakeTask.new("rcov:build") do |t|
   t.pattern = 'spec/**/*_spec.rb'
   t.rcov = true
-  t.rcov_opts = [ "--exclude", ".bundle", "--exclude", "spec" ]
+  t.rcov_opts = [ "--exclude", Gem.default_dir , "--exclude", "spec" ]
 end
 
 desc 'Build the manual'
@@ -37,7 +37,6 @@ task :man do
   sh "git commit -m 'update readme' || echo 'nothing to commit'"
 end
 
-desc "Generate the Github docs"
 task :pages => :man do
   sh %{
     cp man/foreman.1.html /tmp/foreman.1.html

data/example/Procfile

@@ -1,2 +0,0 @@
-ticker: ./ticker $PORT
-error : ./error

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

@@ -1,29 +1,13 @@
-$:.unshift File.expand_path("../lib", __FILE__)
-require "foreman/version"
+require "rubygems"
+require "parka/specification"
 
-Gem::Specification.new do |gem|
+Parka::Specification.new do |gem|
   gem.name     = "foreman"
   gem.version  = Foreman::VERSION
-
-  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.homepage = "http://github.com/ddollar/foreman"
 
-  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 'json',           '~> 1.5.1'
-  gem.add_dependency 'term-ansicolor', '~> 1.0.5'
-  gem.add_dependency 'thor',           '>= 0.13.6'
-
-  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.0.0'
+  gem.executables  = "foreman"
+  gem.files       << "man/foreman.1"
+  gem.files       << Dir["export/**/*"]
 end

lib/foreman.rb

@@ -1,5 +1,7 @@
 module Foreman
 
+  VERSION = "0.7.4"
+
   class AppDoesNotExist < Exception; end
 
 end

lib/foreman/cli.rb

@@ -5,7 +5,7 @@ require "thor"
 
 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"
 
@@ -36,9 +36,8 @@ class Foreman::CLI < Thor
     check_procfile!
 
     formatter = case format
-      when "json"    then Foreman::Export::JSON
-      when "inittab" then Foreman::Export::Inittab
       when "upstart" then Foreman::Export::Upstart
+      when "inittab" then Foreman::Export::Inittab
       else error "Unknown export format: #{format}."
     end
 
@@ -48,18 +47,10 @@ 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
@@ -67,12 +58,10 @@ private ######################################################################
   end
 
   def procfile
-    options[:procfile] || "Procfile"
+    options[:procfile] || "./Procfile"
   end
 
-  def display(message)
-    puts message
-  end
+private ######################################################################
 
   def error(message)
     puts "ERROR: #{message}"
@@ -83,11 +72,4 @@ 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

@@ -22,42 +22,25 @@ class Foreman::Engine
 
   def processes
     @processes ||= begin
-      @order = []
       procfile.split("\n").inject({}) do |hash, line|
         next if line.strip == ""
-        name, command = line.split(/ *: +/, 2)
-        unless command
-          warn_deprecated_procfile!
-          name, command = line.split(/ +/, 2)
-        end
+        name, command = line.split(" ", 2)
         process = Foreman::Process.new(name, command)
         process.color = next_color
-        @order << process.name
         hash.update(process.name => process)
       end
     end
   end
 
-  def process_order
-    processes
-    @order.uniq
-  end
-
-  def processes_in_order
-    process_order.map do |name|
-      [name, processes[name]]
-    end
-  end
-
   def start(options={})
     proctitle "ruby: foreman master"
 
-    processes_in_order.each do |name, process|
+    processes.each do |name, process|
       fork process, options
     end
 
-    trap("TERM") { puts "SIGTERM received"; kill_all("TERM") }
-    trap("INT")  { puts "SIGINT received";  kill_all("INT")  }
+    trap("TERM") { kill_and_exit("TERM") }
+    trap("INT")  { kill_and_exit("INT")  }
 
     watch_for_termination
   end
@@ -65,15 +48,15 @@ class Foreman::Engine
   def execute(name, options={})
     fork processes[name], options
 
-    trap("TERM") { puts "SIGTERM received"; kill_all("TERM") }
-    trap("INT")  { puts "SIGINT received";  kill_all("INT")  }
+    trap("TERM") { kill_and_exit("TERM") }
+    trap("INT")  { kill_and_exit("INT")  }
 
     watch_for_termination
   end
 
   def port_for(process, num, base_port=nil)
     base_port ||= 5000
-    offset = processes_in_order.map { |p| p.first }.index(process.name) * 100
+    offset = processes.keys.sort.index(process.name) * 100
     base_port.to_i + offset + num - 1
   end
 
@@ -83,13 +66,12 @@ 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)
@@ -99,33 +81,32 @@ private ######################################################################
     running_processes[pid] = process
   end
 
-  def run(process)
+  def run(process, log_to_file=true)
     proctitle "ruby: foreman #{process.name}"
 
-    begin
-      Dir.chdir directory do
-        command = process.command
+    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
-      end
-    rescue PTY::ChildExited, Interrupt
-      begin
+      rescue PTY::ChildExited, Interrupt
         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)
@@ -145,8 +126,8 @@ private ######################################################################
   end
 
   def pad_process_name(process)
-    name = process ? "#{ENV["PS"]}" : "system"
-    name.ljust(longest_process_name + 3) # add 3 for process number padding
+    name = process ? "#{process.name}:#{ENV["PORT"]}" : "system"
+    name.ljust(longest_process_name + 6) # add 6 for port padding
   end
 
   def print_info
@@ -168,8 +149,7 @@ private ######################################################################
     pid, status = Process.wait2
     process = running_processes.delete(pid)
     info "process terminated", process
-    kill_all
-    Process.waitall
+    kill_and_exit
   end
 
   def running_processes
@@ -182,12 +162,4 @@ 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
-
 end

lib/foreman/export.rb

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

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.chown(user, nil, log_root) rescue error "could not chown #{log_root} to #{user}"
+      FileUtils.mkdir_p(log_root)
+      FileUtils.chown(user, nil, log_root)
       write_file(fname, inittab)
     else
       puts inittab

lib/foreman/export/json.rb

@@ -1,13 +0,0 @@
-require "foreman/export/base"
-require "json"
-
-class Foreman::Export::JSON < Foreman::Export::Base
-
-  def export(fname=nil, options={})
-    processes = engine.processes.values.inject({}) do |hash, process|
-      hash.update(process.name => { "command" => process.command })
-    end
-    puts processes.to_json
-  end
-
-end

lib/foreman/version.rb

@@ -1,5 +0,0 @@
-module Foreman
-
-  VERSION = "0.12.0.pre1"
-
-end

man/foreman.1.ronn

@@ -75,18 +75,10 @@ These options control all modes of foreman's operation.
 
 foreman currently supports the following output formats:
 
-  * json
-
   * inittab
 
   * upstart
 
-## JSON EXPORT
-
-Will export your processes as JSON:
-
-    { "web": { "command": "bundle exec thin start" } }
-
 ## INITTAB EXPORT
 
 Will export a chunk of inittab-compatible configuration:
@@ -112,21 +104,8 @@ 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
-
-You can validate your Procfile format using the `check` command
-
-    $ foreman check
-
-## 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
+    web  bundle exec thin start
+    job  bundle exec rake jobs:work
 
 ## EXAMPLES
 
@@ -140,7 +119,7 @@ Export the application in upstart format:
 
 Run one process type from the application defined in a specific Procfile:
 
-    $ foreman start alpha -p ~/myapp/Procfile
+    $ foreman start alpha -p ~/app/Procfile
 
 ## COPYRIGHT
 

spec/foreman/cli_spec.rb

@@ -58,27 +58,4 @@ 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

@@ -12,26 +12,12 @@ 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
@@ -45,9 +31,9 @@ describe "Foreman::Engine" do
 
     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).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

spec/spec_helper.rb

@@ -26,8 +26,8 @@ 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 "bravo ./bravo"
   end
 end