foreman 0.46.0 → 0.48.0

data/lib/foreman/export/inittab.rb

@@ -3,21 +3,19 @@ require "foreman/export"
 class Foreman::Export::Inittab < Foreman::Export::Base
 
   def export
-    app = self.app || File.basename(engine.directory)
-    user = self.user || app
-    log_root = self.log || "/var/log/#{app}"
+    error("Must specify a location") unless location
 
     inittab = []
     inittab << "# ----- foreman #{app} processes -----"
 
-    engine.procfile.entries.inject(1) do |index, process|
-      1.upto(self.concurrency[process.name]) do |num|
+    index = 1
+    engine.each_process do |name, process|
+      1.upto(engine.formation[name]) do |num|
         id = app.slice(0, 2).upcase + sprintf("%02d", index)
-        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'"
+        port = engine.port_for(process, num)
+        inittab << "#{id}:4:respawn:/bin/su - #{user} -c 'PORT=#{port} #{process.command} >> #{log}/#{name}-#{num}.log 2>&1'"
         index += 1
       end
-      index
     end
 
     inittab << "# ----- end foreman #{app} processes -----"
@@ -27,9 +25,8 @@ class Foreman::Export::Inittab < Foreman::Export::Base
     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(location, inittab)
+      say "writing: #{location}"
+      File.open(location, "w") { |file| file.puts inittab }
     end
   end
 

data/lib/foreman/export/launchd.rb

@@ -0,0 +1,15 @@
+require "erb"
+require "foreman/export"
+
+class Foreman::Export::Launchd < Foreman::Export::Base
+
+  def export
+    super
+    engine.each_process do |name, process|
+      1.upto(engine.formation[name]) do |num|
+        write_template "launchd/launchd.plist.erb", "#{app}-#{name}-#{num}.plist", binding
+      end
+    end
+  end
+
+end

data/lib/foreman/export/runit.rb

@@ -2,58 +2,33 @@ require "erb"
 require "foreman/export"
 
 class Foreman::Export::Runit < Foreman::Export::Base
+
   ENV_VARIABLE_REGEX = /([a-zA-Z_]+[a-zA-Z0-9_]*)=(\S+)/
 
   def export
-    error("Must specify a location") unless location
-
-    app = self.app || File.basename(engine.directory)
-    user = self.user || app
-    log_root = self.log || "/var/log/#{app}"
-    template_root = self.template
+    super
 
-    run_template = export_template('runit', 'run.erb', template_root)
-    log_run_template = export_template('runit', 'log_run.erb', template_root)
-
-    engine.procfile.entries.each do |process|
-      1.upto(self.concurrency[process.name]) do |num|
-        process_directory     = "#{location}/#{app}-#{process.name}-#{num}"
-        process_env_directory = "#{process_directory}/env"
-        process_log_directory = "#{process_directory}/log"
+    engine.each_process do |name, process|
+      1.upto(engine.formation[name]) do |num|
+        process_directory = "#{app}-#{name}-#{num}"
 
         create_directory process_directory
-        create_directory process_env_directory
-        create_directory process_log_directory
-
-        run = ERB.new(run_template).result(binding)
-        write_file "#{process_directory}/run", run
-        FileUtils.chmod 0755, "#{process_directory}/run"
+        create_directory "#{process_directory}/env"
+        create_directory "#{process_directory}/log"
 
-        port = engine.port_for(process, num, self.port)
-        environment_variables = {'PORT' => port}.
-            merge(engine.environment).
-            merge(inline_variables(process.command))
+        write_template "runit/run.erb", "#{process_directory}/run", binding
+        chmod 0755, "#{process_directory}/run"
 
-        environment_variables.each_pair do |var, env|
-          write_file "#{process_env_directory}/#{var.upcase}", env
+        port = engine.port_for(process, num)
+        engine.env.merge("PORT" => port.to_s).each do |key, value|
+          write_file "#{process_directory}/env/#{key}", value
         end
 
