foreman 0.84.0 → 0.87.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 07592e3ada2314429eef1c9e1c0ba6bece95ab7e
-  data.tar.gz: 445fb48e93a2447988598b2db0f60a78c1991b14
+SHA256:
+  metadata.gz: d793d4fa84a1ecb6daadb477756195e44f9ccd90de90be6f817505015028c06e
+  data.tar.gz: cab6c4bce9ffa9bceef2eeb15023dad3d9b404bba2a0c2d67a1fb785dc09bb12
 SHA512:
-  metadata.gz: 546d1fb8701f569b96ba69885e6d390385abe15a309ffbe5a03a68a4cd074a878a0ba06d7dbe7f15bf0399e72c6c72097c8bfa10f94a8552b875787a9e88f1dd
-  data.tar.gz: d3a0b59f02ef1203f8cb4e8b354a789182cb7eaa9afd053a17bba0450f9f34ff03b287b410be514f8a759d9a7295ee080e14d75f073be65abc8281f5cd90c1f6
+  metadata.gz: 62699c71def241e50ae7b41ad409a723a90b17027748daf989bf251497b1ede3bfd13c8ed0edb29f93395b88a88dfcbc119424bf310fe6cb432fde61f7686856
+  data.tar.gz: 8549d39b952cb2702d15498fee39b8fe8c11e60acb39e33aa79d44b899bdbc204291e6320647fcdf0d3d3f3d255950066e318a1c876d80e05c00d90f3af49cbd

data/README.md

@@ -10,7 +10,7 @@ Manage Procfile-based applications
 
     $ gem install foreman
 
-Ruby users should take care *not* to install foreman in their project's `Gemfile`.
+Ruby users should take care *not* to install foreman in their project's `Gemfile`. See this [wiki article](https://github.com/ddollar/foreman/wiki/Don't-Bundle-Foreman) for more details.
 
 ## Getting Started
 

data/data/export/daemon/process.conf.erb

@@ -3,6 +3,6 @@ stop on stopping <%= app %>-<%= name.gsub('_', '-') %>
 respawn
 
 env PORT=<%= port %><% engine.env.each_pair do |var, env| %>
-env <%= var.upcase %>=<%= env %><% end %>
+env <%= var %>=<%= env %><% end %>
 
 exec start-stop-daemon --start --chuid <%= user %> --chdir <%= engine.root %> --make-pidfile --pidfile <%= run %>/<%= app %>-<%= name %>-<%= num %>.pid --exec <%= executable %><%= arguments %> >> <%= log %>/<%= app %>-<%= name %>-<%= num %>.log 2>&1

data/data/export/launchd/launchd.plist.erb

@@ -7,7 +7,7 @@
     <key>EnvironmentVariables</key>
     <dict>
     <%- engine.env.merge("PORT" => port).each_pair do |var,env| -%>
-        <key><%= var.upcase %></key>
+        <key><%= var %></key>
         <string><%= env %></string>
     <%- end -%>
     </dict>

data/data/export/systemd/master.target.erb

@@ -1,5 +1,5 @@
 [Unit]
-Wants=<%= process_master_names.join(' ') %>
+Wants=<%= service_names.join(' ') %>
 
 [Install]
 WantedBy=multi-user.target

data/data/export/systemd/process.service.erb

@@ -1,15 +1,18 @@
 [Unit]
-PartOf=<%= app %>-<%= name %>.target
+PartOf=<%= app %>.target
+StopWhenUnneeded=yes
 
 [Service]
 User=<%= user %>
 WorkingDirectory=<%= engine.root %>
-Environment=PORT=%i
+Environment=PORT=<%= port %>
+Environment=PS=<%= process_name %>
 <% engine.env.each_pair do |var,env| -%>
-Environment="<%= var.upcase %>=<%= env %>"
+Environment="<%= var %>=<%= env %>"
 <% end -%>
-ExecStart=/bin/bash -lc 'exec <%= process.command %>'
+ExecStart=/bin/bash -lc 'exec -a "<%= app %>-<%= process_name %>" <%= process.command %>'
 Restart=always
+RestartSec=14s
 StandardInput=null
 StandardOutput=syslog
 StandardError=syslog

