foreman 0.27.0 → 0.37.0

data/lib/foreman/export/upstart.rb

@@ -3,37 +3,35 @@ require "foreman/export"
 
 class Foreman::Export::Upstart < Foreman::Export::Base
 
-  def export(location, options={})
+  def export
     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]
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
+    template_root = self.template
 
     Dir["#{location}/#{app}*.conf"].each do |file|
       say "cleaning up: #{file}"
       FileUtils.rm(file)
     end
 
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
-
     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", template_root)
 
-    engine.processes.each do |process|
-      next if (conc = concurrency[process.name]) < 1
+    engine.procfile.entries.each do |process|
+      next if (conc = self.concurrency[process.name]) < 1
       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
 
-      1.upto(concurrency[process.name]) do |num|
-        port = engine.port_for(process, num, options[:port])
+      1.upto(self.concurrency[process.name]) do |num|
+        port = engine.port_for(process, num, self.port)
         process_config = ERB.new(process_template).result(binding)
         write_file "#{location}/#{app}-#{process.name}-#{num}.conf", process_config
       end

data/lib/foreman/export.rb

@@ -1,9 +1,30 @@
 require "foreman"
+require "foreman/helpers"
 
 module Foreman::Export
+  extend Foreman::Helpers
+
   class Exception < ::Exception; end
+
+  def self.formatter(format)
+    begin
+      require "foreman/export/#{ format.tr('-', '_') }"
+      classy_format = classify(format)
+      formatter     = constantize("Foreman::Export::#{ classy_format }")
+    rescue NameError => ex
+      error "Unknown export format: #{format} (no class Foreman::Export::#{ classy_format })."
+    rescue LoadError => ex
+      error "Unknown export format: #{format} (unable to load file 'foreman/export/#{ format.tr('-', '_') }')."
+    end
+  end
+
+  def self.error(message)
+    raise Foreman::Export::Exception.new(message)
+  end
+
 end
 
+
 require "foreman/export/base"
 require "foreman/export/inittab"
 require "foreman/export/upstart"

data/lib/foreman/helpers.rb

@@ -0,0 +1,45 @@
+module Foreman::Helpers
+  # Copied whole sale from, https://github.com/defunkt/resque/
+
+  # Given a word with dashes, returns a camel cased version of it.
+  #
+  # classify('job-name') # => 'JobName'
+  def classify(dashed_word)
+    dashed_word.split('-').each { |part| part[0] = part[0].chr.upcase }.join
+  end  # Tries to find a constant with the name specified in the argument string:
+
+  #
+  # constantize("Module") # => Module
+  # constantize("Test::Unit") # => Test::Unit
+  #
+  # The name is assumed to be the one of a top-level constant, no matter
+  # whether it starts with "::" or not. No lexical context is taken into
+  # account:
+  #
+  # C = 'outside'
+  # module M
+  #   C = 'inside'
+  #   C # => 'inside'
+  #   constantize("C") # => 'outside', same as ::C
+  # end
+  #
+  # NameError is raised when the constant is unknown.
+  def constantize(camel_cased_word)
+    camel_cased_word = camel_cased_word.to_s
+
+    names = camel_cased_word.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      args = Module.method(:const_get).arity != 1 ? [false] : []
+
+      if constant.const_defined?(name, *args)
+        constant = constant.const_get(name)
+      else
+        constant = constant.const_missing(name)
+      end
+    end
+    constant
+  end
+end

data/lib/foreman/process.rb

@@ -1,14 +1,96 @@
 require "foreman"
+require "rubygems"
 
 class Foreman::Process
 
-  attr_reader :name
-  attr_reader :command
-  attr_accessor :color
+  attr_reader :entry
+  attr_reader :num
+  attr_reader :pid
+  attr_reader :port
 
-  def initialize(name, command)
-    @name    = name
-    @command = command
+  def initialize(entry, num, port)
+    @entry = entry
+    @num = num
+    @port = port
   end
 