-        log_run = ERB.new(log_run_template).result(binding)
-        write_file "#{process_log_directory}/run", log_run
-        FileUtils.chmod 0755, "#{process_log_directory}/run"
+        write_template "runit/log/run.erb", "#{process_directory}/log/run", binding
+        chmod 0755, "#{process_directory}/log/run"
       end
     end
 
   end
 
-  private
-  def create_directory(location)
-    say "creating: #{location}"
-    FileUtils.mkdir_p(location)
-  end
-
-  def inline_variables(command)
-    variable_name_regex =
-    Hash[*command.scan(ENV_VARIABLE_REGEX).flatten]
-  end
 end

data/lib/foreman/export/supervisord.rb

@@ -4,23 +4,13 @@ require "foreman/export"
 class Foreman::Export::Supervisord < Foreman::Export::Base
 
   def export
-    error("Must specify a location") unless location
-
-    FileUtils.mkdir_p location
-
-    app = self.app || File.basename(engine.directory)
-    user = self.user || app
-    log_root = self.log || "/var/log/#{app}"
-    template_root = self.template
+    super
 
     Dir["#{location}/#{app}*.conf"].each do |file|
-      say "cleaning up: #{file}"
-      FileUtils.rm(file)
+      clean file
     end
 
-    app_template = export_template("supervisord", "app.conf.erb", template_root)
-    app_config   = ERB.new(app_template, 0, '<').result(binding)
-    write_file "#{location}/#{app}.conf", app_config
+    write_template "supervisord/app.conf.erb", "#{app}.conf", binding
   end
 
 end

data/lib/foreman/export/upstart.rb

@@ -4,40 +4,22 @@ require "foreman/export"
 class Foreman::Export::Upstart < Foreman::Export::Base
 
   def export
-    error("Must specify a location") unless location
-
-    FileUtils.mkdir_p location
-
-    app = self.app || File.basename(engine.directory)
-    user = self.user || app
-    log_root = self.log || "/var/log/#{app}"
-    template_root = self.template
+    super
 
     Dir["#{location}/#{app}*.conf"].each do |file|
-      say "cleaning up: #{file}"
-      FileUtils.rm(file)
+      clean file
     end
 
-    master_template = export_template("upstart", "master.conf.erb", template_root)
-    master_config   = ERB.new(master_template).result(binding)
-    write_file "#{location}/#{app}.conf", master_config
+    write_template "upstart/master.conf.erb", "#{app}.conf", binding
 
-    process_template = export_template("upstart", "process.conf.erb", template_root)
+    engine.each_process do |name, process|
+      next if engine.formation[name] < 1
+      write_template "upstart/process_master.conf.erb", "#{app}-#{name}.conf", binding
 
-    engine.procfile.entries.each do |process|
-      next if (conc = self.concurrency[process.name]) < 1
-      process_master_template = export_template("upstart", "process_master.conf.erb", template_root)
-      process_master_config   = ERB.new(process_master_template).result(binding)
-      write_file "#{location}/#{app}-#{process.name}.conf", process_master_config
-
-      1.upto(self.concurrency[process.name]) do |num|
-        port = engine.port_for(process, num, self.port)
-        process_config = ERB.new(process_template).result(binding)
-        write_file "#{location}/#{app}-#{process.name}-#{num}.conf", process_config
+      1.upto(engine.formation[name]) do |num|
+        port = engine.port_for(process, num)
+        write_template "upstart/process.conf.erb", "#{app}-#{name}-#{num}.conf", binding
       end
     end
-
-    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}"
   end
 end

data/lib/foreman/export.rb

@@ -1,5 +1,6 @@
 require "foreman"
 require "foreman/helpers"
+require "pathname"
 
 module Foreman::Export
   extend Foreman::Helpers
@@ -24,11 +25,10 @@ module Foreman::Export
 
 end
 
-
 require "foreman/export/base"
 require "foreman/export/inittab"
 require "foreman/export/upstart"
 require "foreman/export/bluepill"
 require "foreman/export/runit"
 require "foreman/export/supervisord"
-
+require "foreman/export/launchd"

data/lib/foreman/process.rb

@@ -3,94 +3,83 @@ require "rubygems"
 
 class Foreman::Process
 