data/data/export/upstart/process.conf.erb

@@ -5,7 +5,7 @@ respawn
 env PORT=<%= port %>
 <% engine.env.each do |name,value| -%>
 <% next if name.upcase == "PORT" -%>
-env <%= name.upcase %>='<%= value.gsub(/'/, "'\"'\"'") %>'
+env <%= name %>='<%= value.gsub(/'/, "'\"'\"'") %>'
 <% end -%>
 
 setuid <%= user %>

data/lib/foreman/cli.rb

@@ -6,9 +6,9 @@ require "foreman/export"
 require "foreman/version"
 require "shellwords"
 require "yaml"
-require "thor"
+require "foreman/vendor/thor/lib/thor"
 
-class Foreman::CLI < Thor
+class Foreman::CLI < Foreman::Thor
 
   include Foreman::Helpers
 
@@ -157,6 +157,6 @@ private ######################################################################
     original_options = super
     return original_options unless File.file?(".foreman")
     defaults = ::YAML::load_file(".foreman") || {}
-    Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
+    Foreman::Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
   end
 end

data/lib/foreman/engine.rb

@@ -197,7 +197,8 @@ class Foreman::Engine
       end
     else
       begin
-        Process.kill signal, *@running.keys unless @running.empty?
+        pids = @running.keys.compact
+        Process.kill signal, *pids unless pids.empty?
       rescue Errno::ESRCH, Errno::EPERM
       end
     end

data/lib/foreman/export/base.rb

@@ -135,7 +135,11 @@ private ######################################################################
   end
 
   def write_template(name, target, binding)
-    compiled = ERB.new(export_template(name), nil, '-').result(binding)
+    compiled = if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
+                 ERB.new(export_template(name), trim_mode: '-').result(binding)
+               else
+                 ERB.new(export_template(name), nil, '-').result(binding)
+               end
     write_file target, compiled
   end
 

data/lib/foreman/export/systemd.rb

@@ -17,22 +17,16 @@ class Foreman::Export::Systemd < Foreman::Export::Base
       clean_dir file
     end
 
-    process_master_names = []
+    service_names = []
 
     engine.each_process do |name, process|
-      service_fn = "#{app}-#{name}@.service"
-      write_template "systemd/process.service.erb", service_fn, binding
-
-      create_directory("#{app}-#{name}.target.wants")
-      1.upto(engine.formation[name])
-        .collect { |num| engine.port_for(process, num) }
-        .collect { |port| "#{app}-#{name}@#{port}.service" }
-        .each do |process_name|
-        create_symlink("#{app}-#{name}.target.wants/#{process_name}", "../#{service_fn}") rescue Errno::EEXIST # This is needed because rr-mocks do not call the origial cleanup
+      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
-
-      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

data/lib/foreman/procfile.rb

@@ -21,7 +21,7 @@ class Foreman::Procfile
 
   # Yield each +Procfile+ entry in order
   #
-  def entries(&blk)
+  def entries
     @entries.each do |(name, command)|
       yield name, command
     end

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

