foreman 0.47.0 → 0.48.0.pre1

data/spec/foreman/process_spec.rb

@@ -5,141 +5,44 @@ 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 }
+  def run(process, options={})
+    rd, wr = IO.method(:pipe).arity.zero? ? IO.pipe : IO.pipe("BINARY")
+    process.run(options.merge(:output => wr))
+    rd.gets
+  end
 
-    after { FileUtils.remove_entry_secure basedir }
+  describe "#run" do
 
-    def run(cmd=command)
-      entry.command = cmd
-      subject.run pipe, basedir, env
-      subject.detach && sleep(init_delta)
+    it "runs the process" do
+      process = Foreman::Process.new(resource_path("bin/test"))
+      run(process).should == "testing\n"
     end
 
-    def run_file(executable, code)
-      file = File.open("#{basedir}/script", 'w') {|it| it << code }
-      run "#{executable} #{file.path}"
-      sleep 1
+    it "can set environment" do
+      process = Foreman::Process.new(resource_path("bin/env FOO"), :env => { "FOO" => "bar" })
+      run(process).should == "bar\n"
     end
 
-    context 'options' do
-      it 'should set PORT for environment' do
-        mock(subject).run_process(basedir, command, pipe) do
-          ENV['PORT'].should == port.to_s
-        end
-        run
-      end
-
-      it 'should set custom variables for environment' do
-        mock(subject).run_process(basedir, command, pipe) do
-          ENV['foo'].should == 'bar'
-        end
-        run
-      end
-
-      it 'should restore environment afterwards' do
-        mock(subject).run_process(basedir, command, pipe)
-        run
-        ENV.should_not include('PORT', 'foo')
-      end
+    it "can set per-run environment" do
+      process = Foreman::Process.new(resource_path("bin/env FOO"))
+      run(process, :env => { "FOO" => "bar "}).should == "bar\n"
     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.should be_alive
-        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 multi-word arguments (old test)' do
-        # TODO: This test used to be marked pending; it now passes,
-        # but is very slow.  The next test is a fast replacement.
-        run %{ sh -c "trap '' TERM; sleep 10" }
-        subject.should be_alive
-      end
+    it "can handle env vars in the command" do
+      process = Foreman::Process.new(resource_path("bin/echo $FOO"), :env => { "FOO" => "bar" })
+      run(process).should == "bar\n"
+    end
 
-      it 'should handle multi-word arguments' do
-        # We have to be a little clever here since Foreman will always
-        # print a status message that includes the command.
-        run %{ sh -c 'echo abcdef | tr a-c x | tr d-f y' }
-        output.should include('xxxyyy')
-      end
+    it "can handle per-run env vars in the command" do
+      process = Foreman::Process.new(resource_path("bin/echo $FOO"))
+      run(process, :env => { "FOO" => "bar" }).should == "bar\n"
+    end
 
-      it 'should not clobber "$x"-subexpressions' do
-        pending 'this conflicts with the variable interpolation hack'
-        run %{ sh -c 'echo \$abcdef | tr \$ %' }
-        output.should include('%abcdef')
-      end
+    it "should output utf8 properly" do
+      process = Foreman::Process.new(resource_path("bin/utf8"))
+      run(process).should == "\xFF\x03\n"
     end
   end
+
 end

data/spec/foreman/procfile_spec.rb

@@ -3,29 +3,39 @@ require 'foreman/procfile'
 require 'pathname'
 require 'tmpdir'
 
-describe Foreman::Procfile do
-  subject { described_class.new }
+describe Foreman::Procfile, :fakefs do
+  subject { Foreman::Procfile.new }
 
-  let(:testdir) { Pathname(Dir.tmpdir) }
-  let(:procfile) { testdir + 'Procfile' }
+  it "can load from a file" do
+    write_procfile
+    subject.load "Procfile"
+    subject["alpha"].should == "./alpha"
+    subject["bravo"].should == "./bravo"
+  end
+
+  it "loads a passed-in Procfile" do
+    write_procfile
+    procfile = Foreman::Procfile.new("Procfile")
+    procfile["alpha"].should == "./alpha"
+    procfile["bravo"].should == "./bravo"
+  end
 
   it "can have a process appended to it" do
-    subject << ['alpha', './alpha']
-    subject['alpha'].should be_a(Foreman::ProcfileEntry)
+    subject["charlie"] = "./charlie"
+    subject["charlie"].should == "./charlie"
   end
 
