ypadlyak-foreman 0.81.0

data/lib/foreman/export/inittab.rb

@@ -0,0 +1,42 @@
+require "foreman/export"
+
+class Foreman::Export::Inittab < Foreman::Export::Base
+
+  def export
+    error("Must specify a location") unless location
+
+    inittab = []
+    inittab << "# ----- foreman #{app} processes -----"
+
+    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)
+
+        commands = []
+        commands << "cd #{engine.root}"
+        commands << "export PORT=#{port}"
+        engine.env.each_pair do |var, env|
+          commands << "export #{var.upcase}=#{shell_quote(env)}"
+        end
+        commands << "#{process.command} >> #{log}/#{name}-#{num}.log 2>&1"
+
+        inittab << "#{id}:4:respawn:/bin/su - #{user} -c '#{commands.join(";")}'"
+        index += 1
+      end
+    end
+
+    inittab << "# ----- end foreman #{app} processes -----"
+
+    inittab = inittab.join("\n") + "\n"
+
+    if location == "-"
+      puts inittab
+    else
+      say "writing: #{location}"
+      File.open(location, "w") { |file| file.puts inittab }
+    end
+  end
+
+end

data/lib/foreman/export/launchd.rb

@@ -0,0 +1,22 @@
+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|
+        port = engine.port_for(process, num)
+        command_args = process.command.split(/\s+/).map{|arg|
+          case arg
+          when "$PORT" then port
+          else arg
+          end
+        }
+        write_template "launchd/launchd.plist.erb", "#{app}-#{name}-#{num}.plist", binding
+      end
+    end
+  end
+
+end

data/lib/foreman/export/runit.rb

@@ -0,0 +1,34 @@
+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
+    super
+
+    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_directory}/env"
+        create_directory "#{process_directory}/log"
+
+        write_template "runit/run.erb", "#{process_directory}/run", binding
+        chmod 0755, "#{process_directory}/run"
+
+        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
+
+        write_template "runit/log/run.erb", "#{process_directory}/log/run", binding
+        chmod 0755, "#{process_directory}/log/run"
+      end
+    end
+
+  end
+
+end

data/lib/foreman/export/supervisord.rb

@@ -0,0 +1,16 @@
+require "erb"
+require "foreman/export"
+
+class Foreman::Export::Supervisord < Foreman::Export::Base
+
+  def export
+    super
+
+    Dir["#{location}/#{app}.conf"].each do |file|
+      clean file
+    end
+
+    write_template "supervisord/app.conf.erb", "#{app}.conf", binding
+  end
+
+end

data/lib/foreman/export/systemd.rb

@@ -0,0 +1,32 @@
+require "erb"
+require "foreman/export"
+
+class Foreman::Export::Systemd < Foreman::Export::Base
+
+  def export
+    super
+
+    Dir["#{location}/#{app}*.target"].concat(Dir["#{location}/#{app}*.service"]).each do |file|
+      clean file
+    end
+
+    process_master_names = []
+
+    engine.each_process do |name, process|
+      next if engine.formation[name] < 1
+
+      process_names = []
+
+      1.upto(engine.formation[name]) do |num|
+        port = engine.port_for(process, num)
+        write_template "systemd/process.service.erb", "#{app}-#{name}-#{num}.service", binding
+        process_names << "#{app}-#{name}-#{num}.service"
+      end
+
+      write_template "systemd/process_master.target.erb", "#{app}-#{name}.target", binding
+      process_master_names << "#{app}-#{name}.target"
+    end
+
+    write_template "systemd/master.target.erb", "#{app}.target", binding
+  end
+end

data/lib/foreman/export/upstart.rb

@@ -0,0 +1,43 @@
+require "erb"
+require "foreman/export"
+
+class Foreman::Export::Upstart < Foreman::Export::Base
+
+  def export
+    super
+
+    master_file = "#{app}.conf"
+
+    clean File.join(location, master_file)
+    write_template master_template, master_file, binding
+
+    engine.each_process do |name, process|
+      process_master_file = "#{app}-#{name}.conf"
+      clean File.join(location, process_master_file)
+
+      next if engine.formation[name] < 1
+      write_template process_master_template, process_master_file, binding
+
+      1.upto(engine.formation[name]) do |num|
+        port = engine.port_for(process, num)
+        process_file = "#{app}-#{name}-#{num}.conf"
+        clean File.join(location, process_file)
+        write_template process_template, process_file, binding
+      end
+    end
+  end
+
+  private
+
+  def master_template
+    "upstart/master.conf.erb"
+  end
+
+  def process_master_template
+    "upstart/process_master.conf.erb"
+  end
+
+  def process_template
+    "upstart/process.conf.erb"
+  end
+end

data/lib/foreman/export.rb

