HeSYINUvSBZfxqA-foreman 0.20.0

data/README.markdown

@@ -0,0 +1,30 @@
+# Foreman
+
+## Installation
+
+    gem install foreman
+
+## Description
+
+http://blog.daviddollar.org/2011/05/06/introducing-foreman.html
+
+## Manual
+
+See the [man page](http://ddollar.github.com/foreman) for usage.
+
+## Authorship
+
+Created by David Dollar
+
+Patches contributed by:
+
+* Adam Wiggins
+* clifff
+* Dan Peterson
+* Jay Zeschin
+* Keith Rarick
+* Ricardo Chimal, Jr
+
+## License
+
+MIT

data/bin/foreman

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

data/bin/foreman-runner

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec ARGV.join(" ")

data/data/example/Procfile

@@ -0,0 +1,2 @@
+ticker: ./ticker $PORT
+error : ./error

data/data/example/Procfile.without_colon

@@ -0,0 +1,2 @@
+ticker ./ticker $PORT
+error  ./error

data/data/example/error

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+puts "will error in 10s"
+sleep 5
+raise "Dying"

data/data/example/log/neverdie.log

@@ -0,0 +1,4 @@
+tick
+tick
+./never_die:6:in `sleep': Interrupt
+	from ./never_die:6

data/data/example/ticker

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+%w( SIGINT SIGTERM SIGHUP ).each do |signal|
+  trap(signal) do
+    puts "received #{signal} but i'm ignoring it!"
+  end
+end
+
+while true
+  puts "tick: #{ARGV.inspect} -- FOO:#{ENV["FOO"]}"
+  sleep 1
+end

data/data/export/upstart/master.conf.erb

@@ -0,0 +1,8 @@
+pre-start script
+
+bash << "EOF"
+  mkdir -p <%= log_root %>
+  chown -R <%= user %> <%= log_root %>
+EOF
+
+end script

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

@@ -0,0 +1,5 @@
+start on starting <%= app %>-<%= process.name %>
+stop on stopping <%= app %>-<%= process.name %>
+respawn
+
+exec su - <%= user %> -c 'cd <%= engine.directory %>; export PORT=<%= port %>; <%= process.command %> >> <%= log_root %>/<%=process.name%>-<%=num%>.log 2>&1'

data/data/export/upstart/process_master.conf.erb

@@ -0,0 +1,2 @@
+start on starting <%= app %>
+stop on stopping <%= app %>

data/lib/foreman.rb

@@ -0,0 +1,8 @@
+require "foreman/version"
+
+module Foreman
+
+  class AppDoesNotExist < Exception; end
+
+end
+

data/lib/foreman/cli.rb

@@ -0,0 +1,94 @@
+require "foreman"
+require "foreman/engine"
+require "foreman/export"
+require "thor"
+require "yaml"
+
+class Foreman::CLI < Thor
+
+  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
+
+  desc "start [PROCESS]", "Start the application, or a specific process"
+
+  method_option :env,         :type => :string,  :aliases => "-e", :desc => "Specify an environment file to load, defaults to .env"
+  method_option :port,        :type => :numeric, :aliases => "-p"
+  method_option :concurrency, :type => :string,  :aliases => "-c", :banner => '"alpha=5,bar=3"'
+
+  def start(process=nil)
+    check_procfile!
+
+    if process
+      engine.execute(process, options)
+    else
+      engine.start(options)
+    end
+  end
+
+  desc "export FORMAT LOCATION", "Export the application to another process management format"
+
+  method_option :app,         :type => :string,  :aliases => "-a"
+  method_option :log,         :type => :string,  :aliases => "-l"
+  method_option :port,        :type => :numeric, :aliases => "-p"
+  method_option :user,        :type => :string,  :aliases => "-u"
+  method_option :template,    :type => :string,  :aliases => "-t"
+  method_option :concurrency, :type => :string,  :aliases => "-c",
+    :banner => '"alpha=5,bar=3"'
+
+  def export(format, location=nil)
+    check_procfile!
+
+    formatter = case format
+      when "inittab" then Foreman::Export::Inittab
+      when "upstart" then Foreman::Export::Upstart
+      else error "Unknown export format: #{format}."
+    end
+
+    formatter.new(engine).export(location, options)
+
+  rescue Foreman::Export::Exception => ex
+    error ex.message
+  end
+
+  desc "check", "Validate your application's Procfile"
+
+  def check
+    processes = engine.processes_in_order.map { |p| p.first }
+    error "no processes defined" unless processes.length > 0
+    display "valid procfile detected (#{processes.join(', ')})"
+  end
+
+private ######################################################################
+
+  def check_procfile!
+    error("#{procfile} does not exist.") unless File.exist?(procfile)
+  end
+
+  def engine
+    @engine ||= Foreman::Engine.new(procfile)
+  end
+
+  def procfile
+    options[:procfile] || "Procfile"
+  end
+
+  def display(message)
+    puts message
+  end
+
+  def error(message)
+    puts "ERROR: #{message}"
+    exit 1
+  end
+
+  def procfile_exists?(procfile)
+    File.exist?(procfile)
+  end
+
+  def options
+    original_options = super
+    return original_options unless File.exists?(".foreman")
+    defaults = YAML::load_file(".foreman") || {}
+    Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
+  end
+
+end

data/lib/foreman/engine.rb

@@ -0,0 +1,233 @@
+require "foreman"
+require "foreman/process"
+require "foreman/utils"
+require "pty"
+require "tempfile"
+require "timeout"
+require "term/ansicolor"
+require "fileutils"
+
+class Foreman::Engine
+
+  attr_reader :procfile
+  attr_reader :directory
+
+  extend Term::ANSIColor
+
+  COLORS = [ cyan, yellow, green, magenta, red ]
+
+  def initialize(procfile)
+    @procfile  = read_procfile(procfile)
+    @directory = File.expand_path(File.dirname(procfile))
+  end
+
+  def processes
+    @processes ||= begin
+      @order = []
+      procfile.split("\n").inject({}) do |hash, line|
+        next hash if line.strip == ""
+        name, command = line.split(/ *: +/, 2)
+        unless command
+          warn_deprecated_procfile!
+          name, command = line.split(/ +/, 2)
+        end
+        process = Foreman::Process.new(name, command)
+        process.color = next_color
+        @order << process.name
+        hash.update(process.name => process)
+      end
+    end
+  end
+
+  def process_order
+    processes
+    @order.uniq
+  end
+
+  def processes_in_order
+    process_order.map do |name|
+      [name, processes[name]]
+    end
+  end
+
+  def start(options={})
+    environment = read_environment(options[:env])
+
+    proctitle "ruby: foreman master"
+
+    processes_in_order.each do |name, process|
+      fork process, options, environment
+    end
+
+    trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
+    trap("INT")  { puts "SIGINT received";  terminate_gracefully }
+
+    watch_for_termination
+  end
+
+  def execute(name, options={})
+    environment = read_environment(options[:env])
+
+    fork processes[name], options, environment
+
+    trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
+    trap("INT")  { puts "SIGINT received";  terminate_gracefully }
+
+    watch_for_termination
+  end
+
+  def port_for(process, num, base_port=nil)
+    base_port ||= 5000
+    offset = processes_in_order.map { |p| p.first }.index(process.name) * 100
+    base_port.to_i + offset + num - 1
+  end
+
+private ######################################################################
+
+  def fork(process, options={}, environment={})
+    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+
+    1.upto(concurrency[process.name]) do |num|
+      fork_individual(process, num, port_for(process, num, options[:port]), environment)
+    end
+  end
+
+  def fork_individual(process, num, port, environment)
+    environment.each { |k,v| ENV[k] = v }
+
+    ENV["PORT"] = port.to_s
+    ENV["PS"]   = "#{process.name}.#{num}"
+
+    pid = Process.fork do
+      run(process)
+    end
+
+    info "started with pid #{pid}", process
+    running_processes[pid] = process
+  end
+
+  def run(process)
+    proctitle "ruby: foreman #{process.name}"
+    trap("SIGINT", "IGNORE")
+
+    begin
+      Dir.chdir directory do
+        PTY.spawn(runner, process.command) do |stdin, stdout, pid|
+          trap("SIGTERM") { Process.kill("SIGTERM", pid) }
+          until stdin.eof?
+            info stdin.gets, process
+          end
+        end
+      end
+    rescue PTY::ChildExited, Interrupt, Errno::EIO
+      begin
+        info "process exiting", process
+      rescue Interrupt
+      end
+    end
+  end
+
+  def kill_all(signal="SIGTERM")
+    running_processes.each do |pid, process|
+      Process.kill(signal, pid) rescue Errno::ESRCH
+    end
+  end
+
+  def info(message, process=nil)
+    print process.color if process
+    print "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(process)} | "
+    print Term::ANSIColor.reset
+    print message.chomp
+    puts
+  end
+
+  def error(message)
+    puts "ERROR: #{message}"
+    exit 1
+  end
+
+  def longest_process_name
+    @longest_process_name ||= begin
+      longest = processes.keys.map { |name| name.length }.sort.last
+      longest = 6 if longest < 6 # system
+      longest
+    end
+  end
+
+  def pad_process_name(process)
+    name = process ? "#{ENV["PS"]}" : "system"
+    name.ljust(longest_process_name + 3) # add 3 for process number padding
+  end
+
+  def print_info
+    info "currently running processes:"
+    running_processes.each do |pid, process|
+      info "pid #{pid}", process
+    end
+  end
+
+  def proctitle(title)
+    $0 = title
+  end
+
+  def read_procfile(procfile)
+    File.read(procfile)
+  end
+
+  def watch_for_termination
+    pid, status = Process.wait2
+    process = running_processes.delete(pid)
+    info "process terminated", process
+    terminate_gracefully
+    kill_all
+  rescue Errno::ECHILD
+  end
+
+  def running_processes
+    @running_processes ||= {}
+  end
+
+  def next_color
+    @current_color ||= -1
+    @current_color  +=  1
+    @current_color >= COLORS.length ? "" : COLORS[@current_color]
+  end
+
+  def warn_deprecated_procfile!
+    return if @already_warned_deprecated
+    @already_warned_deprecated = true
+    puts "!!! This format of Procfile is deprecated, and will not work starting in v0.12"
+    puts "!!! Use a colon to separate the process name from the command"
+    puts "!!! e.g.   web: thin start"
+  end
+
+  def read_environment(filename)
+    error "No such file: #{filename}" if filename && !File.exists?(filename)
+    filename ||= ".env"
+    environment = {}
+
+    if File.exists?(filename)
+      File.read(filename).split("\n").each do |line|
+        if line =~ /\A([A-Za-z_]+)=(.*)\z/
+          environment[$1] = $2
+        end
+      end
+    end
+
+    environment
+  end
+
+  def runner
+    File.expand_path("../../../bin/foreman-runner", __FILE__)
+  end
+
+  def terminate_gracefully
+    info "sending SIGTERM to all processes"
+    kill_all "SIGTERM"
+    Timeout.timeout(3) { Process.waitall }
+  rescue Timeout::Error
+    info "sending SIGKILL to all processes"
+    kill_all "SIGKILL"
+  end
+
+end

data/lib/foreman/export.rb

@@ -0,0 +1,9 @@
+require "foreman"
+
+module Foreman::Export
+  class Exception < ::Exception; end
+end
+
+require "foreman/export/base"
+require "foreman/export/inittab"
+require "foreman/export/upstart"