foreman 0.0.1

data/README.rdoc

@@ -0,0 +1,77 @@
+= Foreman
+
+=== Procfile
+
+    alpha ./bin/alpha
+    bravo ./bin/bravo some args
+    charlie ./bin/charlie -n 5
+
+== Development mode
+
+=== Running
+
+    $ foreman start
+    [foreman] [Tue May 18 01:27:08 UTC 2010] [alpha] started with pid 4393
+    [foreman] [Tue May 18 01:27:08 UTC 2010] [bravo] started with pid 4394
+    [foreman] [Tue May 18 01:27:08 UTC 2010] [charlie] started with pid 4395
+
+=== Standardized Logging
+
+    log/alpha.log
+    log/bravo.log
+    log/charlie.log
+
+== Upstart
+
+=== Export to upstart scripts
+
+    $ foreman export sampleapp
+
+    $ initctl list | grep sampleapp
+    sampleapp start/running
+    sampleapp-alpha (1) start/running, process 4204
+    sampleapp-bravo (1) start/running, process 4589
+    sampleapp-charlie (1) start/running, process 4597
+
+=== Change process concurrency levels
+
+    $ foreman scale sampleapp alpha 4
+    sampleapp-alpha (2) start/running, process 4164
+    sampleapp-alpha (3) start/running, process 4166
+    sampleapp-alpha (4) start/running, process 4168
+
+    $ initctl list | grep sampleapp
+    sampleapp start/running
+    sampleapp-alpha (4) start/running, process 4168
+    sampleapp-alpha (3) start/running, process 4166
+    sampleapp-alpha (2) start/running, process 4164
+    sampleapp-alpha (1) start/running, process 4204
+    sampleapp-bravo (1) start/running, process 4589
+    sampleapp-charlie (1) start/running, process 4597
+
+    $ foreman scale sampleapp alpha 1
+    sampleapp-alpha stop/waiting
+    sampleapp-alpha stop/waiting
+    sampleapp-alpha stop/waiting
+
+=== Good Upstart citizen
+
+All Upstart commands work as expected
+
+    $ start sampleapp
+    $ stop sampleapp
+    $ restart sampleapp
+
+=== Standardized Logging
+
+    /var/log/sampleapp/alpha.log
+    /var/log/sampleapp/bravo.log
+    /var/log/sampleapp/charlie.log
+
+== License
+
+MIT
+
+== Copyright
+
+(c) 2010 David Dollar

data/Rakefile

@@ -0,0 +1,60 @@
+require "rubygems"
+require "rake"
+require "rspec/core/rake_task"
+
+$:.unshift File.expand_path("../lib", __FILE__)
+require "foreman"
+
+task :default => :spec
+
+desc "Run all specs"
+Rspec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+desc "Generate RCov code coverage report"
+task :rcov => "rcov:build" do
+  %x{ open coverage/index.html }
+end
+
+Rspec::Core::RakeTask.new("rcov:build") do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rcov = true
+  t.rcov_opts = [ "--exclude", Gem.default_dir , "--exclude", "spec" ]
+end
+
+######################################################
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name    = "foreman"
+    s.version = Foreman::VERSION
+
+    s.summary     = "Process manager for applications with multiple components"
+    s.description = s.summary
+    s.author      = "David Dollar"
+    s.email       = "ddollar@gmail.com"
+    s.homepage    = "http://github.com/ddollar/foreman"
+
+    s.platform = Gem::Platform::RUBY
+    s.has_rdoc = false
+
+    s.files = %w(Rakefile README.md) + Dir["{bin,lib,spec}/**/*"]
+    s.require_path = "lib"
+
+    # #s.bindir             = "bin"
+    # s.executables        = Dir["bin/*"]
+    s.default_executable = "foreman"
+
+    s.add_development_dependency 'fakefs', '~> 0.2.1'
+    s.add_development_dependency 'rake',   '~> 0.8.7'
+    s.add_development_dependency 'rcov',   '~> 0.9.8'
+    s.add_development_dependency 'rr',     '~> 0.10.11'
+    s.add_development_dependency 'rspec',  '~> 2.0.0'
+
+    s.add_dependency 'thor', '~> 0.13.6'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/bin/foreman

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "foreman/cli"
+
+Foreman::CLI.start

data/lib/foreman.rb

@@ -0,0 +1,8 @@
+module Foreman
+
+  VERSION = "0.0.1"
+
+  class AppDoesNotExist < Exception; end
+
+end
+

data/lib/foreman/cli.rb

