foreman 0.26.1 → 0.40.0

data/README.md

@@ -0,0 +1,40 @@
+# Foreman
+
+Manage Procfile-based applications
+
+<table>
+  <tr>
+    <th>If you have...</th>
+    <th>Install with...</th>
+  </tr>
+  <tr>
+    <td>Ruby (MRI, JRuby, Windows)</td>
+    <td><pre>$ gem install foreman</pre></td>
+  </tr>
+  <tr>
+    <td>Mac OS X</td>
+    <td><a href="http://assets.foreman.io/foreman/foreman.pkg">foreman.pkg</a></td>
+  </tr>
+</table>
+
+## Getting Started
+
+* http://blog.daviddollar.org/2011/05/06/introducing-foreman.html
+
+## Documentation
+
+* [man page](http://ddollar.github.com/foreman)
+* [wiki](http://github.com/ddollar/foreman/wiki)
+* [changelog](https://github.com/ddollar/foreman/blob/master/Changelog.md)
+
+## Authors
+
+#### Created and maintained by
+David Dollar
+
+#### Patches contributed by
+[Contributor List](https://github.com/ddollar/foreman/contributors)
+
+## License
+
+MIT

data/bin/foreman-runner

@@ -0,0 +1,36 @@
+#!/bin/sh
+#
+#/ Usage: foreman-runner [-d <dir>] <command>
+#/
+#/ Run a command with exec, optionally changing directory first
+
+set -e
+
+error() {
+  echo $@ >&2
+  exit 1
+}
+
+usage() {
+  cat $0 | grep '^#/' | cut -c4-
+  exit
+}
+
+while getopts ":hd:" OPT; do
+  case $OPT in
+     d) cd "$OPTARG" ;;
+     h) usage ;;
+    \?) error "invalid option: -$OPTARG" ;;
+     :) error "option -$OPTARG requires an argument" ;;
+  esac
+done
+
+shift $((OPTIND-1))
+
+command=$1
+
+if [ -z "$1" ]; then
+  usage
+fi
+
+exec $1

data/data/example/Procfile

@@ -1,2 +1,3 @@
 ticker: ruby ./ticker $PORT
 error:  ruby ./error
+utf8:   ruby ./utf8

data/data/example/utf8

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# encoding: BINARY
+
+$stdout.sync = true
+
+while true
+  puts "\u65e5\u672c\u8a9e\u6587\u5b57\u5217"
+  puts "\u0915\u0932\u094d\u0907\u0928\u0643\u0637\u0628\u041a\u0430\u043b\u0438\u043d\u0430"
+  puts "\xff\x03"
+  sleep 1
+end

data/data/export/bluepill/master.pill.erb