+  def run(pipe, basedir, environment)
+    with_environment(environment.merge("PORT" => port.to_s)) do
+      run_process basedir, entry.command, pipe
+    end
+  end
+
+  def name
+    "%s.%s" % [ entry.name, num ]
+  end
+
+  def kill(signal)
+    pid && Process.kill(signal, pid)
+  rescue Errno::ESRCH
+    false
+  end
+
+  def detach
+    pid && Process.detach(pid)
+  end
+
+  def alive?
+    kill(0)
+  end
+
+  def dead?
+    !alive?
+  end
+
+private
+
+  def fork_with_io(command, basedir)
+    reader, writer = IO.pipe
+    command = replace_command_env(command)
+    pid = if Foreman.windows?
+      Dir.chdir(basedir) do
+        Process.spawn command, :out => writer, :err => writer
+      end
+    elsif Foreman.jruby?
+      require "posix/spawn"
+      POSIX::Spawn.spawn(Foreman.runner, "-d", basedir, command, {
+        :out => writer, :err => writer
+      })
+    else
+      fork do
+        writer.sync = true
+        $stdout.reopen writer
+        $stderr.reopen writer
+        reader.close
+        exec Foreman.runner, "-d", basedir, command
+      end
+    end
+    [ reader, pid ]
+  end
+
+  def run_process(basedir, command, pipe)
+    io, @pid = fork_with_io(command, basedir)
+    output pipe, "started with pid %d" % @pid
+    Thread.new do
+      until io.eof?
+        output pipe, io.gets
+      end
+    end
+  end
+
+  def output(pipe, message)
+    pipe.puts "%s,%s" % [ name, message ]
+  end
+
+  def replace_command_env(command)
+    command.gsub(/\$(\w+)/) { |e| ENV[e[1..-1]] }
+  end
+
+  def with_environment(environment)
+    original = ENV.to_hash
+    ENV.update environment
+    yield
+  ensure
+    ENV.replace original
+  end
 end

data/lib/foreman/procfile.rb

@@ -1,4 +1,5 @@
 require "foreman"
+require "foreman/procfile_entry"
 
 # A valid Procfile entry is captured by this regex.
 # All other lines are ignored.
@@ -10,18 +11,18 @@ require "foreman"
 #
 class Foreman::Procfile
 
-  attr_reader :processes
+  attr_reader :entries
 
   def initialize(filename)
-    @processes = parse_procfile(filename)
+    @entries = parse_procfile(filename)
   end
 
-  def process_names
-    processes.map(&:name)
+  def [](name)
+    entries.detect { |entry| entry.name == name }
   end
 
-  def [](name)
-    processes.detect { |process| process.name == name }
+  def process_names
+    entries.map(&:name)
   end
 
 private
@@ -29,7 +30,7 @@ private
   def parse_procfile(filename)
     File.read(filename).split("\n").map do |line|
       if line =~ /^([A-Za-z0-9_]+):\s*(.+)$/
-        Foreman::Process.new($1, $2)
+        Foreman::ProcfileEntry.new($1, $2)
       end
     end.compact
   end

data/lib/foreman/procfile_entry.rb

@@ -0,0 +1,22 @@
+require "foreman"
+
+class Foreman::ProcfileEntry
+
+  attr_reader :name
+  attr_reader :command
+  attr_accessor :color
+
+  def initialize(name, command)
+    @name = name
+    @command = command
+  end
+
+  def spawn(num, pipe, basedir, environment, base_port)
+    (1..num).to_a.map do |n|
+      process = Foreman::Process.new(self, n, base_port + (n-1))
+      process.run(pipe, basedir, environment)
+      process
+    end
+  end
+
+end

data/lib/foreman/utils.rb

@@ -5,7 +5,10 @@ class Foreman::Utils
   def self.parse_concurrency(concurrency)
     begin
       pairs = concurrency.to_s.gsub(/\s/, "").split(",")
-      pairs.inject(Hash.new(1)) do |hash, pair|
+      
+      default = concurrency.nil? ? 1 : 0
+      
+      pairs.inject(Hash.new(default)) do |hash, pair|
         process, amount = pair.split("=")
         hash.update(process => amount.to_i)        
       end

data/lib/foreman/version.rb

@@ -1,5 +1,5 @@
 module Foreman
 