@@ -0,0 +1,50 @@
+require "foreman"
+require "foreman/configuration"
+require "foreman/engine"
+require "foreman/export"
+require "thor"
+
+class Foreman::CLI < Thor
+
+  desc "start [PROCFILE]", "Run the app described in PROCFILE"
+
+  def start(procfile="Procfile")
+    error "#{procfile} does not exist." unless procfile_exists?(procfile)
+    Foreman::Engine.new(procfile).start
+  end
+
+  desc "export APP [PROCFILE] [FORMAT]", "Export the app described in PROCFILE as APP to another FORMAT"
+
+  def export(app, procfile="Procfile", format="upstart")
+    error "#{procfile} does not exist." unless procfile_exists?(procfile)
+
+    formatter = case format
+      when "upstart" then Foreman::Export::Upstart
+      else error "Unknown export format: #{format}."
+    end
+
+    formatter.new(Foreman::Engine.new(procfile)).export(app)
+  end
+
+  desc "scale APP PROCESS AMOUNT", "Change the concurrency of a given process type"
+
+  def scale(app, process, amount)
+    config = Foreman::Configuration.new(app)
+    error "No such process: #{process}." unless config.processes[process]
+    config.scale(process, amount)
+  rescue Foreman::AppDoesNotExist
+    error "No such app: #{app}."
+  end
+
+private ######################################################################
+
+  def error(message)
+    puts "ERROR: #{message}"
+    exit 1
+  end
+
+  def procfile_exists?(procfile)
+    File.exist?(procfile)
+  end
+
+end

data/lib/foreman/configuration.rb

@@ -0,0 +1,59 @@
+require "foreman"
+
+class Foreman::Configuration
+
+  attr_reader :app
+  attr_reader :processes
+
+  def initialize(app)
+    @app = app
+    @processes = {}
+    read_initial_config
+  end
+
+  def scale(process, amount)
+    old_amount = processes[process].to_i
+    processes[process] = amount.to_i
+    amount = amount.to_i
+
+    if (old_amount < amount)
+      ((old_amount + 1) .. amount).each { |num| run "start #{app}-#{process} NUM=#{num}" }
+    elsif (amount < old_amount)
+      ((amount + 1) .. old_amount).each { |num| run "stop #{app}-#{process} NUM=#{num}" }
+    end
+
+    write
+  end
+
+  def write
+    write_file "/etc/foreman/#{app}.conf", <<-UPSTART_CONFIG
+#{app}_processes="#{processes.keys.join(' ')}"
+#{processes.keys.map { |k| "#{app}_#{k}=\"#{processes[k]}\"" }.join("\n")}
+    UPSTART_CONFIG
+  end
+
+private ######################################################################
+
+  def read_initial_config
+    config = File.read("/etc/foreman/#{app}.conf").split("\n").inject({}) do |accum, line|
+      key, value = line.match(/^(.+?)\s*=\s*"(.+?)"\s*$/).captures
+      #accum.update(parts(1) => parts(2))
+      accum.update(key => value)
+    end
+    config["#{app}_processes"].split(" ").each do |process|
+      processes[process] = config["#{app}_#{process}"].to_i
+    end
+  rescue Errno::ENOENT
+  end
+
+  def run(command)
+    system command
+  end
+
+  def write_file(filename, contents)
+    File.open(filename, "w") do |file|
+      file.puts contents
+    end
+  end
+
+end

data/lib/foreman/engine.rb

@@ -0,0 +1,91 @@
+require "foreman"
+require "foreman/process"
+
+class Foreman::Engine
+
+  attr_reader :procfile
+  attr_reader :directory
+
+  def initialize(procfile)
+    @procfile  = read_procfile(procfile)
+    @directory = File.expand_path(File.dirname(procfile))
+  end
+
+  def processes
+    @processes ||= begin
+      procfile.split("\n").inject({}) do |hash, line|
+        next if line.strip == ""
+        process = Foreman::Process.new(*line.split(" ", 2))
+        hash.update(process.name => process)
+      end
+    end
+  end
+
+  def start
+    proctitle "ruby: foreman master"
+
+    processes.each do |name, process|
+      fork process
+    end
+
+    trap("TERM") { kill_and_exit("TERM") }
+    trap("INT")  { kill_and_exit("INT")  }
+
+    while true
+      pid, status = Process.wait2
+      process = running_processes.delete(pid)
+      info "exited with code #{status}", process
+      fork process
+    end
+  end
+
+private ######################################################################
+
+  def fork(process)
+    pid = Process.fork do
+      proctitle "ruby: foreman #{process.name}"
+
+      Dir.chdir directory do
+        FileUtils.mkdir_p "log"
+        system "#{process.command} >>log/#{process.name}.log 2>&1"
+        exit $?.exitstatus || 255
+      end
+    end
+
+    info "started with pid #{pid}", process
+    running_processes[pid] = process
+  end
+
+  def kill_and_exit(signal="TERM")
+    info "termination requested"
+    running_processes.each do |pid, process|
+      info "killing pid #{pid}", process
+      Process.kill(signal, pid)
+    end
+    exit 0
+  end
+
+  def info(message, process=nil)
+    puts "[foreman] [#{Time.now.utc}] [#{process ? process.name : "system"}] #{message}"
+  end
+
+  def print_info
+    info "currently running processes:"
+    running_processes.each do |pid, process|
+      info "pid #{pid}", process
+    end
+  end
+
+  def read_procfile(procfile)
+    File.read(procfile)
+  end
+
+  def running_processes
+    @running_processes ||= {}
+  end
+
+  def proctitle(title)
+    $0 = title
+  end
+
+end