@@ -3,9 +3,9 @@ Bluepill.application("<%= app %>", :foreground => false, :log_file => "/var/log/
   app.uid = "<%= user %>"
   app.gid = "<%= user %>"
 
-<% engine.processes.each do |process| %>
+<% engine.procfile.entries.each do |process| %>
 <% 1.upto(concurrency[process.name]) do |num| %>
-<% port = engine.port_for(process, num, options[:port]) %>
+<% port = engine.port_for(process, num, self.port) %>
   app.process("<%= process.name %>-<%=num%>") do |process|
     process.start_command = "<%= process.command.gsub("$PORT", port.to_s) %>"
 
@@ -19,7 +19,7 @@ Bluepill.application("<%= app %>", :foreground => false, :log_file => "/var/log/
     process.monitor_children do |children|
       children.stop_command "kill -QUIT {{PID}}"
     end
-    
+
     process.group = "<%= app %>-<%= process.name %>"
   end
 <% end %>

data/lib/foreman/cli.rb

@@ -1,27 +1,36 @@
 require "foreman"
+require "foreman/helpers"
 require "foreman/engine"
 require "foreman/export"
 require "thor"
 require "yaml"
 
 class Foreman::CLI < Thor
+  include Foreman::Helpers
 
   class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
 
-  desc "start [PROCESS]", "Start the application, or a specific process"
+  desc "start [PROCESS]", "Start the application (or a specific PROCESS)"
+
+  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
+  class_option :app_root, :type => :string, :aliases => "-d", :desc => "Default: Procfile directory"
 
   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"'
 
+  class << self
+    # Hackery. Take the run method away from Thor so that we can redefine it.
+    def is_thor_reserved_word?(word, type)
+      return false if word == 'run'
+      super
+    end
+  end
+
   def start(process=nil)
     check_procfile!
-
-    if process
-      engine.execute(process)
-    else
-      engine.start
-    end
+    engine.options[:concurrency] = "#{process}=1" if process
+    engine.start
   end
 
   desc "export FORMAT LOCATION", "Export the application to another process management format"
@@ -32,22 +41,12 @@ class Foreman::CLI < Thor
   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"'
+  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
-      when "bluepill" then Foreman::Export::Bluepill
-      when "runit"    then Foreman::Export::Runit
-      else error "Unknown export format: #{format}."
-    end
-
-    formatter.new(engine).export(location, options)
-
+    formatter = Foreman::Export.formatter(format)
+    formatter.new(location, engine, options).export
   rescue Foreman::Export::Exception => ex
     error ex.message
   end
@@ -55,8 +54,22 @@ class Foreman::CLI < Thor
   desc "check", "Validate your application's Procfile"
 
   def check
-    error "no processes defined" unless engine.processes.length > 0
-    display "valid procfile detected (#{engine.processes.map(&:name).join(', ')})"
+    check_procfile!
+    error "no processes defined" unless engine.procfile.entries.length > 0
+    puts "valid procfile detected (#{engine.procfile.process_names.join(', ')})"
+  end
+
+  desc "run COMMAND", "Run a command using your application's environment"
+
+  def run(*args)
+    engine.apply_environment!
+    begin
+      exec args.join(" ")
+    rescue Errno::EACCES
+      error "not executable: #{args.first}"
+    rescue Errno::ENOENT
+      error "command not found: #{args.first}"
+    end
   end
 
 private ######################################################################
@@ -73,24 +86,15 @@ private ######################################################################
     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

@@ -2,146 +2,151 @@ require "foreman"
 require "foreman/process"
 require "foreman/procfile"
 require "foreman/utils"
-require "pty"
 require "tempfile"
 require "timeout"
 require "term/ansicolor"
 require "fileutils"
+require "thread"
 
 class Foreman::Engine
 
+  attr_reader :environment
   attr_reader :procfile
   attr_reader :directory
-  attr_reader :environment
   attr_reader :options
 
   extend Term::ANSIColor
 
-  COLORS = [ cyan, yellow, green, magenta, red ]
+  COLORS = [ cyan, yellow, green, magenta, red, blue,
+             intense_cyan, intense_yellow, intense_green, intense_magenta,
+             intense_red, intense_blue ]
 
   def initialize(procfile, options={})
     @procfile  = Foreman::Procfile.new(procfile)
-    @directory = File.expand_path(File.dirname(procfile))
-    @options = options
+    @directory = options[:app_root] || File.expand_path(File.dirname(procfile))
+    @options = options.dup
     @environment = read_environment_files(options[:env])
+    @output_mutex = Mutex.new
   end
 
   def start
     proctitle "ruby: foreman master"
-    termtitle "#{File.basename(@directory)} - foreman (#{processes.size} processes)"
-
-    processes.each do |process|
-      process.color = next_color
-      fork process
-    end
-
-    trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
-    trap("INT")  { puts "SIGINT received";  terminate_gracefully }
-
-    watch_for_termination
-  end
-
-  def execute(name)
-    error "no such process: #{name}" unless process = procfile[name]
-    process.color = next_color
-    fork process
+    termtitle "#{File.basename(@directory)} - foreman"
 
     trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
     trap("INT")  { puts "SIGINT received";  terminate_gracefully }
 
+    assign_colors
+    spawn_processes
+    watch_for_output
     watch_for_termination
   end
 
-  def processes
-    procfile.processes
-  end
-
   def port_for(process, num, base_port=nil)
     base_port ||= 5000
     offset = procfile.process_names.index(process.name) * 100
     base_port.to_i + offset + num - 1
   end
 
-private ######################################################################
-
-  def fork(process)
-    concurrency = Foreman::Utils.parse_concurrency(@options[:concurrency])
-
-    1.upto(concurrency[process.name]) do |num|
-      fork_individual(process, num, port_for(process, num, @options[:port]))
-    end
+  def apply_environment!
+    environment.each { |k,v| ENV[k] = v }
   end
 
-  def fork_individual(process, num, port)
-    @environment.each { |k,v| ENV[k] = v }
+private ######################################################################
 
-    ENV["PORT"] = port.to_s
-    ENV["PS"]   = "#{process.name}.#{num}"
+  def spawn_processes
+    concurrency = Foreman::Utils.parse_concurrency(@options[:concurrency])
 
-    pid = Process.fork do
-      run(process)
+    procfile.entries.each do |entry|
+      reader, writer = (IO.method(:pipe).arity == 0 ? IO.pipe : IO.pipe("BINARY"))
+      entry.spawn(concurrency[entry.name], writer, @directory, @environment, port_for(entry, 1, base_port)).each do |process|
+        running_processes[process.pid] = process
+        readers[process] = reader
+      end
     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(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, Errno::ENOENT
-      begin
-        info "process exiting", process
-      rescue Interrupt
-      end
-    end
+  def base_port
+    options[:port] || 5000
   end
 
   def kill_all(signal="SIGTERM")
     running_processes.each do |pid, process|
-      Process.kill(signal, pid) rescue Errno::ESRCH
+      info "sending #{signal} to pid #{pid}"
+      process.kill signal
     end
   end
 
   def terminate_gracefully
+    return if @terminating
+    @terminating = true
     info "sending SIGTERM to all processes"
     kill_all "SIGTERM"
-    Timeout.timeout(3) { Process.waitall }
+    Timeout.timeout(5) do
+      while running_processes.length > 0
+        pid, status = Process.wait2
+        process = running_processes.delete(pid)
+        info "process terminated", process.name
+      end
+    end
   rescue Timeout::Error
     info "sending SIGKILL to all processes"
     kill_all "SIGKILL"
   end
 
+  def poll_readers
+    rs, ws = IO.select(readers.values, [], [], 1)
+    (rs || []).each do |r|
+      data = r.gets
+      next unless data
+      data.force_encoding("BINARY") if data.respond_to?(:force_encoding)
+      ps, message = data.split(",", 2)
+      color = colors[ps.split(".").first]
+      info message, ps, color
+    end
+  end
+
+  def watch_for_output
+    Thread.new do
+      require "win32console" if Foreman.windows?
+      begin
+        loop do
+          poll_readers
+        end
+      rescue Exception => ex
+        puts ex.message
+        puts ex.backtrace
+      end
+    end
+  end
+
   def watch_for_termination
     pid, status = Process.wait2
     process = running_processes.delete(pid)
-    info "process terminated", process
+    info "process terminated", process.name
     terminate_gracefully
-    kill_all
   rescue Errno::ECHILD
   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
+  def info(message, name="system", color=Term::ANSIColor.white)
+    output  = ""
+    output += color
+    output += "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(name)} | "
+    output += Term::ANSIColor.reset
+    output += message.chomp
+    puts output
   end
 
-  def error(message)
-    puts "ERROR: #{message}"
-    exit 1
+  def print(message=nil)
+    @output_mutex.synchronize do
+      $stdout.print message
+    end
+  end
+
+  def puts(message=nil)
+    @output_mutex.synchronize do
+      $stdout.puts message
+    end
   end
 
   def longest_process_name
@@ -152,9 +157,8 @@ private ######################################################################
     end
   end
 
-  def pad_process_name(process)
-    name = process ? "#{ENV["PS"]}" : "system"
-    name.ljust(longest_process_name + 3) # add 3 for process number padding
+  def pad_process_name(name="system")
+    name.to_s.ljust(longest_process_name + 3) # add 3 for process number padding
   end
 
   def proctitle(title)
@@ -162,17 +166,36 @@ private ######################################################################
   end
 
   def termtitle(title)
-    printf("\033]0;#{title}\007")
+    printf("\033]0;#{title}\007") unless Foreman.windows?
   end
 
   def running_processes
     @running_processes ||= {}
   end
 
+  def readers
+    @readers ||= {}
+  end
+
+  def colors
+    @colors ||= {}
+  end
+
+  def assign_colors
+    procfile.entries.each do |entry|
+      colors[entry.name] = next_color
+    end
+  end
+
+  def process_by_reader(reader)
+    readers.invert[reader]
+  end
+
   def next_color
     @current_color ||= -1
     @current_color  +=  1
-    @current_color >= COLORS.length ? "" : COLORS[@current_color]
+    @current_color = 0 if COLORS.length < @current_color
+    COLORS[@current_color]
   end
 
   def read_environment_files(filenames)
@@ -192,10 +215,14 @@ private ######################################################################
 
     File.read(filename).split("\n").inject({}) do |hash, line|
       if line =~ /\A([A-Za-z_0-9]+)=(.*)\z/
-        hash[$1] = $2
+        key, val = [$1, $2]
+        case val
+          when /\A'(.*)'\z/ then hash[key] = $1
+          when /\A"(.*)"\z/ then hash[key] = $1.gsub(/\\(.)/, '\1')
+          else hash[key] = val
+        end
       end
       hash
     end
   end
-
 end

data/lib/foreman/export/base.rb

@@ -3,10 +3,17 @@ require "foreman/utils"
 
 class Foreman::Export::Base
 
-  attr_reader :engine
-
-  def initialize(engine)
-    @engine = engine
+  attr_reader :location, :engine, :app, :log, :port, :user, :template, :concurrency
+
+  def initialize(location, engine, options={})
+    @location    = location
+    @engine      = engine
+    @app         = options[:app]
+    @log         = options[:log]
+    @port        = options[:port]
+    @user        = options[:user]
+    @template    = options[:template]
+    @concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
   end
 
   def export
@@ -26,7 +33,7 @@ private ######################################################################
   def export_template(exporter, file, template_root)
     if template_root && File.exist?(file_path = File.join(template_root, file))
       File.read(file_path)
-    elsif File.exist?(file_path = File.join("~/.foreman/templates", file))
+    elsif File.exist?(file_path = File.expand_path(File.join("~/.foreman/templates", file)))
       File.read(file_path)
     else
       File.read(File.expand_path("../../../../data/export/#{exporter}/#{file}", __FILE__))

data/lib/foreman/export/bluepill.rb

@@ -3,23 +3,21 @@ require "foreman/export"
 
 class Foreman::Export::Bluepill < Foreman::Export::Base
 
-  def export(location, options={})
+  def export
     error("Must specify a location") unless location
 
     FileUtils.mkdir_p location
 
-    app = options[:app] || File.basename(engine.directory)
-    user = options[:user] || app
-    log_root = options[:log] || "/var/log/#{app}"
-    template_root = options[:template]
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
+    template_root = self.template
 
     Dir["#{location}/#{app}.pill"].each do |file|
       say "cleaning up: #{file}"
       FileUtils.rm(file)
     end
 
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
-
     master_template = export_template("bluepill", "master.pill.erb", template_root)
     master_config   = ERB.new(master_template).result(binding)
     write_file "#{location}/#{app}.pill", master_config

data/lib/foreman/export/inittab.rb

@@ -2,20 +2,18 @@ require "foreman/export"
 
 class Foreman::Export::Inittab < Foreman::Export::Base
 
-  def export(fname=nil, options={})
-    app = options[:app] || File.basename(engine.directory)
-    user = options[:user] || app
-    log_root = options[:log] || "/var/log/#{app}"
-
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+  def export
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
 
     inittab = []
     inittab << "# ----- foreman #{app} processes -----"
 
-    engine.processes.inject(1) do |index, process|
-      1.upto(concurrency[process.name]) do |num|
+    engine.procfile.entries.inject(1) do |index, process|
+      1.upto(self.concurrency[process.name]) do |num|
         id = app.slice(0, 2).upcase + sprintf("%02d", index)
-        port = engine.port_for(process, num, options[:port])
+        port = engine.port_for(process, num, self.port)
         inittab << "#{id}:4:respawn:/bin/su - #{user} -c 'PORT=#{port} #{process.command} >> #{log_root}/#{process.name}-#{num}.log 2>&1'"
         index += 1
       end
@@ -26,12 +24,12 @@ class Foreman::Export::Inittab < Foreman::Export::Base
 
     inittab = inittab.join("\n") + "\n"
 
-    if fname
+    if location == "-"
+      puts inittab
+    else
       FileUtils.mkdir_p(log_root) rescue error "could not create #{log_root}"
       FileUtils.chown(user, nil, log_root) rescue error "could not chown #{log_root} to #{user}"
-      write_file(fname, inittab)
-    else
-      puts inittab
+      write_file(location, inittab)
     end
   end