Merge pull request #139 from brainopia/foreman

---

If you remember Ive wanted to implement a prototype of process-tree monitor (and therefore restore support for complex commands), but decided to start with specing current behavior and marking desired behavior as pending specs.

This pull-request is a first pass. Its mainly Foreman::Process specs and a bit of refactoring. Specs for Foreman::Engine will be coming next (theyll cover a wide ground of possible uses). Afterwards I will replace machinery a bit to remove pending specs and ensure the rest is still passing on all available to me platforms.

If you have any notices, Ill gladly hear them.

lib/foreman/engine.rb

@@ -73,7 +73,7 @@ private ######################################################################
   def kill_all(signal="SIGTERM")
     running_processes.each do |pid, process|
       info "sending #{signal} to pid #{pid}"
-      Process.kill(signal, pid) rescue Errno::ESRCH
+      process.kill signal
     end
   end
 

lib/foreman/process.rb

@@ -24,6 +24,24 @@ class Foreman::Process
     "%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)
@@ -69,12 +87,10 @@ private
   end
 
   def with_environment(environment)
-    old_env = ENV.each_pair.inject({}) { |h,(k,v)| h.update(k => v) }
-    environment.each { |k,v| ENV[k] = v }
-    ret = yield
-    ENV.clear
-    old_env.each { |k,v| ENV[k] = v}
-    ret
+    original = ENV.to_hash
+    ENV.update environment
+    yield
+  ensure
+    ENV.replace original
   end
-
 end

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
@@ -89,47 +89,47 @@ describe "Foreman::CLI" do
       end
     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

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

spec/foreman/export/bluepill_spec.rb

@@ -3,7 +3,7 @@ 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) }
@@ -18,7 +18,7 @@ describe Foreman::Export::Bluepill do
 
   it "exports to the filesystem with concurrency" do
     bluepill.export("/tmp/init", :concurrency => "alpha=2")
-    
+
     normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app-concurrency.pill"))
   end
-end
+end

spec/foreman/export/runit_spec.rb

@@ -3,34 +3,34 @@ require "foreman/engine"
 require "foreman/export/runit"
 require "tmpdir"
 
-describe Foreman::Export::Runit do
+describe Foreman::Export::Runit, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile", 'bar=baz') }
   let(:engine) { Foreman::Engine.new(procfile) }
   let(:runit) { Foreman::Export::Runit.new(engine) }
-  
+
   before(:each) { load_export_templates_into_fakefs("runit") }
   before(:each) { stub(runit).say }
   before(:each) { stub(FakeFS::FileUtils).chmod }
-  
+
   it "exports to the filesystem" do
     FileUtils.mkdir_p('/tmp/init')
     runit.export('/tmp/init', :concurrency => "alpha=2,bravo=1")
-    
+
     File.read("/tmp/init/app-alpha-1/run").should == example_export_file('runit/app-alpha-1-run')
-    File.read("/tmp/init/app-alpha-1/log/run").should == 
+    File.read("/tmp/init/app-alpha-1/log/run").should ==
         example_export_file('runit/app-alpha-1-log-run')
     File.read("/tmp/init/app-alpha-1/env/PORT").should == "5000\n"
     File.read("/tmp/init/app-alpha-1/env/BAR").should == "baz\n"
-    
+
     File.read("/tmp/init/app-alpha-2/run").should == example_export_file('runit/app-alpha-2-run')
-    File.read("/tmp/init/app-alpha-2/log/run").should == 
+    File.read("/tmp/init/app-alpha-2/log/run").should ==
         example_export_file('runit/app-alpha-2-log-run')
     File.read("/tmp/init/app-alpha-2/env/PORT").should == "5001\n"
     File.read("/tmp/init/app-alpha-2/env/BAR").should == "baz\n"
-    
+
     File.read("/tmp/init/app-bravo-1/run").should == example_export_file('runit/app-bravo-1-run')
-    File.read("/tmp/init/app-bravo-1/log/run").should == 
+    File.read("/tmp/init/app-bravo-1/log/run").should ==
         example_export_file('runit/app-bravo-1-log-run')
     File.read("/tmp/init/app-bravo-1/env/PORT").should == "5100\n"
   end
-end
+end

spec/foreman/export/upstart_spec.rb

@@ -3,7 +3,7 @@ require "foreman/engine"
 require "foreman/export/upstart"
 require "tmpdir"
 
-describe Foreman::Export::Upstart do
+describe Foreman::Export::Upstart, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
   let(:engine) { Foreman::Engine.new(procfile) }
   let(:upstart) { Foreman::Export::Upstart.new(engine) }

spec/foreman/process_spec.rb

