overman 0.0.1 → 0.87.3

data/lib/foreman/export/daemon.rb

@@ -0,0 +1,28 @@
+require "erb"
+require "foreman/export"
+
+class Foreman::Export::Daemon < Foreman::Export::Base
+
+  def export
+    super
+
+    (Dir["#{location}/#{app}-*.conf"] << "#{location}/#{app}.conf").each do |file|
+      clean file
+    end
+
+    write_template "daemon/master.conf.erb", "#{app}.conf", binding
+
+    engine.each_process do |name, process|
+      next if engine.formation[name] < 1
+      write_template "daemon/process_master.conf.erb", "#{app}-#{name}.conf", binding
+
+      1.upto(engine.formation[name]) do |num|
+        port = engine.port_for(process, num)
+        arguments = process.command.split(" ")
+        executable = arguments.slice!(0)
+        arguments = arguments.size > 0 ? " -- #{arguments.join(' ')}" : ""
+        write_template "daemon/process.conf.erb", "#{app}-#{name}-#{num}.conf", binding
+      end
+    end
+  end
+end

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,34 @@
+require "erb"
+require "foreman/export"
+
+class Foreman::Export::Systemd < Foreman::Export::Base
+
+  def export
+    super
+
+    Dir["#{location}/#{app}*.target"]
+      .concat(Dir["#{location}/#{app}*.service"])
+      .concat(Dir["#{location}/#{app}*.target.wants/#{app}*.service"])
+      .each do |file|
+      clean file
+    end
+
+    Dir["#{location}/#{app}*.target.wants"].each do |file|
+      clean_dir file
+    end
+
+    service_names = []
+
+    engine.each_process do |name, process|
+      1.upto(engine.formation[name]) do |num|
+        port = engine.port_for(process, num)
+        process_name = "#{name}.#{num}"
+        service_filename = "#{app}-#{process_name}.service"
+        write_template "systemd/process.service.erb", service_filename, binding
+        service_names << service_filename
+      end
+    end
+
+    write_template "systemd/master.target.erb", "#{app}.target", binding
+  end
+end

data/lib/foreman/export/upstart.rb

@@ -0,0 +1,46 @@
+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"
+      process_file = "#{app}-#{name}-%s.conf"
+
+      Dir[
+        File.join(location, process_master_file),
+        File.join(location, process_file % "*")
+      ].each { |f| clean(f) }
+
+      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)
+        write_template process_template, process_file % num, 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,81 @@
+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
+    pgroup = Foreman.windows? ? :new_pgroup : :pgroup
+
+    Dir.chdir(cwd) do
+      Process.spawn env, expanded_command(env), :out => output, :err => output, pgroup => true
+    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
+    @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/vendor/thor/lib/thor/actions/create_file.rb

@@ -0,0 +1,103 @@
+require "foreman/vendor/thor/lib/thor/actions/empty_directory"
+
+class Foreman::Thor
+  module Actions
+    # Create a new file relative to the destination root with the given data,
+    # which is the return value of a block or a data string.
+    #
+    # ==== Parameters
+    # destination<String>:: the relative path to the destination root.
+    # data<String|NilClass>:: the data to append to the file.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   create_file "lib/fun_party.rb" do
+    #     hostname = ask("What is the virtual hostname I should use?")
+    #     "vhost.name = #{hostname}"
+    #   end
+    #
+    #   create_file "config/apache.conf", "your apache config"
+    #
+    def create_file(destination, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      data = args.first
+      action CreateFile.new(self, destination, block || data.to_s, config)
+    end
+    alias_method :add_file, :create_file
+
+    # CreateFile is a subset of Template, which instead of rendering a file with
+    # ERB, it gets the content from the user.
+    #
+    class CreateFile < EmptyDirectory #:nodoc:
+      attr_reader :data
+
+      def initialize(base, destination, data, config = {})
+        @data = data
+        super(base, destination, config)
+      end
+
+      # Checks if the content of the file at the destination is identical to the rendered result.
+      #
+      # ==== Returns
+      # Boolean:: true if it is identical, false otherwise.
+      #
+      def identical?
+        exists? && File.binread(destination) == render
+      end
+
+      # Holds the content to be added to the file.
+      #
+      def render
+        @render ||= if data.is_a?(Proc)
+          data.call
+        else
+          data
+        end
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          FileUtils.mkdir_p(File.dirname(destination))
+          File.open(destination, "wb") { |f| f.write render }
+        end
+        given_destination
+      end
+
+    protected
+
+      # Now on conflict we check if the file is identical or not.
+      #
+      def on_conflict_behavior(&block)
+        if identical?
+          say_status :identical, :blue
+        else
+          options = base.options.merge(config)
+          force_or_skip_or_conflict(options[:force], options[:skip], &block)
+        end
+      end
+
+      # If force is true, run the action, otherwise check if it's not being
+      # skipped. If both are false, show the file_collision menu, if the menu
+      # returns true, force it, otherwise skip.
+      #
+      def force_or_skip_or_conflict(force, skip, &block)
+        if force
+          say_status :force, :yellow
+          yield unless pretend?
+        elsif skip
+          say_status :skip, :yellow
+        else
+          say_status :conflict, :red
+          force_or_skip_or_conflict(force_on_collision?, true, &block)
+        end
+      end
+
+      # Shows the file collision menu to the user and gets the result.
+      #
+      def force_on_collision?
+        base.shell.file_collision(destination) { render }
+      end
+    end
+  end
+end

data/lib/foreman/vendor/thor/lib/thor/actions/create_link.rb

@@ -0,0 +1,59 @@
+require "foreman/vendor/thor/lib/thor/actions/create_file"
+
+class Foreman::Thor
+  module Actions
+    # Create a new file relative to the destination root from the given source.
+    #
+    # ==== Parameters
+    # destination<String>:: the relative path to the destination root.
+    # source<String|NilClass>:: the relative path to the source root.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #   :: give :symbolic => false for hard link.
+    #
+    # ==== Examples
+    #
+    #   create_link "config/apache.conf", "/etc/apache.conf"
+    #
+    def create_link(destination, *args)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      source = args.first
+      action CreateLink.new(self, destination, source, config)
+    end
+    alias_method :add_link, :create_link
+
+    # CreateLink is a subset of CreateFile, which instead of taking a block of
+    # data, just takes a source string from the user.
+    #
+    class CreateLink < CreateFile #:nodoc:
+      attr_reader :data
+
+      # Checks if the content of the file at the destination is identical to the rendered result.
+      #
+      # ==== Returns
+      # Boolean:: true if it is identical, false otherwise.
+      #
+      def identical?
+        exists? && File.identical?(render, destination)
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          FileUtils.mkdir_p(File.dirname(destination))
+          # Create a symlink by default
+          config[:symbolic] = true if config[:symbolic].nil?
+          File.unlink(destination) if exists?
+          if config[:symbolic]
+            File.symlink(render, destination)
+          else
+            File.link(render, destination)
+          end
+        end
+        given_destination
+      end
+
+      def exists?
+        super || File.symlink?(destination)
+      end
+    end
+  end
+end