foreman 0.46.0-mingw32 → 0.50.0-mingw32

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.rb

@@ -12,6 +12,10 @@ module Foreman
     defined?(RUBY_PLATFORM) and RUBY_PLATFORM == "java"
   end
 
+  def self.ruby_18?
+    defined?(RUBY_VERSION) and RUBY_VERSION =~ /^1\.8\.\d+/
+  end
+
   def self.windows?
     defined?(RUBY_PLATFORM) and RUBY_PLATFORM =~ /(win|w)32$/
   end

data/lib/foreman/cli.rb

@@ -1,35 +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 [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 :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'
+      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 +52,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 +64,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 +84,57 @@ class Foreman::CLI < Thor
     end
   end
 
+  desc "version", "Display Foreman gem version"
+
+  def version
+    puts Foreman::VERSION
+  end
+
+  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 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") || {}
+    defaults = ::YAML::load_file(".foreman") || {}
     Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
   end
+
 end

data/lib/foreman/engine.rb

@@ -1,8 +1,7 @@
 require "foreman"
-require "foreman/color"
+require "foreman/env"
 require "foreman/process"
 require "foreman/procfile"
-require "foreman/utils"
 require "tempfile"
 require "timeout"
 require "fileutils"
@@ -10,218 +9,305 @@ require "thread"
 
 class Foreman::Engine
 
-  attr_reader :environment
-  attr_reader :procfile
-  attr_reader :directory
+  attr_reader :env
   attr_reader :options
-
-  COLORS = %w( cyan yellow green magenta red blue intense_cyan intense_yellow
-               intense_green intense_magenta intense_red, intense_blue )
-
-  Foreman::Color.enable($stdout)
-
-  def initialize(procfile, options={})
-    @procfile  = Foreman::Procfile.new(procfile) if File.exists?(procfile)
-    @directory = options[:app_root] || File.expand_path(File.dirname(procfile))
+  attr_reader :processes
+
+  # Create an +Engine+ for running processes
+  #
+  # @param [Hash] options
+  #
+  # @option options [String] :formation (all=1)    The process formation to use
+  # @option options [Fixnum] :port      (5000)     The base port to assign to processes
+  # @option options [String] :root      (Dir.pwd)  The root directory from which to run processes
+  #
+  def initialize(options={})
     @options = options.dup
-    @output_mutex = Mutex.new
 
-    @options[:env] ||= default_env
-    @environment = read_environment_files(@options[:env])
+    @options[:formation] ||= (options[:concurrency] || "all=1")
+
+    @env       = {}
+    @mutex     = Mutex.new
+    @names     = {}
+    @processes = []
+    @running   = {}
+    @readers   = {}
   end
 
+  # Start the processes registered to this +Engine+
+  #
   def start
-    proctitle "ruby: foreman master"
-    termtitle "#{File.basename(@directory)} - foreman"
-
     trap("TERM") { puts "SIGTERM received"; terminate_gracefully }
     trap("INT")  { puts "SIGINT received";  terminate_gracefully }
+    trap("HUP")  { puts "SIGHUP received";  terminate_gracefully } if ::Signal.list.keys.include? 'HUP'
 
-    assign_colors
+    startup
     spawn_processes
     watch_for_output
-    watch_for_termination
+    sleep 0.1
+    watch_for_termination { terminate_gracefully }
+    shutdown
   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
+  # Register a process to be run by this +Engine+
+  #
+  # @param [String] name     A name for this process
+  # @param [String] command  The command to run
+  # @param [Hash]   options
+  #
+  # @option options [Hash] :env  A custom environment for this process
+  #
+  def register(name, command, options={})
+    options[:env] ||= env
+    options[:cwd] ||= File.dirname(command.split(" ").first)
+    process = Foreman::Process.new(command, options)
+    @names[process] = name
+    @processes << process
   end
 
-  def apply_environment!
-    environment.each { |k,v| ENV[k] = v }
+  # Clear the processes registered to this +Engine+
+  #
+  def clear
+    @names     = {}
+    @processes = []
   end
 
-  def self.read_environment(filename)
-    return {} unless File.exists?(filename)
+  # Register processes by reading a Procfile
+  #
+  # @param [String] filename  A Procfile from which to read processes to register
+  #
+  def load_procfile(filename)
+    options[:root] ||= File.dirname(filename)
+    Foreman::Procfile.new(filename).entries do |name, command|
+      register name, command, :cwd => options[:root]
+    end
+    self
+  end
+
+  # Load a .env file into the +env+ for this +Engine+
+  #
+  # @param [String] filename  A .env file to load into the environment
+  #
+  def load_env(filename)
+    Foreman::Env.new(filename).entries do |name, value|
+      @env[name] = value
+    end
+  end
 
-    File.read(filename).split("\n").inject({}) do |hash, line|
-      if line =~ /\A([A-Za-z_0-9]+)=(.*)\z/
-        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
+  # Send a signal to all processesstarted by this +Engine+
+  #
+  # @param [String] signal  The signal to send to each process
+  #
+  def killall(signal="SIGTERM")
+    if Foreman.windows?
+      @running.each do |pid, (process, index)|
+        system "sending #{signal} to #{name_for(pid)} at pid #{pid}"
+        begin
+          Process.kill(signal, pid)
+        rescue Errno::ESRCH, Errno::EPERM
         end
       end
-      hash
+    else
+      begin
+        Process.kill "-#{signal}", Process.pid
+      rescue Errno::ESRCH, Errno::EPERM
+      end
     end
   end
 
-private ######################################################################
-
-  def spawn_processes
-    concurrency = Foreman::Utils.parse_concurrency(@options[:concurrency])
+  # Get the process formation
+  #
+  # @returns [Fixnum]  The formation count for the specified process
+  #
+  def formation
+    @formation ||= parse_formation(options[:formation])
+  end
 
-    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
+  # List the available process names
+  #
+  # @returns [Array]  A list of process names
+  #
+  def process_names
+    @processes.map { |p| @names[p] }
   end
 
-  def base_port
-    options[:port] || 5000
+  # Get the +Process+ for a specifid name
+  #
+  # @param [String] name  The process name
+  #
+  # @returns [Foreman::Process]  The +Process+ for the specified name
+  #
+  def process(name)
+    @names.invert[name]
   end
 
-  def kill_all(signal="SIGTERM")
-    running_processes.each do |pid, process|
-      info "sending #{signal} to pid #{pid}"
-      process.kill signal
+  # Yield each +Process+ in order
+  #
+  def each_process
+    process_names.each do |name|
+      yield name, process(name)
     end
   end
 
-  def terminate_gracefully
-    return if @terminating
-    @terminating = true
-    info "sending SIGTERM to all processes"
-    kill_all "SIGTERM"
-    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
+  # Get the root directory for this +Engine+
+  #
+  # @returns [String]  The root directory
+  #
+  def root
+    File.expand_path(options[:root] || Dir.pwd)
   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
+  # Get the port for a given process and offset
+  #
+  # @param [Foreman::Process] process   A +Process+ associated with this engine
+  # @param [Fixnum]           instance  The instance of the process
+  #
+  # @returns [Fixnum] port  The port to use for this instance of this process
+  #
+  def port_for(process, instance, base=nil)
+    if base
+      base + (@processes.index(process.process) * 100) + (instance - 1)
+    else
+      base_port + (@processes.index(process) * 100) + (instance - 1)
     end
   end
 
-  def watch_for_termination
-    pid, status = Process.wait2
-    process = running_processes.delete(pid)
-    info "process terminated", process.name
-    terminate_gracefully
-  rescue Errno::ECHILD
+  # Get the base port for this foreman instance
+  #
+  # @returns [Fixnum] port  The base port
+  #
+  def base_port
+    (options[:port] || env["PORT"] || ENV["PORT"] || 5000).to_i
   end
 
-  def info(message, name="system", color=:white)
-    output  = ""
-    output += $stdout.color(color)
-    output += "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(name)} | "
-    output += $stdout.color(:reset)
-    output += message.chomp
-    puts output
+  # deprecated
+  def environment
+    env
   end
 
-  def print(message=nil)
-    @output_mutex.synchronize do
-      $stdout.print message
-    end
-  end
+private
 
-  def puts(message=nil)
-    @output_mutex.synchronize do
-      $stdout.puts message
-    end
+### Engine API ######################################################
+
+  def startup
+    raise TypeError, "must use a subclass of Foreman::Engine"
   end
 
-  def longest_process_name
-    @longest_process_name ||= begin
-      longest = procfile.process_names.map { |name| name.length }.sort.last
-      longest = 6 if longest < 6 # system
-      longest
-    end
+  def output(name, data)
+    raise TypeError, "must use a subclass of Foreman::Engine"
   end
 
-  def pad_process_name(name="system")
-    name.to_s.ljust(longest_process_name + 3) # add 3 for process number padding
+  def shutdown
+    raise TypeError, "must use a subclass of Foreman::Engine"
   end
 
-  def proctitle(title)
-    $0 = title
+## Helpers ##########################################################
+
+  def create_pipe
+    IO.method(:pipe).arity.zero? ? IO.pipe : IO.pipe("BINARY")
   end
 
-  def termtitle(title)
-    printf("\033]0;#{title}\007") unless Foreman.windows?
+  def name_for(pid)
+    process, index = @running[pid]
+    [ @names[process], index.to_s ].compact.join(".")
   end
 
-  def running_processes
-    @running_processes ||= {}
+  def parse_formation(formation)
+    pairs = formation.to_s.gsub(/\s/, "").split(",")
+
+    pairs.inject(Hash.new(0)) do |ax, pair|
+      process, amount = pair.split("=")
+      process == "all" ? ax.default = amount.to_i : ax[process] = amount.to_i
+      ax
+    end
   end
 
-  def readers
-    @readers ||= {}
+  def output_with_mutex(name, message)
+    @mutex.synchronize do
+      output name, message
+    end
   end
 
-  def colors
-    @colors ||= {}
+  def system(message)
+    output_with_mutex "system", message
   end
 
-  def assign_colors
-    procfile.entries.each_with_index do |entry, idx|
-      colors[entry.name] = COLORS[idx % COLORS.length]
+  def termination_message_for(status)
+    if status.exited?
+      "exited with code #{status.exitstatus}"
+    elsif status.signaled?
+      "terminated by SIG#{Signal.list.invert[status.termsig]}"
+    else
+      "died a mysterious death"
     end
   end
 
-  def process_by_reader(reader)
-    readers.invert[reader]
+  def flush_reader(reader)
+    until reader.eof?
+      data = reader.gets
+      output_with_mutex name_for(@readers.key(reader)), data
+    end
   end
 
-  def read_environment_files(filenames)
-    environment = {}
+## Engine ###########################################################
 
-    (filenames || "").split(",").map(&:strip).each do |filename|
-      error "No such file: #{filename}" unless File.exists?(filename)
-      environment.merge!(Foreman::Engine.read_environment(filename))
+  def spawn_processes
+    @processes.each do |process|
+      1.upto(formation[@names[process]]) do |n|
+        reader, writer = create_pipe
+        begin
+          pid = process.run(:output => writer, :env => { "PORT" => port_for(process, n).to_s })
+          writer.puts "started with pid #{pid}"
+        rescue Errno::ENOENT
+          writer.puts "unknown command: #{process.command}"
+        end
+        @running[pid] = [process, n]
+        @readers[pid] = reader
+      end
     end
+  end
 
-    environment
+  def watch_for_output
+    Thread.new do
+      begin
+        loop do
+          (IO.select(@readers.values).first || []).each do |reader|
+            data = reader.gets
+            output_with_mutex name_for(@readers.invert[reader]), data
+          end
+        end
+      rescue Exception => ex
+        puts ex.message
+        puts ex.backtrace
+      end
+    end
+  end
+
+  def watch_for_termination
+    pid, status = Process.wait2
+    output_with_mutex name_for(pid), termination_message_for(status)
+    @running.delete(pid)
+    yield if block_given?
+    pid
+  rescue Errno::ECHILD
   end
 
-  def default_env
-    env = File.join(directory, ".env")
-    File.exists?(env) ? env : ""
+  def terminate_gracefully
+    return if @terminating
+    @terminating = true
+    if Foreman.windows?
+      system  "sending SIGKILL to all processes"
+      killall "SIGKILL"
+    else
+      system  "sending SIGTERM to all processes"
+      killall "SIGTERM"
+    end
+    Timeout.timeout(5) do
+      watch_for_termination while @running.length > 0
+    end
+  rescue Timeout::Error
+    system  "sending SIGKILL to all processes"
+    killall "SIGKILL"
   end
 
 end