-  attr_reader :entry
-  attr_reader :num
-  attr_reader :pid
-  attr_reader :port
+  attr_reader :command
+  attr_reader :env
 
-  def initialize(entry, num, port)
-    @entry = entry
-    @num = num
-    @port = port
-  end
+  # Create a Process
+  #
+  # @param [String] command  The command to run
+  # @param [Hash]   options
+  #
+  # @option options [String] :cwd (./)  Change to this working directory before executing the process
+  # @option options [Hash]   :env ({})  Environment variables to set for this process
+  #
+  def initialize(command, options={})
+    @command = command
+    @options = options.dup
 
-  def run(pipe, basedir, environment)
-    with_environment(environment.merge("PORT" => port.to_s)) do
-      run_process basedir, entry.command, pipe
-    end
+    @options[:env] ||= {}
   end
 
-  def name
-    "%s.%s" % [ entry.name, num ]
+  # Run a +Process+
+  #
+  # @param [Hash] options
+  #
+  # @option options :env    ({})       Environment variables to set for this execution
+  # @option options :output ($stdout)  The output stream
+  #
+  # @returns [Fixnum] pid  The +pid+ of the process
+  #
+  def run(options={})
+    env    = options[:env] ? @options[:env].merge(options[:env]) : @options[:env]
+    output = options[:output] || $stdout
+
+    if Foreman.windows?
+      Dir.chdir(cwd) do
+        Process.spawn env, command, :out => output, :err => output, :new_pgroup => true
+      end
+    elsif Foreman.jruby?
+      Dir.chdir(cwd) do
+        require "posix/spawn"
+        POSIX::Spawn.spawn env, command, :out => output, :err => output, :pgroup => 0
+      end
+    else
+      Dir.chdir(cwd) do
+        Process.spawn env, command, :out => output, :err => output, :pgroup => 0
+      end
+    end
   end
 
+  # Send a signal to this +Process+
+  #
+  # @param [String] signal  The signal to send
+  #
   def kill(signal)
-    pid && Process.kill(signal, pid)
+    pid && Process.kill(signal, -1 * pid)
   rescue Errno::ESRCH
     false
   end
 
-  def detach
-    pid && Process.detach(pid)
-  end
-
+  # Test whether or not this +Process+ is still running
+  #
+  # @returns [Boolean]
+  #
   def alive?
     kill(0)
   end
 
+  # Test whether or not this +Process+ has terminated
+  #
+  # @returns [Boolean]
+  #
   def dead?
     !alive?
   end
 
 private
 
-  def fork_with_io(command, basedir)
-    reader, writer = IO.pipe
-    command = replace_command_env(command)
-    pid = if Foreman.windows?
-      Dir.chdir(basedir) do
-        Process.spawn command, :out => writer, :err => writer
-      end
-    elsif Foreman.jruby?
-      require "posix/spawn"
-      POSIX::Spawn.spawn(Foreman.runner, "-d", basedir, command, {
-        :out => writer, :err => writer
-      })
-    else
-      fork do
-        writer.sync = true
-        $stdout.reopen writer
-        $stderr.reopen writer
-        reader.close
-        exec Foreman.runner, "-d", basedir, command
-      end
-    end
-    [ reader, pid ]
-  end
-
-  def run_process(basedir, command, pipe)
-    io, @pid = fork_with_io(command, basedir)
-    output pipe, "started with pid %d" % @pid
-    Thread.new do
-      until io.eof?
-        output pipe, io.gets
-      end
-    end
-  end
-
-  def output(pipe, message)
-    pipe.puts "%s,%s" % [ name, message ]
+  def cwd
+    @options[:cwd] || "."
   end
 
-  def replace_command_env(command)
-    command.gsub(/\$(\w+)/) { |e| ENV[e[1..-1]] }
-  end
-
-  def with_environment(environment)
-    original = ENV.to_hash
-    ENV.update environment
-    yield
-  ensure
-    ENV.replace original
-  end
 end

data/lib/foreman/procfile.rb

@@ -1,56 +1,90 @@
 require "foreman"
-require "foreman/procfile_entry"
 