-  VERSION = "0.27.0"
+  VERSION = "0.37.0"
 
 end

data/lib/foreman.rb

@@ -9,5 +9,17 @@ module Foreman
     require 'foreman/engine'
     Foreman::Engine.load_env!(env_file)
   end
-end
 
+  def self.runner
+    File.expand_path("../../bin/runner", __FILE__)
+  end
+
+  def self.jruby?
+    defined?(RUBY_PLATFORM) and RUBY_PLATFORM == "java"
+  end
+
+  def self.windows?
+    defined?(RUBY_PLATFORM) and RUBY_PLATFORM =~ /(win|w)32$/
+  end
+
+end

data/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" "November 2011" "Foreman 0.26.0" "Foreman Manual"
+.TH "FOREMAN" "1" "January 2012" "Foreman 0.33.1" "Foreman Manual"
 .
 .SH "NAME"
 \fBforeman\fR \- manage Procfile\-based applications
@@ -68,6 +68,10 @@ Specify the user the application should be run as\. Defaults to the app name
 These options control all modes of foreman\'s operation\.
 .
 .TP
+\fB\-d\fR, \fB\-\-directory\fR
+Specify an alternate application root\. This defaults to the directory containing the Procfile\.
+.
+.TP
 \fB\-e\fR, \fB\-\-env\fR
 Specify an alternate environment file\. You can specify more than one file by using: \fB\-\-env file1,file2\fR\.
 .

data/spec/foreman/cli_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "foreman/cli"
 
-describe "Foreman::CLI" do
+describe "Foreman::CLI", :fakefs do
   subject { Foreman::CLI.new }
 
   describe "start" do
@@ -27,10 +27,21 @@ describe "Foreman::CLI" do
 
   describe "export" do
     describe "options" do
+      it "uses .foreman" do
+        write_procfile
+        File.open(".foreman", "w") { |f| f.puts "concurrency: alpha=2" }
+        mock_export = mock(Foreman::Export::Upstart)
+        mock(Foreman::Export::Upstart).new("/upstart", is_a(Foreman::Engine), { "concurrency" => "alpha=2" }) { mock_export }
+        mock_export.export
+        foreman %{ export upstart /upstart }
+      end
+
       it "respects --env" do
         write_procfile
         write_env("envfile")
-        mock.instance_of(Foreman::Export::Upstart).export("/upstart", { "env" => "envfile" })
+        mock_export = mock(Foreman::Export::Upstart)
+        mock(Foreman::Export::Upstart).new("/upstart", is_a(Foreman::Engine), { "env" => "envfile" }) { mock_export }
+        mock_export.export
         foreman %{ export upstart /upstart --env envfile }
       end
     end
@@ -47,10 +58,18 @@ describe "Foreman::CLI" do
     describe "with a Procfile" do
       before(:each) { write_procfile }
 
-      describe "with an invalid formatter" do
+      describe "with a formatter with a generic error" do
+        before do
+          mock(Foreman::Export).formatter("errorful") { Class.new(Foreman::Export::Base) do
+            def export
+              raise Foreman::Export::Exception.new("foo")
+            end
+          end }
+        end
+
         it "prints an error" do
-          mock_error(subject, "Unknown export format: invalidformatter.") do
-            subject.export("invalidformatter")
+          mock_error(subject, "foo") do
+            subject.export("errorful")
           end
         end
       end
@@ -60,7 +79,9 @@ describe "Foreman::CLI" do
 
         it "runs successfully" do
           dont_allow(subject).error
-          mock.instance_of(Foreman::Export::Upstart).export("/tmp/foo", {})
+          mock_export = mock(Foreman::Export::Upstart)
+          mock(Foreman::Export::Upstart).new("/tmp/foo", is_a(Foreman::Engine), {}) { mock_export }
+          mock_export.export
           subject.export("upstart", "/tmp/foo")
         end
       end
@@ -72,7 +93,7 @@ describe "Foreman::CLI" do
       before { write_procfile }
 
       it "displays the jobs" do
-        mock(subject).display("valid procfile detected (alpha, bravo)")
+        mock(subject).puts("valid procfile detected (alpha, bravo)")
         subject.check
       end
     end