-  it "can write itself out to a file" do
-    subject << ['alpha', './alpha']
-    subject.write(procfile)
-    procfile.read.should == "alpha: ./alpha\n"
+  it "can write to a string" do
+    subject["foo"] = "./foo"
+    subject["bar"] = "./bar"
+    subject.to_s.should == "foo: ./foo\nbar: ./bar"
   end
 
-  it "can re-read entries from a file" do
-    procfile.open('w') { |io| io.puts "gamma: ./radiation", "theta: ./rate" }
-    subject << ['alpha', './alpha']
-    subject.load(procfile)
-    subject.process_names.should have(2).members
-    subject.process_names.should include('gamma', 'theta')
+  it "can write to a file" do
+    subject["foo"] = "./foo"
+    subject["bar"] = "./bar"
+    subject.save "/tmp/proc"
+    File.read("/tmp/proc").should == "foo: ./foo\nbar: ./bar\n"
   end
 
 end

data/spec/resources/Procfile

@@ -0,0 +1,4 @@
+echo: bin/echo echoing
+env:  bin/env  FOO
+test: bin/test
+utf8: bin/utf8

data/spec/resources/bin/echo

@@ -0,0 +1,2 @@
+#!/bin/sh
+echo $*

data/spec/resources/bin/env

@@ -0,0 +1,2 @@
+#!/bin/bash
+echo ${!1}

data/spec/resources/bin/test

@@ -0,0 +1,2 @@
+#!/bin/sh
+echo "testing"

data/spec/resources/export/bluepill/app-concurrency.pill