-# A valid Procfile entry is captured by this regex.
-# All other lines are ignored.
+# Reads and writes Procfiles
+#
+# A valid Procfile entry is captured by this regex:
 #
-# /^([A-Za-z0-9_]+):\s*(.+)$/
+#   /^([A-Za-z0-9_]+):\s*(.+)$/
 #
-# $1 = name
-# $2 = command
+# All other lines are ignored.
 #
 class Foreman::Procfile
 
-  attr_reader :entries
-
+  # Initialize a Procfile
+  #
+  # @param [String] filename (nil)  An optional filename to read from
+  #
   def initialize(filename=nil)
     @entries = []
     load(filename) if filename
   end
 
+  # Yield each +Procfile+ entry in order
+  #
+  def entries(&blk)
+    @entries.each do |(name, command)|
+      yield name, command
+    end
+  end
+
+  # Retrieve a +Procfile+ command by name
+  #
+  # @param [String] name  The name of the Procfile entry to retrieve
+  #
   def [](name)
-    entries.detect { |entry| entry.name == name }
+    @entries.detect { |n,c| name == n }.last
+  end
+
+  # Create a +Procfile+ entry
+  #
+  # @param [String] name     The name of the +Procfile+ entry to create
+  # @param [String] command  The command of the +Procfile+ entry to create
+  #
+  def []=(name, command)
+    delete name
+    @entries << [name, command]
   end
 
-  def process_names
-    entries.map(&:name)
+  # Remove a +Procfile+ entry
+  #
+  # @param [String] name  The name of the +Procfile+ entry to remove
+  #
+  def delete(name)
+    @entries.reject! { |n,c| name == n }
   end
 
+  # Load a Procfile from a file
+  #
+  # @param [String] filename  The filename of the +Procfile+ to load
+  #
   def load(filename)
-    entries.clear
-    parse_procfile(filename)
+    @entries.replace parse(filename)
   end
 
-  def write(filename)
-    File.open(filename, 'w') do |io|
-      entries.each do |ent|
-        io.puts(ent)
-      end
+  # Save a Procfile to a file
+  #
+  # @param [String] filename  Save the +Procfile+ to this file
+  #
+  def save(filename)
+    File.open(filename, 'w') do |file|
+      file.puts self.to_s
     end
   end
 
-  def <<(entry)
-    entries << Foreman::ProcfileEntry.new(*entry)
-    self
+  # Get the +Procfile+ as a +String+
+  #
+  def to_s
+    @entries.map do |name, command|
+      [ name, command ].join(": ")
+    end.join("\n")
   end
 
+private
 
-protected
-
-  def parse_procfile(filename)
+  def parse(filename)
     File.read(filename).split("\n").map do |line|
       if line =~ /^([A-Za-z0-9_]+):\s*(.+)$/
-        self << [ $1, $2 ]
+        [$1, $2]
       end
     end.compact
   end

data/lib/foreman/version.rb

@@ -1,5 +1,5 @@
 module Foreman
 
-  VERSION = "0.46.0"
+  VERSION = "0.48.0"
 
 end

data/man/foreman.1

@@ -1,7 +1,7 @@
 .\" generated with Ronn/v0.7.3
 .\" http://github.com/rtomayko/ronn/tree/0.7.3
 .
-.TH "FOREMAN" "1" "April 2012" "Foreman 0.45.0" "Foreman Manual"
+.TH "FOREMAN" "1" "April 2012" "Foreman 0.46.0" "Foreman Manual"
 .
 .SH "NAME"
 \fBforeman\fR \- manage Procfile\-based applications
@@ -46,6 +46,10 @@ Specify an alternate Procfile to load, implies \fB\-d\fR at the Procfile root\.
 \fB\-p\fR, \fB\-\-port\fR
 Specify which port to use as the base for this application\. Should be a multiple of 1000\.
 .
+.TP
+\fB\-t\fR, \fB\-\-tmux\fR
+Runs the processes in a tmux session\. Creates one window for each process and an extra window containing the output of each window (requires gawk)\.
+.
 .P
 \fBforeman run\fR is used to run one\-off commands using the same environment as your defined processes\.
 .