@@ -0,0 +1,492 @@
+require "set"
+require "foreman/vendor/thor/lib/thor/base"
+
+class Foreman::Thor
+  class << self
+    # Allows for custom "Command" package naming.
+    #
+    # === Parameters
+    # name<String>
+    # options<Hash>
+    #
+    def package_name(name, _ = {})
+      @package_name = name.nil? || name == "" ? nil : name
+    end
+
+    # Sets the default command when thor is executed without an explicit command to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the default command
+    #
+    def default_command(meth = nil)
+      if meth
+        @default_command = meth == :none ? "help" : meth.to_s
+      else
+        @default_command ||= from_superclass(:default_command, "help")
+      end
+    end
+    alias_method :default_task, :default_command
+
+    # Registers another Foreman::Thor subclass as a command.
+    #
+    # ==== Parameters
+    # klass<Class>:: Foreman::Thor subclass to register
+    # command<String>:: Subcommand name to use
+    # usage<String>:: Short usage for the subcommand
+    # description<String>:: Description for the subcommand
+    def register(klass, subcommand_name, usage, description, options = {})
+      if klass <= Foreman::Thor::Group
+        desc usage, description, options
+        define_method(subcommand_name) { |*args| invoke(klass, args) }
+      else
+        desc usage, description, options
+        subcommand subcommand_name, klass
+      end
+    end
+
+    # Defines the usage and the description of the next command.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    # options<String>
+    #
+    def desc(usage, description, options = {})
+      if options[:for]
+        command = find_and_refresh_command(options[:for])
+        command.usage = usage             if usage
+        command.description = description if description
+      else
+        @usage = usage
+        @desc = description
+        @hide = options[:hide] || false
+      end
+    end
+
+    # Defines the long description of the next command.
+    #
+    # ==== Parameters
+    # long description<String>
+    #
+    def long_desc(long_description, options = {})
+      if options[:for]
+        command = find_and_refresh_command(options[:for])
+        command.long_description = long_description if long_description
+      else
+        @long_desc = long_description
+      end
+    end
+
+    # Maps an input to a command. If you define:
+    #
+    #   map "-T" => "list"
+    #
+    # Running:
+    #
+    #   thor -T
+    #
+    # Will invoke the list command.
+    #
+    # ==== Parameters
+    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given command.
+    #
+    def map(mappings = nil)
+      @map ||= from_superclass(:map, {})
+
+      if mappings
+        mappings.each do |key, value|
+          if key.respond_to?(:each)
+            key.each { |subkey| @map[subkey] = value }
+          else
+            @map[key] = value
+          end
+        end
+      end
+
+      @map
+    end
+
+    # Declares the options for the next command to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    #
+    def method_options(options = nil)
+      @method_options ||= {}
+      build_options(options, @method_options) if options
+      @method_options
+    end
+
+    alias_method :options, :method_options
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined command.
+    #
+    #   def previous_command
+    #     # magic
+    #   end
+    #
+    #   method_option :foo => :bar, :for => :previous_command
+    #
+    #   def next_command
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    # :hide     - If you want to hide this option from the help.
+    #
+    def method_option(name, options = {})
+      scope = if options[:for]
+        find_and_refresh_command(options[:for]).options
+      else
+        method_options
+      end
+
+      build_option(name, options, scope)
+    end
+    alias_method :option, :method_option
+
+    def disable_class_options
+      @disable_class_options = true
+    end
+
+    # Prints help information for the given command.
+    #
+    # ==== Parameters
+    # shell<Foreman::Thor::Shell>
+    # command_name<String>
+    #
+    def command_help(shell, command_name)
+      meth = normalize_command_name(command_name)
+      command = all_commands[meth]
+      handle_no_command_error(meth) unless command
+
+      shell.say "Usage:"
+      shell.say "  #{banner(command)}"
+      shell.say
+      class_options_help(shell, nil => command.options.values)
+      if command.long_description
+        shell.say "Description:"
+        shell.print_wrapped(command.long_description, :indent => 2)
+      else
+        shell.say command.description
+      end
+    end
+    alias_method :task_help, :command_help
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Foreman::Thor::Shell>
+    #
+    def help(shell, subcommand = false)
+      list = printable_commands(true, subcommand)
+      Foreman::Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_commands(false)
+      end
+      list.sort! { |a, b| a[0] <=> b[0] }
+
+      if defined?(@package_name) && @package_name
+        shell.say "#{@package_name} commands:"
+      else
+        shell.say "Commands:"
+      end
+
+      shell.print_table(list, :indent => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
+
+    # Returns commands ready to be printed.
+    def printable_commands(all = true, subcommand = false)
+      (all ? all_commands : commands).map do |_, command|
+        next if command.hidden?
+        item = []
+        item << banner(command, false, subcommand)
+        item << (command.description ? "# #{command.description.gsub(/\s+/m, ' ')}" : "")
+        item
+      end.compact
+    end
+    alias_method :printable_tasks, :printable_commands
+
+    def subcommands
+      @subcommands ||= from_superclass(:subcommands, [])
+    end
+    alias_method :subtasks, :subcommands
+
+    def subcommand_classes
+      @subcommand_classes ||= {}
+    end
+
+    def subcommand(subcommand, subcommand_class)
+      subcommands << subcommand.to_s
+      subcommand_class.subcommand_help subcommand
+      subcommand_classes[subcommand.to_s] = subcommand_class
+
+      define_method(subcommand) do |*args|
+        args, opts = Foreman::Thor::Arguments.split(args)
+        invoke_args = [args, opts, {:invoked_via_subcommand => true, :class_options => options}]
+        invoke_args.unshift "help" if opts.delete("--help") || opts.delete("-h")
+        invoke subcommand_class, *invoke_args
+      end
+    end
+    alias_method :subtask, :subcommand
+
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    def check_unknown_options!(options = {})
+      @check_unknown_options ||= {}
+      options.each do |key, value|
+        if value
+          @check_unknown_options[key] = Array(value)
+        else
+          @check_unknown_options.delete(key)
+        end
+      end
+      @check_unknown_options
+    end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    def check_unknown_options?(config) #:nodoc:
+      options = check_unknown_options
+      return false unless options
+
+      command = config[:current_command]
+      return true unless command
+
+      name = command.name
+
+      if subcommands.include?(name)
+        false
+      elsif options[:except]
+        !options[:except].include?(name.to_sym)
+      elsif options[:only]
+        options[:only].include?(name.to_sym)
+      else
+        true
+      end
+    end
+
+    # Stop parsing of options as soon as an unknown option or a regular
+    # argument is encountered.  All remaining arguments are passed to the command.
+    # This is useful if you have a command that can receive arbitrary additional
+    # options, and where those additional options should not be handled by
+    # Foreman::Thor.
+    #
+    # ==== Example
+    #
+    # To better understand how this is useful, let's consider a command that calls
+    # an external command.  A user may want to pass arbitrary options and
+    # arguments to that command.  The command itself also accepts some options,
+    # which should be handled by Foreman::Thor.
+    #
+    #   class_option "verbose",  :type => :boolean
+    #   stop_on_unknown_option! :exec
+    #   check_unknown_options!  :except => :exec
+    #
+    #   desc "exec", "Run a shell command"
+    #   def exec(*args)
+    #     puts "diagnostic output" if options[:verbose]
+    #     Kernel.exec(*args)
+    #   end
+    #
+    # Here +exec+ can be called with +--verbose+ to get diagnostic output,
+    # e.g.:
+    #
+    #   $ thor exec --verbose echo foo
+    #   diagnostic output
+    #   foo
+    #
+    # But if +--verbose+ is given after +echo+, it is passed to +echo+ instead:
+    #
+    #   $ thor exec echo --verbose foo
+    #   --verbose foo
+    #
+    # ==== Parameters
+    # Symbol ...:: A list of commands that should be affected.
+    def stop_on_unknown_option!(*command_names)
+      stop_on_unknown_option.merge(command_names)
+    end
+
+    def stop_on_unknown_option?(command) #:nodoc:
+      command && stop_on_unknown_option.include?(command.name.to_sym)
+    end
+
+  protected
+
+    def stop_on_unknown_option #:nodoc:
+      @stop_on_unknown_option ||= Set.new
+    end
+
+    # The method responsible for dispatching given the args.
+    def dispatch(meth, given_args, given_opts, config) #:nodoc: # rubocop:disable MethodLength
+      meth ||= retrieve_command_name(given_args)
+      command = all_commands[normalize_command_name(meth)]
+
+      if !command && config[:invoked_via_subcommand]
+        # We're a subcommand and our first argument didn't match any of our
+        # commands. So we put it back and call our default command.
+        given_args.unshift(meth)
+        command = all_commands[normalize_command_name(default_command)]
+      end
+
+      if command
+        args, opts = Foreman::Thor::Options.split(given_args)
+        if stop_on_unknown_option?(command) && !args.empty?
+          # given_args starts with a non-option, so we treat everything as
+          # ordinary arguments
+          args.concat opts
+          opts.clear
+        end
+      else
+        args = given_args
+        opts = nil
+        command = dynamic_command_class.new(meth)
+      end
+
+      opts = given_opts || opts || []
+      config[:current_command] = command
+      config[:command_options] = command.options
+
+      instance = new(args, opts, config)
+      yield instance if block_given?
+      args = instance.args
+      trailing = args[Range.new(arguments.size, -1)]
+      instance.invoke_command(command, trailing || [])
+    end
+
+    # The banner for this class. You can customize it if you are invoking the
+    # thor class by another ways which is not the Foreman::Thor::Runner. It receives
+    # the command that is going to be invoked and a boolean which indicates if
+    # the namespace should be displayed as arguments.
+    #
+    def banner(command, namespace = nil, subcommand = false)
+      "#{basename} #{command.formatted_usage(self, $thor_runner, subcommand)}"
+    end
+
+    def baseclass #:nodoc:
+      Foreman::Thor
+    end
+
+    def dynamic_command_class #:nodoc:
+      Foreman::Thor::DynamicCommand
+    end
+
+    def create_command(meth) #:nodoc:
+      @usage ||= nil
+      @desc ||= nil
+      @long_desc ||= nil
+      @disable_class_options ||= nil
+
+      if @usage && @desc
+        base_class = @hide ? Foreman::Thor::HiddenCommand : Foreman::Thor::Command
+        commands[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options, @disable_class_options)
+        @usage, @desc, @long_desc, @method_options, @hide, @disable_class_options = nil
+        true
+      elsif all_commands[meth] || meth == "method_missing"
+        true
+      else
+        puts "[WARNING] Attempted to create command #{meth.inspect} without usage or description. " \
+             "Call desc if you want this method to be available as command or declare it inside a " \
+             "no_commands{} block. Invoked from #{caller[1].inspect}."
+        false
+      end
+    end
+    alias_method :create_task, :create_command
+
+    def initialize_added #:nodoc:
+      class_options.merge!(method_options)
+      @method_options = nil
+    end
+
+    # Retrieve the command name from given args.
+    def retrieve_command_name(args) #:nodoc:
+      meth = args.first.to_s unless args.empty?
+      args.shift if meth && (map[meth] || meth !~ /^\-/)
+    end
+    alias_method :retrieve_task_name, :retrieve_command_name
+
+    # receives a (possibly nil) command name and returns a name that is in
+    # the commands hash. In addition to normalizing aliases, this logic
+    # will determine if a shortened command is an unambiguous substring of
+    # a command or alias.
+    #
+    # +normalize_command_name+ also converts names like +animal-prison+
+    # into +animal_prison+.
+    def normalize_command_name(meth) #:nodoc:
+      return default_command.to_s.tr("-", "_") unless meth
+
+      possibilities = find_command_possibilities(meth)
+      raise AmbiguousTaskError, "Ambiguous command #{meth} matches [#{possibilities.join(', ')}]" if possibilities.size > 1
+
+      if possibilities.empty?
+        meth ||= default_command
+      elsif map[meth]
+        meth = map[meth]
+      else
+        meth = possibilities.first
+      end
+
+      meth.to_s.tr("-", "_") # treat foo-bar as foo_bar
+    end
+    alias_method :normalize_task_name, :normalize_command_name
+
+    # this is the logic that takes the command name passed in by the user
+    # and determines whether it is an unambiguous substrings of a command or
+    # alias name.
+    def find_command_possibilities(meth)
+      len = meth.to_s.length
+      possibilities = all_commands.merge(map).keys.select { |n| meth == n[0, len] }.sort
+      unique_possibilities = possibilities.map { |k| map[k] || k }.uniq
+
+      if possibilities.include?(meth)
+        [meth]
+      elsif unique_possibilities.size == 1
+        unique_possibilities
+      else
+        possibilities
+      end
+    end
+    alias_method :find_task_possibilities, :find_command_possibilities
+
+    def subcommand_help(cmd)
+      desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
+      class_eval "
+        def help(command = nil, subcommand = true); super; end
+"
+    end
+    alias_method :subtask_help, :subcommand_help
+  end
+
+  include Foreman::Thor::Base
+
+  map HELP_MAPPINGS => :help
+
+  desc "help [COMMAND]", "Describe available commands or one specific command"
+  disable_class_options
+  def help(command = nil, subcommand = false)
+    if command
+      if self.class.subcommands.include? command
+        self.class.subcommand_classes[command].help(shell, true)
+      else
+        self.class.command_help(shell, command)
+      end
+    else
+      self.class.help(shell, subcommand)
+    end
+  end
+end