foreman 0.46.0 → 0.48.0.pre1

data/README.md

@@ -27,6 +27,12 @@ Manage Procfile-based applications
 * [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

data/bin/foreman-runner

@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-#/ Usage: foreman-runner [-d <dir>] <command>
+#/ Usage: foreman-runner [-d <dir>] <command> [<args>...]
 #/
 #/ Run a command with exec, optionally changing directory first
 
@@ -27,10 +27,6 @@ done
 
 shift $((OPTIND-1))
 
-command=$1
+[ -z "$1" ] && usage
 
-if [ -z "$1" ]; then
-  usage
-fi
-
-exec $1
+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,3 +1,4 @@
-ticker: ruby ./ticker $PORT
-error:  ruby ./error
-utf8:   ruby ./utf8
+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/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, self.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

@@ -1,23 +1,23 @@
 <%
 app_names = []
-engine.procfile.entries.each do |process|
-  next if (conc = self.concurrency[process.name]) < 1
-  1.upto(self.concurrency[process.name]) do |num|
-    port = engine.port_for(process, num, self.port)
-    name = if (conc > 1); "#{process.name}-#{num}" else process.name; end
-    environment = (engine.environment.keys.sort.map{ |var| %{#{var.upcase}="#{engine.environment[var]}"} } + [%{PORT="#{port}"}])
-    app_name = "#{app}-#{name}"
-    app_names << app_name
+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:<%= app_name %>]
+[program:<%= full_name %>]
 command=<%= process.command %>
 autostart=true
 autorestart=true
 stopsignal=QUIT
-stdout_logfile=<%= log_root %>/<%=process.name%>-<%=num%>-out.log
-stderr_logfile=<%= log_root %>/<%=process.name%>-<%=num%>-err.log
+stdout_logfile=<%= log %>/<%= name %>-<%= num %>.log
+stderr_logfile=<%= log %>/<%= name %>-<%= num %>.error.log
 user=<%= user %>
-directory=<%= engine.directory %>
+directory=<%= engine.root %>
 environment=<%= environment.join(',') %><%
   end
 end

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,35 +1,37 @@
 require "foreman"
 require "foreman/helpers"
 require "foreman/engine"
+require "foreman/engine/cli"
 require "foreman/export"
+require "shellwords"
 require "thor"
-require "yaml"
 
 class Foreman::CLI < Thor
+
   include Foreman::Helpers
 
   class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
+  class_option :root,     :type => :string, :aliases => "-d", :desc => "Default: Procfile directory"
 
   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"'
+  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'
+      return false if word == "run"
       super
     end
   end
 
   def start(process=nil)
     check_procfile!
-    engine.options[:concurrency] = "#{process}=1" if process
+    load_environment!
+    engine.load_procfile(procfile)
+    engine.options[:formation] = "#{process}=1" if process
     engine.start
   end
 
@@ -45,6 +47,8 @@ class Foreman::CLI < Thor
 
   def export(format, location=nil)
     check_procfile!
+    load_environment!
+    engine.load_procfile(procfile)
     formatter = Foreman::Export.formatter(format)
     formatter.new(location, engine, options).export
   rescue Foreman::Export::Exception => ex
@@ -55,16 +59,19 @@ class Foreman::CLI < Thor
 
   def check
     check_procfile!
-    error "no processes defined" unless engine.procfile.entries.length > 0
-    puts "valid procfile detected (#{engine.procfile.process_names.join(', ')})"
+    engine.load_procfile(procfile)
+    error "no processes defined" unless engine.processes.length > 0
+    puts "valid procfile detected (#{engine.process_names.join(', ')})"
   end
 
-  desc "run COMMAND", "Run a command using your application's environment"
+  desc "run COMMAND [ARGS...]", "Run a command using your application's environment"
+
+  method_option :env, :type => :string, :aliases => "-e", :desc => "Specify an environment file to load, defaults to .env"
 
   def run(*args)
-    engine.apply_environment!
+    load_environment!
     begin
-      exec args.join(" ")
+      exec engine.env, args.shelljoin
     rescue Errno::EACCES
       error "not executable: #{args.first}"
     rescue Errno::ENOENT
@@ -72,33 +79,55 @@ class Foreman::CLI < Thor
     end
   end
 
+  no_tasks do
+    def engine
+      @engine ||= begin
+        engine_class = Foreman::Engine::CLI
+        engine = engine_class.new(
+          :formation => options[:formation],
+          :port      => options[:port],
+          :root      => options[:root]
+        )
+        engine
+      end
+    end
+  end
+
 private ######################################################################
 
+  def error(message)
+    puts "ERROR: #{message}"
+    exit 1
+  end
+
   def check_procfile!
     error("#{procfile} does not exist.") unless File.exist?(procfile)
   end
 
-  def engine
-    @engine ||= Foreman::Engine.new(procfile, options)
+  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[:app_root] then File.expand_path(File.join(options[:app_root], "Procfile"))
+      when options[:root]     then File.expand_path(File.join(options[:app_root], "Procfile"))
       else "Procfile"
     end
   end
 
-  def error(message)
-    puts "ERROR: #{message}"
-    exit 1
-  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/cli.rb

@@ -0,0 +1,98 @@
+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)
+      io.extend(self)
+    end
+
+    def color?
+      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"
+  end
+
+  def output(name, data)
+    data.to_s.chomp.split("\n").each do |message|
+      Color.enable($stdout) unless $stdout.respond_to?(:color?)
+      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
+    end
+  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