data/lib/foreman/export.rb

@@ -0,0 +1,6 @@
+require "foreman"
+
+module Foreman::Export
+end
+
+require "foreman/export/upstart"

data/lib/foreman/export/upstart.rb

@@ -0,0 +1,66 @@
+require "foreman/configuration"
+require "foreman/export"
+
+class Foreman::Export::Upstart
+
+  attr_reader :engine
+
+  def initialize(engine)
+    @engine = engine
+  end
+
+  def export(app)
+    FileUtils.mkdir_p "/etc/foreman"
+    FileUtils.mkdir_p "/etc/init"
+
+    config = Foreman::Configuration.new(app)
+
+    engine.processes.each do |name, process|
+      config.scale(name, 1)
+    end
+    config.write
+
+    write_file "/etc/init/#{app}.conf", <<-UPSTART_MASTER
+pre-start script
+
+bash << "EOF"
+  mkdir -p /var/log/#{app}
+
+  if [ -f /etc/foreman/#{app}.conf ]; then
+    source /etc/foreman/#{app}.conf
+  fi
+
+  for process in $( echo "$#{app}_processes" ); do
+    process_count_config="#{app}_$process"
+    process_count=${!process_count_config}
+
+    for ((i=1; i<=${process_count:=1}; i+=1)); do
+      start #{app}-$process NUM=$i
+    done
+  done
+EOF
+
+end script
+    UPSTART_MASTER
+
+    engine.processes.values.each do |process|
+      write_file "/etc/init/#{app}-#{process.name}.conf", <<-UPSTART_CHILD
+instance $NUM
+stop on stopping #{app}
+respawn
+
+chdir #{engine.directory}
+exec #{process.command} >>/var/log/#{app}/#{process.name}.log 2>&1
+      UPSTART_CHILD
+    end
+  end
+
+private ######################################################################
+
+  def write_file(filename, contents)
+    File.open(filename, "w") do |file|
+      file.puts contents
+    end
+  end
+
+end

data/lib/foreman/process.rb

@@ -0,0 +1,13 @@
+require "foreman"
+
+class Foreman::Process
+
+  attr_reader :name
+  attr_reader :command
+
+  def initialize(name, command)
+    @name    = name
+    @command = command
+  end
+
+end

data/spec/foreman/cli_spec.rb

@@ -0,0 +1,88 @@
+require "spec_helper"
+require "foreman/cli"
+
+describe "Foreman::CLI" do
+  subject { Foreman::CLI.new }
+
+  describe "start" do
+    #let(:engine) { stub_engine }
+
+    describe "with a non-existent Procifile" do
+      it "prints an error" do
+        mock_error(subject, "Procfile does not exist.") do
+          dont_allow.instance_of(Foreman::Engine).start
+          subject.start
+        end
+      end
+    end
+
+    describe "with a Procfile" do
+      before(:each) { write_procfile }
+
+      it "runs successfully" do
+        dont_allow(subject).error
+        mock.instance_of(Foreman::Engine).start
+        subject.start
+      end
+    end
+  end
+
+  describe "export" do
+    describe "with a non-existent Procifile" do
+      it "prints an error" do
+        mock_error(subject, "Procfile does not exist.") do
+          dont_allow.instance_of(Foreman::Engine).export
+          subject.export("testapp")
+        end
+      end
+    end
+
+    describe "with a Procfile" do
+      before(:each) { write_procfile }
+
+      describe "with an invalid formatter" do
+        it "prints an error" do
+          mock_error(subject, "Unknown export format: invalidformatter.") do
+            subject.export("testapp", "Procfile", "invalidformatter")
+          end
+        end
+      end
+
+      describe "with a valid config" do
+        before(:each) { write_foreman_config("testapp") }
+
+        it "runs successfully" do
+          dont_allow(subject).error
+          subject.export("testapp")
+        end
+      end
+    end
+  end
+
+  describe "scale" do
+    describe "without an existing configuration" do
+      it "displays an error" do
+        mock_error(subject, "No such app: testapp.") do
+          subject.scale("testapp", "alpha", "2")
+        end
+      end
+    end
+
+    describe "with an existing configuration" do
+      before(:each) { write_foreman_config("testapp") }
+
+      it "scales a process that exists" do
+        mock.instance_of(Foreman::Configuration).scale("alpha", "2")
+        subject.scale("testapp", "alpha", "2")
+      end
+
+      it "errors if a process that does not exist is specified" do
+        mock_error(subject, "No such process: invalidprocess.") do
+          dont_allow.instance_of(Foreman::Configuration).scale
+          subject.scale("testapp", "invalidprocess", "2")
+        end
+      end
+    end
+  end
+
+end

data/spec/foreman/configuration_spec.rb

@@ -0,0 +1,2 @@
+require "spec_helper"
+require "foreman/configuration"

data/spec/foreman/engine_spec.rb

@@ -0,0 +1,2 @@
+require "spec_helper"
+require "foreman/engine"

data/spec/foreman/export/upstart_spec.rb

@@ -0,0 +1,2 @@
+require "spec_helper"
+require "foreman/export/upstart"

data/spec/foreman/export_spec.rb

@@ -0,0 +1,2 @@
+require "spec_helper"
+require "foreman/export"

data/spec/foreman/process_spec.rb

@@ -0,0 +1,2 @@
+require "spec_helper"
+require "foreman/process"

data/spec/foreman_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+require "foreman"
+
+describe Foreman do
+
+  describe "VERSION" do
+    subject { Foreman::VERSION }
+    it { should be_a String }
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require "fakefs/spec_helpers"
+require "rspec"
+
+$:.unshift "lib"
+
+def mock_error(subject, message)
+  mock_exit do
+    mock(subject).puts("ERROR: #{message}")
+    yield
+  end
+end
+
+def mock_exit(&block)
+  block.should raise_error(SystemExit)
+end
+
+def write_foreman_config(app)
+  File.open("/etc/foreman/#{app}.conf", "w") do |file|
+    file.puts %{#{app}_processes="alpha bravo"}
+    file.puts %{#{app}_alpha="1"}
+    file.puts %{#{app}_bravo="2"}
+  end
+end
+
+def write_procfile(procfile="Procfile")
+  File.open(procfile, "w") do |file|
+    file.puts "alpha ./alpha"
+    file.puts "bravo ./bravo"
+  end
+end
+
+Rspec.configure do |config|
+  config.color_enabled = true
+  config.include FakeFS::SpecHelpers
+  config.mock_with :rr
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification 
+name: foreman
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- David Dollar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-20 00:00:00 -04:00
+default_executable: foreman
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 0
+        - 2
+        - 1
+        version: 0.2.1
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 33
+        segments: 
+        - 0
+        - 10
+        - 11
+        version: 0.10.11
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 39
+        segments: 
+        - 0
+        - 13
+        - 6
+        version: 0.13.6
+  type: :runtime
+  version_requirements: *id006
+description: Process manager for applications with multiple components
+email: ddollar@gmail.com
+executables: 
+- foreman
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Rakefile
+- bin/foreman
+- lib/foreman.rb
+- lib/foreman/cli.rb
+- lib/foreman/configuration.rb
+- lib/foreman/engine.rb
+- lib/foreman/export.rb
+- lib/foreman/export/upstart.rb
+- lib/foreman/process.rb
+- spec/foreman/cli_spec.rb
+- spec/foreman/configuration_spec.rb
+- spec/foreman/engine_spec.rb
+- spec/foreman/export/upstart_spec.rb
+- spec/foreman/export_spec.rb
+- spec/foreman/process_spec.rb
+- spec/foreman_spec.rb
+- spec/spec_helper.rb
+- README.rdoc
+has_rdoc: false
+homepage: http://github.com/ddollar/foreman
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Process manager for applications with multiple components
+test_files: 
+- spec/foreman/cli_spec.rb
+- spec/foreman/configuration_spec.rb
+- spec/foreman/engine_spec.rb
+- spec/foreman/export/upstart_spec.rb
+- spec/foreman/export_spec.rb
+- spec/foreman/process_spec.rb
+- spec/foreman_spec.rb
+- spec/spec_helper.rb