@@ -11,14 +11,14 @@ Bluepill.application("app", :foreground => false, :log_file => "/var/log/bluepil
 
     process.working_dir = "/tmp/app"
     process.daemonize = true
-    process.environment = {"PORT" => "5000"}
+    process.environment = {"PORT"=>"5000"}
     process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
     process.stop_grace_time = 45.seconds
 
     process.stdout = process.stderr = "/var/log/app/app-alpha-1.log"
 
     process.monitor_children do |children|
-      children.stop_command "kill -QUIT {{PID}}"
+      children.stop_command "kill {{PID}}"
     end
     
     process.group = "app-alpha"
@@ -30,14 +30,14 @@ Bluepill.application("app", :foreground => false, :log_file => "/var/log/bluepil
 
     process.working_dir = "/tmp/app"
     process.daemonize = true
-    process.environment = {"PORT" => "5001"}
+    process.environment = {"PORT"=>"5001"}
     process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
     process.stop_grace_time = 45.seconds
 
     process.stdout = process.stderr = "/var/log/app/app-alpha-2.log"
 
     process.monitor_children do |children|
-      children.stop_command "kill -QUIT {{PID}}"
+      children.stop_command "kill {{PID}}"
     end
     
     process.group = "app-alpha"

data/spec/resources/export/bluepill/app.pill

@@ -11,14 +11,14 @@ Bluepill.application("app", :foreground => false, :log_file => "/var/log/bluepil
 
     process.working_dir = "/tmp/app"
     process.daemonize = true
-    process.environment = {"PORT" => "5000"}
+    process.environment = {"PORT"=>"5000"}
     process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
     process.stop_grace_time = 45.seconds
 
     process.stdout = process.stderr = "/var/log/app/app-alpha-1.log"
 
     process.monitor_children do |children|
-      children.stop_command "kill -QUIT {{PID}}"
+      children.stop_command "kill {{PID}}"
     end
 
     process.group = "app-alpha"
@@ -29,14 +29,14 @@ Bluepill.application("app", :foreground => false, :log_file => "/var/log/bluepil
 
     process.working_dir = "/tmp/app"
     process.daemonize = true
-    process.environment = {"PORT" => "5100"}
+    process.environment = {"PORT"=>"5100"}
     process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
     process.stop_grace_time = 45.seconds
 
     process.stdout = process.stderr = "/var/log/app/app-bravo-1.log"
 
     process.monitor_children do |children|
-      children.stop_command "kill -QUIT {{PID}}"
+      children.stop_command "kill {{PID}}"
     end
 
     process.group = "app-bravo"

data/spec/resources/export/supervisord/app-alpha-1.conf

@@ -0,0 +1,24 @@
+
+[program:app-alpha-1]
+command=./alpha
+autostart=true
+autorestart=true
+stopsignal=QUIT
+stdout_logfile=/var/log/app/alpha-1.log
+stderr_logfile=/var/log/app/alpha-1.error.log
+user=app
+directory=/tmp/app
+environment=PORT="5000"
+[program:app-bravo-1]
+command=./bravo
+autostart=true
+autorestart=true
+stopsignal=QUIT
+stdout_logfile=/var/log/app/bravo-1.log
+stderr_logfile=/var/log/app/bravo-1.error.log
+user=app
+directory=/tmp/app
+environment=PORT="5100"
+
+[group:app]
+programs=app-alpha-1,app-bravo-1

data/spec/resources/export/supervisord/app-alpha-2.conf

@@ -4,8 +4,8 @@ command=./alpha
 autostart=true
 autorestart=true
 stopsignal=QUIT
-stdout_logfile=/var/log/app/alpha-1-out.log
-stderr_logfile=/var/log/app/alpha-1-err.log
+stdout_logfile=/var/log/app/alpha-1.log
+stderr_logfile=/var/log/app/alpha-1.error.log
 user=app
 directory=/tmp/app
 environment=PORT="5000"
@@ -14,8 +14,8 @@ command=./alpha
 autostart=true
 autorestart=true
 stopsignal=QUIT
-stdout_logfile=/var/log/app/alpha-2-out.log
-stderr_logfile=/var/log/app/alpha-2-err.log
+stdout_logfile=/var/log/app/alpha-2.log
+stderr_logfile=/var/log/app/alpha-2.error.log
 user=app
 directory=/tmp/app
 environment=PORT="5001"

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ SimpleCov.start do
 end
 
 require "rspec"
+require "timecop"
 require "fakefs/safe"
 require "fakefs/spec_helpers"
 
@@ -23,7 +24,39 @@ def mock_error(subject, message)
 end
 
 def foreman(args)
-  Foreman::CLI.start(args.split(" "))
+  capture_stdout do
+    begin
+      Foreman::CLI.start(args.split(" "))
+    rescue SystemExit
+    end
+  end
+end
+
+def forked_foreman(args)
+  rd, wr = IO.pipe("BINARY")
+  Process.spawn("bundle exec bin/foreman #{args}", :out => wr, :err => wr)
+  wr.close
+  rd.read
+end
+
+def fork_and_capture(&blk)
+  rd, wr = IO.pipe("BINARY")
+  pid = fork do
+    rd.close
+    wr.sync = true
+    $stdout.reopen wr
+    $stderr.reopen wr
+    blk.call
+    $stdout.flush
+    $stdout.close
+  end
+  wr.close
+  Process.wait pid
+  buffer = ""
+  until rd.eof?
+    p [:foo]
+    buffer += rd.gets
+  end
 end
 
 def mock_exit(&block)
@@ -55,13 +88,21 @@ def write_env(env=".env", options={"FOO"=>"bar"})
   end
 end
 
-def load_export_templates_into_fakefs(type)
+def without_fakefs
   FakeFS.deactivate!
-  files = Dir[File.expand_path("../../data/export/#{type}/**", __FILE__)].inject({}) do |hash, file|
-    hash.update(file => File.read(file))
-  end
+  ret = yield
   FakeFS.activate!
-  files.each do |filename, contents|
+  ret
+end
+
+def load_export_templates_into_fakefs(type)
+  without_fakefs do
+    Dir[File.expand_path("../../data/export/#{type}/**/*", __FILE__)].inject({}) do |hash, file|
+      next(hash) if File.directory?(file)
+      hash.update(file => File.read(file))
+    end
+  end.each do |filename, contents|
+    FileUtils.mkdir_p File.dirname(filename)
     File.open(filename, "w") do |f|
       f.puts contents
     end
@@ -93,6 +134,17 @@ def normalize_space(s)
   s.gsub(/\n[\n\s]*/, "\n")
 end
 
+def capture_stdout
+  old_stdout = $stdout.dup
+  rd, wr = IO.method(:pipe).arity.zero? ? IO.pipe : IO.pipe("BINARY")
+  $stdout = wr
+  yield
+  wr.close
+  rd.read
+ensure
+  $stdout = old_stdout
+end
+
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.color_enabled = true