@@ -90,4 +111,53 @@ describe "Foreman::CLI" do
     end
   end
 
+  describe "run" do
+    describe "with a valid Procfile" do
+      before { write_procfile }
+
+      describe "and a command" do
+        let(:command) { ["ls", "-l"] }
+
+        before(:each) do
+          stub(subject).exec
+        end
+
+        it "should load the environment file" do
+          write_env
+          preserving_env do
+            subject.run *command
+            ENV["FOO"].should == "bar"
+          end
+
+          ENV["FOO"].should be_nil
+        end
+
+        it "should runute the command as a string" do
+          mock(subject).exec(command.join(" "))
+          subject.run *command
+        end
+      end
+
+      describe "and a non-existent command" do
+        let(:command) { "iuhtngrglhulhdfg" }
+
+        it "should print an error" do
+          mock_error(subject, "command not found: #{command}") do
+            subject.run command
+          end
+        end
+      end
+
+      describe "and a non-executable command" do
+        let(:command) { __FILE__ }
+
+        it "should print an error" do
+          mock_error(subject, "not executable: #{command}") do
+            subject.run command
+          end
+        end
+      end
+    end
+  end
+
 end

data/spec/foreman/engine_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "foreman/engine"
 
-describe "Foreman::Engine" do
+describe "Foreman::Engine", :fakefs do
   subject { Foreman::Engine.new("Procfile", {}) }
 
   describe "initialize" do
@@ -24,8 +24,9 @@ describe "Foreman::Engine" do
   describe "start" do
     it "forks the processes" do
       write_procfile
-      mock(subject).fork(subject.procfile["alpha"])
-      mock(subject).fork(subject.procfile["bravo"])
+      mock.instance_of(Foreman::Process).run_process(Dir.pwd, "./alpha", is_a(IO))
+      mock.instance_of(Foreman::Process).run_process(Dir.pwd, "./bravo", is_a(IO))
+      mock(subject).watch_for_output
       mock(subject).watch_for_termination
       subject.start
     end
@@ -33,29 +34,14 @@ describe "Foreman::Engine" do
     it "handles concurrency" do
       write_procfile
       engine = Foreman::Engine.new("Procfile",:concurrency => "alpha=2")
-      mock(engine).fork_individual(engine.procfile["alpha"], 1, 5000)
-      mock(engine).fork_individual(engine.procfile["alpha"], 2, 5001)
-      mock(engine).fork_individual(engine.procfile["bravo"], 1, 5100)
+      mock.instance_of(Foreman::Process).run_process(Dir.pwd, "./alpha", is_a(IO)).twice
+      mock.instance_of(Foreman::Process).run_process(Dir.pwd, "./bravo", is_a(IO)).never
+      mock(engine).watch_for_output
       mock(engine).watch_for_termination
       engine.start
     end
   end
 
-  describe "execute" do
-    it "runs the processes" do
-      write_procfile
-      mock(subject).fork(subject.procfile["alpha"])
-      mock(subject).watch_for_termination
-      subject.execute("alpha")
-    end
-
-    it "shows an error running a process that doesnt exist" do
-      write_procfile
-      mock(subject).puts("ERROR: no such process: foo")
-      lambda { subject.execute("foo") }.should raise_error(SystemExit)
-    end
-  end
-
   describe "environment" do
     before(:each) do
       write_procfile
@@ -66,9 +52,10 @@ describe "Foreman::Engine" do
       File.open("/tmp/env", "w") { |f| f.puts("FOO=baz") }
       engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
       stub(engine).info
+      mock(engine).spawn_processes
       mock(engine).watch_for_termination
       engine.environment.should == {"FOO"=>"baz"}
-      engine.execute("alpha")
+      engine.start
     end
 
     it "should read more than one if specified" do
@@ -76,9 +63,10 @@ describe "Foreman::Engine" do
       File.open("/tmp/env2", "w") { |f| f.puts("BAZ=qux") }
       engine = Foreman::Engine.new("Procfile", :env => "/tmp/env1,/tmp/env2")
       stub(engine).info
