foreman 0.31.0 → 0.50.0

data/README.md

@@ -0,0 +1,46 @@
+# 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)
+
+## Ports
+
+* [shoreman](https://github.com/hecticjeff/shoreman) - shell
+* [honcho](https://github.com/nickstenning/honcho) - python
+* [norman](https://github.com/josh/norman) - node.js
+
+## 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,32 @@
+#!/bin/sh
+#
+#/ Usage: foreman-runner [-d <dir>] <command> [<args>...]
+#/
+#/ 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))
+
+[ -z "$1" ] && usage
+
+exec "$@"

data/bin/taskman

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

data/data/example/Procfile

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

data/data/example/spawnee

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+NAME="$1"
+
+sigterm() {
+  echo "$NAME: got sigterm"
+}
+
+#trap sigterm SIGTERM
+
+while true; do
+  echo "$NAME: ping $$"
+  sleep 1
+done

data/data/example/spawner

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+./spawnee A &
+./spawnee B &
+./spawnee C &
+
+wait

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,24 +3,25 @@ Bluepill.application("<%= app %>", :foreground => false, :log_file => "/var/log/
   app.uid = "<%= user %>"
   app.gid = "<%= user %>"
 
-<% engine.procfile.entries.each do |process| %>
-<% 1.upto(concurrency[process.name]) do |num| %>
-<% port = engine.port_for(process, num, options[:port]) %>
-  app.process("<%= process.name %>-<%=num%>") do |process|
-    process.start_command = "<%= process.command.gsub("$PORT", port.to_s) %>"
+<% engine.each_process do |name, process| %>
+<% 1.upto(engine.formation[name]) do |num| %>
+  <% port = engine.port_for(process, num) %>
+  app.process("<%= name %>-<%= num %>") do |process|
+    process.start_command = "<%= process.command %>"
 
-    process.working_dir = "<%= engine.directory %>"
+    process.working_dir = "<%= engine.root %>"
     process.daemonize = true
-    process.environment = {"PORT" => "<%= port %>"}
+    process.environment = <%= engine.env.merge("PORT" => port.to_s).inspect %>
     process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+    process.stop_grace_time = 45.seconds
 
-    process.stdout = process.stderr = "<%= log_root %>/<%= app %>-<%= process.name %>-<%=num%>.log"
+    process.stdout = process.stderr = "<%= log %>/<%= app %>-<%= name %>-<%= num %>.log"
 
     process.monitor_children do |children|
-      children.stop_command "kill -QUIT {{PID}}"
+      children.stop_command "kill {{PID}}"
     end
 
-    process.group = "<%= app %>-<%= process.name %>"
+    process.group = "<%= app %>-<%= name %>"
   end
 <% end %>
 <% end %>

data/data/export/launchd/launchd.plist.erb

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string><%= "#{app}-#{name}-#{num}" %></string>
+    <key>ProgramArguments</key>
+    <array>
+        <string><%= process.command %></string>
+    </array>
+    <key>KeepAlive</key>
+    <true/>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>StandardErrorPath</key>
+    <string><%= log %>/<%= app %>-<%= name %>-<%=num%>.log</string>
+    <key>UserName</key>
+    <string><%= user %></string>
+    <key>WorkingDirectory</key>
+    <string><%= engine.root %></string>
+</dict>
+</plist>

data/data/export/runit/log/run.erb

@@ -0,0 +1,7 @@
+#!/bin/sh
+set -e
+
+LOG=<%= log %>/<%= name %>-<%= num %>
+
+test -d "$LOG" || mkdir -p m2750 "$LOG" && chown <%= user %> "$LOG"
+exec chpst -u <%= user %> svlogd "$LOG"

data/data/export/runit/run.erb

@@ -1,3 +1,3 @@
 #!/bin/sh
-cd <%= engine.directory %>
-exec chpst -u <%= user %> -e <%= process_env_directory %> <%= process.command %>
+cd <%= engine.root %>
+exec chpst -u <%= user %> -e <%= File.join(location, "#{process_directory}/env")  %> <%= process.command %>

data/data/export/supervisord/app.conf.erb

@@ -0,0 +1,27 @@
+<%
+app_names = []
+engine.each_process do |name, process|
+  1.upto(engine.formation[name]) do |num|
+    port = engine.port_for(process, num)
+    full_name = "#{app}-#{name}-#{num}"
+    environment = engine.env.merge("PORT" => port.to_s).map do |key, value|
+      "#{key}=#{shell_quote(value)}"
+    end
+    app_names << full_name
+%>
+[program:<%= full_name %>]
+command=<%= process.command %>
+autostart=true
+autorestart=true
+stopsignal=QUIT
+stdout_logfile=<%= log %>/<%= name %>-<%= num %>.log
+stderr_logfile=<%= log %>/<%= name %>-<%= num %>.error.log
+user=<%= user %>
+directory=<%= engine.root %>
+environment=<%= environment.join(',') %><%
+  end
+end
+%>
+
+[group:<%= app %>]
+programs=<%= app_names.join(',') %>

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

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

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

@@ -1,5 +1,5 @@
-start on starting <%= app %>-<%= process.name %>
-stop on stopping <%= app %>-<%= process.name %>
+start on starting <%= app %>-<%= name %>
+stop on stopping <%= app %>-<%= name %>
 respawn
 
-exec su - <%= user %> -c 'cd <%= engine.directory %>; export PORT=<%= port %>;<% engine.environment.each_pair do |var,env| %> export <%= var.upcase %>=<%= env %>; <% end %> <%= process.command %> >> <%= log_root %>/<%=process.name%>-<%=num%>.log 2>&1'
+exec su - <%= user %> -c 'cd <%= engine.root %>; export PORT=<%= port %>;<% engine.env.each_pair do |var,env| %> export <%= var.upcase %>=<%= shell_quote(env) %>; <% end %> <%= process.command %> >> <%= log %>/<%=name%>-<%=num%>.log 2>&1'

data/lib/foreman/cli.rb

@@ -1,21 +1,42 @@
 require "foreman"
+require "foreman/helpers"
 require "foreman/engine"
+require "foreman/engine/cli"
 require "foreman/export"
-require "thor"
+require "foreman/version"
+require "shellwords"
 require "yaml"
+require "thor"
 
 class Foreman::CLI < Thor
 
+  include Foreman::Helpers
+
+  map ["-v", "--version"] => :version
+
   class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
+  class_option :root,     :type => :string, :aliases => "-d", :desc => "Default: Procfile directory"
 
-  desc "start", "Start the application"
+  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"'
+  method_option :color,     :type => :boolean, :aliases => "-c", :desc => "Force color to be enabled"
+  method_option :env,       :type => :string,  :aliases => "-e", :desc => "Specify an environment file to load, defaults to .env"
+  method_option :formation, :type => :string,  :aliases => "-m", :banner => '"alpha=5,bar=3"'
+  method_option :port,      :type => :numeric, :aliases => "-p"
+
+  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
+  def start(process=nil)
     check_procfile!
+    load_environment!
+    engine.load_procfile(procfile)
+    engine.options[:formation] = "#{process}=1" if process
     engine.start
   end
 
@@ -27,22 +48,14 @@ 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)
-
+    load_environment!
+    engine.load_procfile(procfile)
+    formatter = Foreman::Export.formatter(format)
+    formatter.new(location, engine, options).export
   rescue Foreman::Export::Exception => ex
     error ex.message
   end
@@ -50,41 +63,77 @@ class Foreman::CLI < Thor
   desc "check", "Validate your application's Procfile"
 
   def check
-    error "no processes defined" unless engine.procfile.entries.length > 0
-    display "valid procfile detected (#{engine.procfile.process_names.join(', ')})"
+    check_procfile!
+    engine.load_procfile(procfile)
+    error "no processes defined" unless engine.processes.length > 0
+    puts "valid procfile detected (#{engine.process_names.join(', ')})"
   end
 
-private ######################################################################
+  desc "run COMMAND [ARGS...]", "Run a command using your application's environment"
 
-  def check_procfile!
-    error("#{procfile} does not exist.") unless File.exist?(procfile)
-  end
+  method_option :env, :type => :string, :aliases => "-e", :desc => "Specify an environment file to load, defaults to .env"
 
-  def engine
-    @engine ||= Foreman::Engine.new(procfile, options)
+  def run(*args)
+    load_environment!
+    begin
+      exec engine.env, args.shelljoin
+    rescue Errno::EACCES
+      error "not executable: #{args.first}"
+    rescue Errno::ENOENT
+      error "command not found: #{args.first}"
+    end
   end
 
-  def procfile
-    options[:procfile] || "Procfile"
+  desc "version", "Display Foreman gem version"
+
+  def version
+    puts Foreman::VERSION
   end
 
-  def display(message)
-    puts message
+  no_tasks do
+    def engine
+      @engine ||= begin
+        engine_class = Foreman::Engine::CLI
+        engine = engine_class.new(options)
+        engine
+      end
+    end
   end
 
+private ######################################################################
+
   def error(message)
     puts "ERROR: #{message}"
     exit 1
   end
 
-  def procfile_exists?(procfile)
-    File.exist?(procfile)
+  def check_procfile!
+    error("#{procfile} does not exist.") unless File.exist?(procfile)
+  end
+
+  def load_environment!
+    if options[:env]
+      options[:env].split(",").each do |file|
+        engine.load_env file
+      end
+    else
+      default_env = File.join(engine.root, ".env")
+      engine.load_env default_env if File.exists?(default_env)
+    end
+  end
+
+  def procfile
+    case
+      when options[:procfile] then options[:procfile]
+      when options[:root]     then File.expand_path(File.join(options[:app_root], "Procfile"))
+      else "Procfile"
+    end
   end
 
   def options
     original_options = super
     return original_options unless File.exists?(".foreman")
-    defaults = YAML::load_file(".foreman") || {}
+    defaults = ::YAML::load_file(".foreman") || {}
     Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
   end
 

data/lib/foreman/engine/cli.rb

@@ -0,0 +1,105 @@
+require "foreman/engine"
+
+class Foreman::Engine::CLI < Foreman::Engine
+
+  module Color
+
+    ANSI = {
+      :reset          => 0,
+      :black          => 30,
+      :red            => 31,
+      :green          => 32,
+      :yellow         => 33,
+      :blue           => 34,
+      :magenta        => 35,
+      :cyan           => 36,
+      :white          => 37,
+      :bright_black   => 30,
+      :bright_red     => 31,
+      :bright_green   => 32,
+      :bright_yellow  => 33,
+      :bright_blue    => 34,
+      :bright_magenta => 35,
+      :bright_cyan    => 36,
+      :bright_white   => 37,
+    }
+
+    def self.enable(io, force=false)
+      io.extend(self)
+      @@color_force = force
+    end
+
+    def color?
+      return true if @@color_force
+      return true if Foreman.windows?
+      return false unless self.respond_to?(:isatty)
+      self.isatty && ENV["TERM"]
+    end
+
+    def color(name)
+      return "" unless color?
+      return "" unless ansi = ANSI[name.to_sym]
+      "\e[#{ansi}m"
+    end
+
+  end
+
+  FOREMAN_COLORS = %w( cyan yellow green magenta red blue intense_cyan intense_yellow
+                       intense_green intense_magenta intense_red, intense_blue )
+
+  def startup
+    @colors = map_colors
+    proctitle "foreman: master"
+    require "win32console" if Foreman.windows?
+    Color.enable($stdout, options[:color]) unless $stdout.respond_to?(:color?)
+  end
+
+  def output(name, data)
+    data.to_s.chomp.split("\n").each do |message|
+      output  = ""
+      output += $stdout.color(@colors[name.split(".").first].to_sym)
+      output += "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(name)} | "
+      output += $stdout.color(:reset)
+      output += message
+      $stdout.puts output
+      $stdout.flush
+    end
+  rescue Errno::EPIPE
+    terminate_gracefully
+  end
+
+  def shutdown
+  end
+
+private
+
+  def name_padding
+    @name_padding ||= begin
+      index_padding = @names.values.map { |n| formation[n] }.max.to_s.length + 1
+      name_padding  = @names.values.map { |n| n.length + index_padding }.sort.last
+      [ 6, name_padding ].max
+    end
+  end
+
+  def pad_process_name(name)
+    name.ljust(name_padding, " ")
+  end
+
+  def map_colors
+    colors = Hash.new("white")
+    @names.values.each_with_index do |name, index|
+      colors[name] = FOREMAN_COLORS[index % FOREMAN_COLORS.length]
+    end
+    colors["system"] = "intense_white"
+    colors
+  end
+
+  def proctitle(title)
+    $0 = title
+  end
+
+  def termtitle(title)
+    printf("\033]0;#{title}\007") unless Foreman.windows?
+  end
+
+end