@@ -1,2 +1,134 @@
-require "spec_helper"
-require "foreman/process"
+require 'spec_helper'
+require 'foreman/process'
+require 'ostruct'
+require 'timeout'
+require 'tmpdir'
+
+describe Foreman::Process do
+  subject { described_class.new entry, number, port }
+
+  let(:number)  { 1 }
+  let(:port)    { 777 }
+  let(:command) { :script }
+  let(:name)    { :foobar }
+  let(:entry)   { OpenStruct.new :name => name, :command => command }
+
+  its(:entry) { entry }
+  its(:num)   { number }
+  its(:port)  { port }
+  its(:name)  { "#{name}.#{port}" }
+  its(:pid)   { nil }
+
+  describe '#run' do
+    let(:pipe)       { :pipe }
+    let(:basedir)    { Dir.mktmpdir }
+    let(:env)        {{ 'foo' => 'bar' }}
+    let(:init_delta) { 0.1 }
+
+    after { FileUtils.remove_entry_secure basedir }
+
+    def run(cmd=command)
+      entry.command = cmd
+      subject.run pipe, basedir, env
+      subject.detach && sleep(init_delta)
+    end
+
+    def run_file(executable, code)
+      file = File.open("#{basedir}/script.rb", 'w+') {|it| it << code }
+      run "#{executable} #{file.path}"
+    end
+
+    context 'options' do
+      it 'should change to basedir' do
+        mock(Dir).chdir basedir
+        run
+      end
+
+      it 'should set PORT for environment' do
+        mock(subject).run_process(command, pipe) do
+          ENV['PORT'].should == port.to_s
+        end
+        run
+      end
+
+      it 'should set custom variables for environment' do
+        mock(subject).run_process(command, pipe) do
+          ENV['foo'].should == 'bar'
+        end
+        run
+      end
+
+      it 'should restore environment afterwards' do
+        mock(subject).run_process command, pipe
+        run
+        ENV.should_not include('PORT', 'foo')
+      end
+    end
+
+    context 'process' do
+      around do |spec|
+        IO.pipe do |reader, writer|
+          @reader, @writer = reader, writer
+          spec.run
+        end
+      end
+
+      let(:pipe) { @writer }
+      let(:output) { @reader.read_nonblock 1024 }
+
+      it 'should not block' do
+        expect {
+          Timeout.timeout(2*init_delta) { run 'sleep 2' }
+        }.should_not raise_exception
+      end
+
+      it 'should be alive' do
+        run 'sleep 1'
+        subject.should be_alive
+      end
+
+      it 'should be dead' do
+        run 'exit'
+        subject.should be_dead
+      end
+
+      it 'should be killable' do
+        run 'sleep 1'
+        subject.kill 'TERM'
+        subject.should be_dead
+      end
+
+      it 'should send different signals' do
+        run_file 'ruby', <<-CODE
+          trap 'TERM', 'IGNORE'
+          loop { sleep 1 }
+        CODE
+        subject.kill 'TERM'
+        subject.should be_alive
+        subject.kill 'KILL'
+        subject.should be_dead
+      end
+
+      it 'should redirect stdout' do
+        run 'echo hey'
+        output.should include('hey')
+      end
+
+      it 'should redirect stderr' do
+        run 'echo hey >2'
+        output.should include('hey')
+      end
+
+      it 'should handle variables' do
+        run 'echo $PORT'
+        output.should include('777')
+      end
+
+      it 'should handle arguments' do
+        pending
+        run %{ sh -c "trap '' TERM; sleep 10" }
+        subject.should be_alive
+      end
+    end
+  end
+end

spec/foreman_spec.rb

@@ -8,13 +8,8 @@ describe Foreman do
     it { should be_a String }
   end
 
-  describe "::load_env!(env_file)" do
-    before do
-      FakeFS.activate!
-    end
-
+  describe "::load_env!(env_file)", :fakefs do
     after do
-      FakeFS.deactivate!
       ENV['FOO'] = nil
     end
 
@@ -22,7 +17,7 @@ describe Foreman do
       File.open("/tmp/env1", "w") { |f| f.puts("FOO=bar") }
       Foreman.load_env!("/tmp/env1")
       ENV['FOO'].should == 'bar'
-    end 
+    end
 
     it "should assume env_file in ./.env" do
       File.open("./.env", "w") { |f| f.puts("FOO=bar") }

spec/helper_spec.rb

@@ -3,16 +3,16 @@ require "spec_helper"
 describe "spec helpers" do
   describe "#preserving_env" do
     after { ENV.delete "FOO" }
-    
+
     it "should remove added environment vars" do
       preserving_env { ENV["FOO"] = "baz" }
       ENV["FOO"].should == nil
     end
-    
+
     it "should reset modified environment vars" do
       ENV["FOO"] = "bar"
       preserving_env { ENV["FOO"] = "baz"}
       ENV["FOO"].should == "bar"
     end
   end
-end
+end

spec/spec_helper.rb

@@ -76,10 +76,11 @@ end
 def normalize_space(s)
   s.gsub(/\n[\n\s]*/, "\n")
 end
-  
+
 RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.color_enabled = true
   config.order = 'rand'
-  config.include FakeFS::SpecHelpers
+  config.include FakeFS::SpecHelpers, :fakefs
   config.mock_with :rr
 end