+      mock(engine).spawn_processes
       mock(engine).watch_for_termination
       engine.environment.should == { "FOO"=>"bar", "BAZ"=>"qux" }
-      engine.execute("alpha")
+      engine.start
     end
 
     it "should fail if specified and doesnt exist" do
@@ -89,11 +77,10 @@ describe "Foreman::Engine" do
     it "should read .env if none specified" do
       File.open(".env", "w") { |f| f.puts("FOO=qoo") }
       engine = Foreman::Engine.new("Procfile")
-      stub(engine).info
+      mock(engine).spawn_processes
       mock(engine).watch_for_termination
-      mock(engine).fork_individual(anything, anything, anything)
       engine.environment.should == {"FOO"=>"qoo"}
-      engine.execute("bravo")
+      engine.start
     end
   end
 end

data/spec/foreman/export/base_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "foreman/export/base"
+
+describe "Foreman::Export::Base" do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:location) { "/tmp/init" }
+  let(:engine)   { Foreman::Engine.new(procfile) }
+  let(:subject)  { Foreman::Export::Base.new(location, engine) }
+
+  it "has a say method for displaying info" do
+    mock(subject).puts("[foreman export] foo")
+    subject.send(:say, "foo")
+  end
+
+  it "export needs to be overridden" do
+    lambda { subject.export }.should raise_error("export method must be overridden")
+  end
+
+  it "raises errors as a Foreman::Export::Exception" do
+    lambda { subject.send(:error, "foo") }.should raise_error(Foreman::Export::Exception, "foo")
+  end
+end

data/spec/foreman/export/bluepill_spec.rb

@@ -3,18 +3,34 @@ require "foreman/engine"
 require "foreman/export/bluepill"
 require "tmpdir"
 
-describe Foreman::Export::Bluepill do
+describe Foreman::Export::Bluepill, :fakefs 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) }
+  let(:engine)   { Foreman::Engine.new(procfile) }
+  let(:options)  { Hash.new }
+  let(:bluepill) { Foreman::Export::Bluepill.new("/tmp/init", engine, options) }
 
   before(:each) { load_export_templates_into_fakefs("bluepill") }
   before(:each) { stub(bluepill).say }
 
   it "exports to the filesystem" do
-    bluepill.export("/tmp/init", :concurrency => "alpha=2")
-    
-    File.read("/tmp/init/app.pill").should == example_export_file("bluepill/app.pill")
+    bluepill.export
+    normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app.pill"))
   end
 
-end
+  it "cleans up if exporting into an existing dir" do
+    mock(FileUtils).rm("/tmp/init/app.pill")
+
+    bluepill.export
+    bluepill.export
+  end
+
+  context  "with concurrency" do
+    let(:options) { Hash[:concurrency => "alpha=2"] }
+
+    it "exports to the filesystem with concurrency" do
+      bluepill.export
+      normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app-concurrency.pill"))
+    end
+  end
+
+end

data/spec/foreman/export/inittab_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/inittab"
+require "tmpdir"
+
+describe Foreman::Export::Inittab, :fakefs do
+  let(:location) { "/tmp/inittab" }
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:location) { "/tmp/inittab" }
+  let(:engine)   { Foreman::Engine.new(procfile) }
+  let(:options)  { Hash.new }
+  let(:inittab)  { Foreman::Export::Inittab.new(location, engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("inittab") }
+  before(:each) { stub(inittab).say }
+
+  it "exports to the filesystem" do
+    inittab.export
+    File.read("/tmp/inittab").should == example_export_file("inittab/inittab.default")
+  end
+
+  context "to stdout" do
+    let(:location) { "-" }
+
+    it "exports to stdout" do
+      mock(inittab).puts example_export_file("inittab/inittab.default")
+      inittab.export
+    end
+  end
+
+  context "with concurrency" do
+    let(:options) { Hash[:concurrency => "alpha=2"] }
+
+    it "exports to the filesystem with concurrency" do
+      inittab.export
+      File.read("/tmp/inittab").should == example_export_file("inittab/inittab.concurrency")
+    end
+  end
+
+end