@@ -0,0 +1,36 @@
+require "foreman"
+require "foreman/helpers"
+require "pathname"
+
+module Foreman::Export
+  extend Foreman::Helpers
+
+  class Exception < ::Exception; end
+
+  def self.formatter(format)
+    begin
+      require "foreman/export/#{ format.tr('-', '_') }"
+      classy_format = classify(format)
+      formatter     = constantize("Foreman::Export::#{ classy_format }")
+    rescue NameError => ex
+      error "Unknown export format: #{format} (no class Foreman::Export::#{ classy_format })."
+    rescue LoadError => ex
+      error "Unknown export format: #{format} (unable to load file 'foreman/export/#{ format.tr('-', '_') }')."
+    end
+  end
+
+  def self.error(message)
+    raise Foreman::Export::Exception.new(message)
+  end
+
+end
+
+require "foreman/export/base"
+require "foreman/export/inittab"
+require "foreman/export/upstart"
+require "foreman/export/daemon"
+require "foreman/export/bluepill"
+require "foreman/export/runit"
+require "foreman/export/supervisord"
+require "foreman/export/launchd"
+require "foreman/export/systemd"

data/lib/foreman/helpers.rb

@@ -0,0 +1,45 @@
+module Foreman::Helpers
+  # Copied whole sale from, https://github.com/defunkt/resque/
+
+  # Given a word with dashes, returns a camel cased version of it.
+  #
+  # classify('job-name') # => 'JobName'
+  def classify(dashed_word)
+    dashed_word.split('-').each { |part| part[0] = part[0].chr.upcase }.join
+  end  # Tries to find a constant with the name specified in the argument string:
+
+  #
+  # constantize("Module") # => Module
+  # constantize("Test::Unit") # => Test::Unit
+  #
+  # The name is assumed to be the one of a top-level constant, no matter
+  # whether it starts with "::" or not. No lexical context is taken into
+  # account:
+  #
+  # C = 'outside'
+  # module M
+  #   C = 'inside'
+  #   C # => 'inside'
+  #   constantize("C") # => 'outside', same as ::C
+  # end
+  #
+  # NameError is raised when the constant is unknown.
+  def constantize(camel_cased_word)
+    camel_cased_word = camel_cased_word.to_s
+
+    names = camel_cased_word.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      args = Module.method(:const_get).arity != 1 ? [false] : []
+
+      if constant.const_defined?(name, *args)
+        constant = constant.const_get(name)
+      else
+        constant = constant.const_missing(name)
+      end
+    end
+    constant
+  end
+end

data/lib/foreman/process.rb

@@ -0,0 +1,80 @@
+require "foreman"
+require "shellwords"
+
+class Foreman::Process
+
+  attr_reader :command
+  attr_reader :env
+
+  # 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
+
+    @options[:env] ||= {}
+  end
+
+  # Get environment-expanded command for a +Process+
+  #
+  # @param [Hash] custom_env ({}) Environment variables to merge with defaults
+  #
+  # @return [String]  The expanded command
+  #
+  def expanded_command(custom_env={})
+    env = @options[:env].merge(custom_env)
+    expanded_command = command.dup
+    env.each do |key, val|
+      expanded_command.gsub!("$#{key}", val)
+    end
+    expanded_command
+  end
+
+  # 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].merge(options[:env] || {})
+    output = options[:output] || $stdout
+    runner = "#{Foreman.runner}".shellescape
+    
+    Dir.chdir(cwd) do
+      Process.spawn env, expanded_command(env), :out => output, :err => output
+    end
+  end
+
+  # Exec a +Process+
+  #
+  # @param [Hash] options
+  #
+  # @option options :env ({}) Environment variables to set for this execution
+  #
+  # @return Does not return
+  def exec(options={})
+    env = @options[:env].merge(options[:env] || {})
+    env.each { |k, v| ENV[k] = v }
+    Dir.chdir(cwd)
+    Kernel.exec expanded_command(env)
+  end
+
+  # Returns the working directory for this +Process+
+  #
+  # @returns [String]
+  #
+  def cwd
+    File.expand_path(@options[:cwd] || ".")
+  end
+
+end

data/lib/foreman/procfile.rb

@@ -0,0 +1,94 @@
+require "foreman"
+
+# Reads and writes Procfiles
+#
+# A valid Procfile entry is captured by this regex:
+#
+#   /^([A-Za-z0-9_]+):\s*(.+)$/
+#
+# All other lines are ignored.
+#
+class Foreman::Procfile
+
+  # 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)
+    if entry = @entries.detect { |n,c| name == n }
+      entry.last
+    end
+  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
+
+  # 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.replace parse(filename)
+  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
+
+  # Get the +Procfile+ as a +String+
+  #
+  def to_s
+    @entries.map do |name, command|
+      [ name, command ].join(": ")
+    end.join("\n")
+  end
+
+private
+
+  def parse(filename)
+    File.read(filename).gsub("\r\n","\n").split("\n").map do |line|
+      if line =~ /^([A-Za-z0-9_-]+):\s*(.+)$/
+        [$1, $2]
+      end
+    end.compact
+  end
+
+end

data/lib/foreman/version.rb

@@ -0,0 +1,5 @@
+module Foreman
+
+  VERSION = "0.81.0"
+
+end

data/lib/foreman.rb

@@ -0,0 +1,17 @@
+require "foreman/version"
+
+module Foreman
+
+  def self.runner
+    File.expand_path("../../bin/foreman-runner", __FILE__)
+  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
+
+end