foreman 0.67.0-mingw32 → 0.69.0-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e3f0ce389e868ec19b47ed04ec78d0405d538bb
+  data.tar.gz: 2e0ee712ccc6f8e4ab192518f3ba4ddb840b22b2
+SHA512:
+  metadata.gz: 6a34b4e3e790bd5f8d609dceb55f66c50fc295a5ab1ad3589f31be7be53471c21c44e7c99c09134b2745597ccfa9bb411bccbb6bbf390282c8177e81b47bca07
+  data.tar.gz: 680a8057e0d6c6ef0aa9f2e90f2c7f55bf3b1b551255ea355c08aafed72ae7f8279d4c39c32880adca244f20c54f7a538ff2a2dd168851bd99187e882d5736d9

data/README.md

@@ -1,5 +1,8 @@
 # Foreman
 
+[![Build Status](https://travis-ci.org/ddollar/foreman.svg?branch=master)](https://travis-ci.org/ddollar/foreman)
+[![Code Climate](https://codeclimate.com/github/ddollar/foreman.png)](https://codeclimate.com/github/ddollar/foreman)
+
 Manage Procfile-based applications
 
 <table>
@@ -17,10 +20,21 @@ Manage Procfile-based applications
   </tr>
 </table>
 
+## Installation
+
+    $ gem install foreman
+
+Ruby users should take care *not* to install foreman in their project's `Gemfile`.
+
 ## Getting Started
 
 * http://blog.daviddollar.org/2011/05/06/introducing-foreman.html
 
+## Supported Ruby versions
+
+* 1.9.3
+* 2.0.0
+
 ## Documentation
 
 * [man page](http://ddollar.github.com/foreman)

data/data/export/upstart/process.conf.erb

@@ -11,4 +11,4 @@ setuid <%= user %>
 
 chdir <%= engine.root %>
 
-exec <%= process.command %>
+exec <%= process.command %> >> <%= log %>/<%=name%>-<%=num%>.log 2>&1

data/lib/foreman.rb

@@ -2,8 +2,6 @@ require "foreman/version"
 
 module Foreman
 
-  class AppDoesNotExist < Exception; end
-
   def self.runner
     File.expand_path("../../bin/foreman-runner", __FILE__)
   end

data/lib/foreman/cli.rb

@@ -34,7 +34,6 @@ class Foreman::CLI < Thor
   end
 
   def start(process=nil)
-    require_posix_spawn_for_ruby_18!
     check_procfile!
     load_environment!
     engine.load_procfile(procfile)
@@ -139,14 +138,6 @@ private ######################################################################
     end
   end
 
-  def require_posix_spawn_for_ruby_18!
-    begin
-      Kernel.require 'posix/spawn' # Use Kernel explicitly so we can mock the require call in the spec
-    rescue LoadError
-      error "foreman requires gem `posix-spawn` on Ruby #{RUBY_VERSION}. Please `gem install posix-spawn`."
-    end if Foreman.ruby_18?
-  end
-
   def procfile
     case
       when options[:procfile] then options[:procfile]

data/lib/foreman/engine.rb

@@ -367,33 +367,39 @@ private
     end
   end
 
+  def read_self_pipe
+    @selfpipe[:reader].read_nonblock(11)
+  rescue Errno::EAGAIN, Errno::EINTR => err
+    # ignore
+  end
+
+  def handle_signals
+    while sig = Thread.main[:signal_queue].shift
+      self.handle_signal(sig)
+    end
+  end
+
+  def handle_io(readers)
+    readers.each do |reader|
+      next if reader == @selfpipe[:reader]
+
+      if reader.eof?
+        @readers.delete_if { |key, value| value == reader }
+      else
+        data = reader.gets
+        output_with_mutex name_for(@readers.invert[reader]), data
+      end
+    end
+  end
+
   def watch_for_output
     Thread.new do
       begin
         loop do
           io = IO.select([@selfpipe[:reader]] + @readers.values, nil, nil, 30)
-
-          begin
-            @selfpipe[:reader].read_nonblock(11)
-          rescue Errno::EAGAIN, Errno::EINTR => err
-            # ignore
-          end
-
-          # Look for any signals that arrived and handle them
-          while sig = Thread.main[:signal_queue].shift
-            self.handle_signal(sig)
-          end
-
-          (io.nil? ? [] : io.first).each do |reader|
-            next if reader == @selfpipe[:reader]
-
-            if reader.eof?
-              @readers.delete_if { |key, value| value == reader }
-            else
-              data = reader.gets
-              output_with_mutex name_for(@readers.invert[reader]), data
-            end
-          end
+          read_self_pipe
+          handle_signals
+          handle_io(io ? io.first : [])
         end
       rescue Exception => ex
         puts ex.message

data/lib/foreman/process.rb

@@ -50,17 +50,8 @@ class Foreman::Process
     output = options[:output] || $stdout
     runner = "#{Foreman.runner}".shellescape
     
-    if Foreman.windows?
-      Dir.chdir(cwd) do
-        Process.spawn env, expanded_command(env), :out => output, :err => output
-      end
-    elsif Foreman.jruby_18? || Foreman.ruby_18?
-      require "posix/spawn"
-      wrapped_command = "#{runner} -d '#{cwd.shellescape}' -p -- #{expanded_command(env)}"
-      POSIX::Spawn.spawn(*spawn_args(env, wrapped_command.shellsplit, {:out => output, :err => output}))
-    else
-      wrapped_command = "exec #{runner} -d '#{cwd.shellescape}' -p -- #{command}"
-      Process.spawn env, wrapped_command, :out => output, :err => output
+    Dir.chdir(cwd) do
+      Process.spawn env, expanded_command(env), :out => output, :err => output
     end
   end
 
@@ -78,36 +69,6 @@ class Foreman::Process
     Kernel.exec expanded_command(env)
   end
 
-  # Send a signal to this +Process+
-  #
-  # @param [String] signal  The signal to send
-  #
-  def kill(signal)
-    if Foreman.windows?
-      pid && Process.kill(signal, pid)
-    else
-      pid && Process.kill("-#{signal}", pid)
-    end
-  rescue Errno::ESRCH
-    false
-  end
-
-  # Test whether or not this +Process+ is still running
-  #
-  # @returns [Boolean]
-  #
-  def alive?
-    kill(0)
-  end
-
-  # Test whether or not this +Process+ has terminated
-  #
-  # @returns [Boolean]
-  #
-  def dead?
-    !alive?
-  end
-
   # Returns the working directory for this +Process+
   #
   # @returns [String]
@@ -116,14 +77,4 @@ class Foreman::Process
     File.expand_path(@options[:cwd] || ".")
   end
 
-private
-
-  def spawn_args(env, argv, options)
-    args = []
-    args << env
-    args += argv
-    args << options
-    args
-  end
-
 end

data/lib/foreman/version.rb

@@ -1,5 +1,5 @@
 module Foreman
 
-  VERSION = "0.67.0"
+  VERSION = "0.69.0"
 
 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" "April 2014" "Foreman 0.67.0" "Foreman Manual"
+.TH "FOREMAN" "1" "May 2014" "Foreman 0.69.0" "Foreman Manual"
 .
 .SH "NAME"
 \fBforeman\fR \- manage Procfile\-based applications

data/spec/foreman/cli_spec.rb

@@ -8,12 +8,12 @@ describe "Foreman::CLI", :fakefs do
     before { File.open(".foreman", "w") { |f| f.puts "formation: alpha=2" } }
 
     it "provides default options" do
-      subject.send(:options)["formation"].should == "alpha=2"
+      expect(subject.send(:options)["formation"]).to eq("alpha=2")
     end
 
     it "is overridden by options at the cli" do
       subject = Foreman::CLI.new([], :formation => "alpha=3")
-      subject.send(:options)["formation"].should == "alpha=3"
+      expect(subject.send(:options)["formation"]).to eq("alpha=3")
     end
   end
 
@@ -31,24 +31,24 @@ describe "Foreman::CLI", :fakefs do
       it "can run a single command" do
         without_fakefs do
           output = foreman("start env -f #{resource_path("Procfile")}")
-          output.should     =~ /env.1/
-          output.should_not =~ /test.1/
+          expect(output).to     match(/env.1/)
+          expect(output).not_to match(/test.1/)
         end
       end
 
       it "can run all commands" do
         without_fakefs do
           output = foreman("start -f #{resource_path("Procfile")} -e #{resource_path(".env")}")
-          output.should =~ /echo.1 \| echoing/
-          output.should =~ /env.1  \| bar/
-          output.should =~ /test.1 \| testing/
+          expect(output).to match(/echo.1 \| echoing/)
+          expect(output).to match(/env.1  \| bar/)
+          expect(output).to match(/test.1 \| testing/)
         end
       end
 
       it "sets PS variable with the process name" do
         without_fakefs do
           output = foreman("start -f #{resource_path("Procfile")}")
-          output.should =~ /ps.1   \| PS env var is ps.1/
+          expect(output).to match(/ps.1   \| PS env var is ps.1/)
         end
       end
     end
@@ -57,55 +57,47 @@ describe "Foreman::CLI", :fakefs do
   describe "check" do
     it "with a valid Procfile displays the jobs" do
       write_procfile
-      foreman("check").should == "valid procfile detected (alpha, bravo, foo_bar, foo-bar)\n"
+      expect(foreman("check")).to eq("valid procfile detected (alpha, bravo, foo_bar, foo-bar)\n")
     end
 
     it "with a blank Procfile displays an error" do
       FileUtils.touch "Procfile"
-      foreman("check").should == "ERROR: no processes defined\n"
+      expect(foreman("check")).to eq("ERROR: no processes defined\n")
     end
 
     it "without a Procfile displays an error" do
       FileUtils.rm_f "Procfile"
-      foreman("check").should == "ERROR: Procfile does not exist.\n"
+      expect(foreman("check")).to eq("ERROR: Procfile does not exist.\n")
     end
   end
 
   describe "run" do
     it "can run a command" do
-      forked_foreman("run echo 1").should == "1\n"
+      expect(forked_foreman("run echo 1")).to eq("1\n")
     end
 
     it "includes the environment" do
-      forked_foreman("run #{resource_path("bin/env FOO")} -e #{resource_path(".env")}").should == "bar\n"
+      expect(forked_foreman("run #{resource_path("bin/env FOO")} -e #{resource_path(".env")}")).to eq("bar\n")
     end
 
     it "can run a command from the Procfile" do
-      forked_foreman("run -f #{resource_path("Procfile")} test").should == "testing\n"
+      expect(forked_foreman("run -f #{resource_path("Procfile")} test")).to eq("testing\n")
     end
 
     it "exits with the same exit code as the command" do
-      fork_and_get_exitstatus("run echo 1").should == 0
-      fork_and_get_exitstatus("run date 'invalid_date'").should == 1
+      expect(fork_and_get_exitstatus("run echo 1")).to eq(0)
+      expect(fork_and_get_exitstatus("run date 'invalid_date'")).to eq(1)
     end
   end
 
   describe "version" do
     it "displays gem version" do
-      foreman("version").chomp.should == Foreman::VERSION
+      expect(foreman("version").chomp).to eq(Foreman::VERSION)
     end
 
     it "displays gem version on shortcut command" do
-      foreman("-v").chomp.should == Foreman::VERSION
+      expect(foreman("-v").chomp).to eq(Foreman::VERSION)
     end
   end
 
-  describe "when posix-spawn is not present on ruby 1.8" do
-    it "should fail with an error" do
-      mock(Kernel).require('posix/spawn') { raise LoadError }
-      output = foreman("start -f #{resource_path("Procfile")}")
-      output.should == "ERROR: foreman requires gem `posix-spawn` on Ruby #{RUBY_VERSION}. Please `gem install posix-spawn`.\n"
-    end
-  end if running_ruby_18?
-
 end

data/spec/foreman/engine_spec.rb

@@ -27,8 +27,8 @@ describe "Foreman::Engine", :fakefs do
       before { write_procfile }
 
       it "reads the processes" do
-        subject.process("alpha").command.should == "./alpha"
-        subject.process("bravo").command.should == "./bravo"
+        expect(subject.process("alpha").command).to eq("./alpha")
+        expect(subject.process("bravo").command).to eq("./bravo")
       end
     end
   end
@@ -56,7 +56,7 @@ describe "Foreman::Engine", :fakefs do
     it "has the directory default relative to the Procfile" do
       write_procfile "/some/app/Procfile"
       engine = Foreman::Engine.new.load_procfile("/some/app/Procfile")
-      engine.root.should == "/some/app"
+      expect(engine.root).to eq("/some/app")
     end
   end
 
@@ -64,7 +64,7 @@ describe "Foreman::Engine", :fakefs do
     it "should read env files" do
       File.open("/tmp/env", "w") { |f| f.puts("FOO=baz") }
       subject.load_env("/tmp/env")
-      subject.env["FOO"].should == "baz"
+      expect(subject.env["FOO"]).to eq("baz")
     end
 
     it "should read more than one if specified" do
@@ -72,8 +72,8 @@ describe "Foreman::Engine", :fakefs do
       File.open("/tmp/env2", "w") { |f| f.puts("BAZ=qux") }
       subject.load_env "/tmp/env1"
       subject.load_env "/tmp/env2"
-      subject.env["FOO"].should == "bar"
-      subject.env["BAZ"].should == "qux"
+      expect(subject.env["FOO"]).to eq("bar")
+      expect(subject.env["BAZ"]).to eq("qux")
     end
 
     it "should handle quoted values" do
@@ -84,10 +84,10 @@ describe "Foreman::Engine", :fakefs do
         f.puts 'OTHER="escaped\"quote"'
       end
       subject.load_env "/tmp/env"
-      subject.env["FOO"].should   == "bar"
-      subject.env["BAZ"].should   == "qux"
-      subject.env["FRED"].should  == "barney"
-      subject.env["OTHER"].should == 'escaped"quote'
+      expect(subject.env["FOO"]).to   eq("bar")
+      expect(subject.env["BAZ"]).to   eq("qux")
+      expect(subject.env["FRED"]).to  eq("barney")
+      expect(subject.env["OTHER"]).to eq('escaped"quote')
     end
 
     it "should handle multiline strings" do
@@ -95,17 +95,17 @@ describe "Foreman::Engine", :fakefs do
         f.puts 'FOO="bar\nbaz"'
       end
       subject.load_env "/tmp/env"
-      subject.env["FOO"].should == "bar\nbaz"
+      expect(subject.env["FOO"]).to eq("bar\nbaz")
     end
 
     it "should fail if specified and doesnt exist" do
-      lambda { subject.load_env "/tmp/env" }.should raise_error(Errno::ENOENT)
+      expect { subject.load_env "/tmp/env" }.to raise_error(Errno::ENOENT)
     end
 
     it "should set port from .env if specified" do
       File.open("/tmp/env", "w") { |f| f.puts("PORT=9000") }
       subject.load_env "/tmp/env"
-      subject.send(:base_port).should == 9000
+      expect(subject.send(:base_port)).to eq(9000)
     end
   end
 

data/spec/foreman/export/base_spec.rb

@@ -14,6 +14,6 @@ describe "Foreman::Export::Base", :fakefs do
   end
 
   it "raises errors as a Foreman::Export::Exception" do
-    lambda { subject.send(:error, "foo") }.should raise_error(Foreman::Export::Exception, "foo")
+    expect { subject.send(:error, "foo") }.to raise_error(Foreman::Export::Exception, "foo")
   end
 end

data/spec/foreman/export/bluepill_spec.rb

@@ -15,7 +15,7 @@ describe Foreman::Export::Bluepill, :fakefs do
 
   it "exports to the filesystem" do
     bluepill.export
-    normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app.pill"))
+    expect(normalize_space(File.read("/tmp/init/app.pill"))).to eq(normalize_space(example_export_file("bluepill/app.pill")))
   end
 
   it "cleans up if exporting into an existing dir" do
@@ -30,7 +30,7 @@ describe Foreman::Export::Bluepill, :fakefs do
 
     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"))
+      expect(normalize_space(File.read("/tmp/init/app.pill"))).to eq(normalize_space(example_export_file("bluepill/app-concurrency.pill")))
     end
   end
 

data/spec/foreman/export/daemon_spec.rb

@@ -16,11 +16,11 @@ describe Foreman::Export::Daemon, :fakefs do
   it "exports to the filesystem" do
     daemon.export
 
-    File.read("/tmp/init/app.conf").should         == example_export_file("daemon/app.conf")
-    File.read("/tmp/init/app-alpha.conf").should   == example_export_file("daemon/app-alpha.conf")
-    File.read("/tmp/init/app-alpha-1.conf").should == example_export_file("daemon/app-alpha-1.conf")
-    File.read("/tmp/init/app-bravo.conf").should   == example_export_file("daemon/app-bravo.conf")
-    File.read("/tmp/init/app-bravo-1.conf").should == example_export_file("daemon/app-bravo-1.conf")
+    expect(File.read("/tmp/init/app.conf")).to         eq(example_export_file("daemon/app.conf"))
+    expect(File.read("/tmp/init/app-alpha.conf")).to   eq(example_export_file("daemon/app-alpha.conf"))
+    expect(File.read("/tmp/init/app-alpha-1.conf")).to eq(example_export_file("daemon/app-alpha-1.conf"))
+    expect(File.read("/tmp/init/app-bravo.conf")).to   eq(example_export_file("daemon/app-bravo.conf"))
+    expect(File.read("/tmp/init/app-bravo-1.conf")).to eq(example_export_file("daemon/app-bravo-1.conf"))
   end
 
   it "cleans up if exporting into an existing dir" do
@@ -56,11 +56,11 @@ describe Foreman::Export::Daemon, :fakefs do
     it "exports to the filesystem with concurrency" do
       daemon.export
 
-      File.read("/tmp/init/app.conf").should            == example_export_file("daemon/app.conf")
-      File.read("/tmp/init/app-alpha.conf").should      == example_export_file("daemon/app-alpha.conf")
-      File.read("/tmp/init/app-alpha-1.conf").should    == example_export_file("daemon/app-alpha-1.conf")
-      File.read("/tmp/init/app-alpha-2.conf").should    == example_export_file("daemon/app-alpha-2.conf")
-      File.exists?("/tmp/init/app-bravo-1.conf").should == false
+      expect(File.read("/tmp/init/app.conf")).to            eq(example_export_file("daemon/app.conf"))
+      expect(File.read("/tmp/init/app-alpha.conf")).to      eq(example_export_file("daemon/app-alpha.conf"))
+      expect(File.read("/tmp/init/app-alpha-1.conf")).to    eq(example_export_file("daemon/app-alpha-1.conf"))
+      expect(File.read("/tmp/init/app-alpha-2.conf")).to    eq(example_export_file("daemon/app-alpha-2.conf"))
+      expect(File.exists?("/tmp/init/app-bravo-1.conf")).to eq(false)
     end
   end
 
@@ -75,7 +75,7 @@ describe Foreman::Export::Daemon, :fakefs do
 
     it "can export with alternate template files" do
       daemon.export
-      File.read("/tmp/init/app.conf").should == "alternate_template\n"
+      expect(File.read("/tmp/init/app.conf")).to eq("alternate_template\n")
     end
   end
 
@@ -90,7 +90,7 @@ describe Foreman::Export::Daemon, :fakefs do
 
     it "can export with alternate template files" do
       daemon.export
-      File.read("/tmp/init/app.conf").should == "default_alternate_template\n"
+      expect(File.read("/tmp/init/app.conf")).to eq("default_alternate_template\n")
     end
   end