foreman_maintain 0.0.6 → 0.0.7

data/lib/foreman_maintain/config.rb

@@ -2,8 +2,8 @@ require 'fileutils'
 module ForemanMaintain
   class Config
     attr_accessor :pre_setup_log_messages,
-                  :config_file, :definitions_dirs, :log_level, :log_dir, :storage_file,
-                  :backup_dir
+                  :config_file, :definitions_dirs, :log_level, :log_dir, :log_file_size,
+                  :storage_file, :backup_dir, :foreman_proxy_cert_path
 
     def initialize(options)
       @pre_setup_log_messages = []
@@ -11,17 +11,22 @@ module ForemanMaintain
       @options = load_config
       @definitions_dirs = @options.fetch(:definitions_dirs,
                                          [File.join(source_path, 'definitions')])
-
-      @log_level = @options.fetch(:log_level, ::Logger::DEBUG)
-      @log_dir = find_dir_path(@options.fetch(:log_dir, 'log'))
+      load_log_configs
       @storage_file = @options.fetch(:storage_file, 'data.yml')
       @backup_dir = find_dir_path(
         @options.fetch(:backup_dir, '/var/lib/foreman-maintain')
       )
+      @foreman_proxy_cert_path = @options.fetch(:foreman_proxy_cert_path, '/etc/foreman')
     end
 
     private
 
+    def load_log_configs
+      @log_level = @options.fetch(:log_level, ::Logger::DEBUG)
+      @log_dir = find_dir_path(@options.fetch(:log_dir, 'log'))
+      @log_file_size = @options.fetch(:log_file_size, 10_000)
+    end
+
     def load_config
       if File.exist?(config_file)
         YAML.load(File.open(config_file)) || {}

data/lib/foreman_maintain/core_ext.rb

@@ -2,7 +2,11 @@ module ForemanMaintain
   module CoreExt
     module StripHeredoc
       def strip_heredoc
-        indent = scan(/^[ \t]*(?=\S)/).min.size || 0
+        indent = 0
+        indented_lines = scan(/^[ \t]+(?=\S)/)
+        unless indented_lines.empty?
+          indent = indented_lines.min.size
+        end
         gsub(/^[ \t]{#{indent}}/, '')
       end
     end

data/lib/foreman_maintain/csv_parser.rb

@@ -0,0 +1,81 @@
+module ForemanMaintain
+  class CSVParser
+    def initialize
+      reset_parser
+    end
+
+    def parse(data)
+      return [] if data.nil?
+      reset_parser
+      data.each_char do |char|
+        handle_escape(char) || handle_quoting(char) || handle_comma(char) || add_to_buffer(char)
+      end
+      unless @last_quote.nil?
+        raise(ArgumentError, format('Illegal quoting in %s', @raw_buffer))
+      end
+      clean_buffer
+      @value
+    end
+
+    private
+
+    def handle_comma(char)
+      if char == ','
+        clean_buffer
+        true
+      else
+        false
+      end
+    end
+
+    def handle_quoting(char)
+      if @last_quote.nil? && ["'", '"'].include?(char)
+        @last_quote = char
+        @raw_buffer += char
+        true
+      elsif @last_quote == char
+        @last_quote = nil
+        @raw_buffer += char
+        true
+      elsif @last_quote
+        add_to_buffer(char)
+        true
+      else
+        false
+      end
+    end
+
+    def handle_escape(char)
+      if @escape
+        add_to_buffer(char)
+        @escape = false
+        true
+      elsif char == '\\'
+        @escape = true
+        @raw_buffer += char
+        true
+      else
+        false
+      end
+    end
+
+    def add_to_buffer(char)
+      @buffer += char
+      @raw_buffer += char
+    end
+
+    def reset_parser
+      @value = []
+      @buffer = ''
+      @raw_buffer = ''
+      @escape = false
+      @last_quote = nil
+    end
+
+    def clean_buffer
+      @value << @buffer
+      @raw_buffer = ''
+      @buffer = ''
+    end
+  end
+end

data/lib/foreman_maintain/dependency_graph.rb

@@ -13,24 +13,18 @@ module ForemanMaintain
     def initialize(collection)
       @graph = Hash.new([])
       @collection = collection
-      @labels = extract_labels
+      @steps_by_labels = @collection.group_by(&:label)
       generate_label_graph
-      convert_label_graph_to_object_graph
     end
 
     def add_to_graph(key, dependencies = [])
       return unless key
 
-      dependencies = dependencies.map do |dep|
-        next unless labels.include?(dep)
-        dep
-      end.compact
-
       graph[key] = dependencies
     end
 
     def tsort_each_node(&block)
-      graph.each_key(&block)
+      @collection.each(&block)
     end
 
     def tsort_each_child(node, &block)
@@ -39,51 +33,19 @@ module ForemanMaintain
 
     private
 
-    def cache
-      ForemanMaintain.cache
-    end
-
-    def convert_label_graph_to_object_graph
-      graph.keys.each do |key|
-        graph[cache.fetch(key)] = graph[key].map { |dep| cache.fetch(dep) }
-        graph.delete(key)
-      end
-
-      graph
-    end
-
-    def extract_labels
-      collection.map(&:label)
-    end
-
-    def find_class(dep)
-      case dep
-      when Class
-        dep
-      when String
-        if dep.include?('::')
-          dep.split('::').reduce(Object) { |o, e| o.const_get(e) }
-        else
-          cache.fetch(dep)
-        end
-      else
-        cache.fetch(dep)
-      end
-    end
-
     def generate_label_graph
       collection.each do |object|
-        klass = object.class
-        key = object.label
-
-        add_to_graph(klass.before.first, [key])
-        add_to_graph(key, klass.after)
-        map_label_to_object(object)
+        klass = object.is_a?(Class) ? object : object.class
+        klass.before.each do |label|
+          add_to_graph(labels_to_objects(label).first, [object])
+        end
+        add_to_graph(object, labels_to_objects(klass.after))
       end
     end
 
-    def map_label_to_object(object)
-      cache.fetch(object.label, object)
+    def labels_to_objects(labels)
+      labels = Array(labels)
+      labels.map { |label| @steps_by_labels[label] }.compact.flatten
     end
   end
 end

data/lib/foreman_maintain/error.rb

@@ -34,5 +34,9 @@ module ForemanMaintain
         ret
       end
     end
+
+    # Error caused by incorrect usage, usually connected to passed CLI options
+    class UsageError < StandardError
+    end
   end
 end

data/lib/foreman_maintain/executable.rb

@@ -1,9 +1,12 @@
 module ForemanMaintain
   class Executable
     extend Forwardable
+    extend Concerns::Finders
     attr_reader :options
-    def_delegators :execution, :success?, :fail?, :output, :assumeyes?
-    def_delegators :execution, :puts, :print, :with_spinner, :ask
+    def_delegators :execution,
+                   :success?, :skipped?, :fail?, :warning?, :output,
+                   :assumeyes?, :whitelisted?,
+                   :execution, :puts, :print, :with_spinner, :ask, :storage
 
     attr_accessor :associated_feature
 
@@ -56,11 +59,41 @@ module ForemanMaintain
       @next_steps ||= []
     end
 
+    # make the step to fail: the failure is considered significant and
+    # the next steps should not continue. The specific behaviour depends
+    # on the scenario it's being used on. In check-sets scenario, the next
+    # steps of the same scenario might continue, while the following scenarios
+    # would be aborted.
+    def fail!(message)
+      raise Error::Fail, message
+    end
+
+    # make the step a warning: this doesn't indicate the whole scenario should
+    # not continue, but the user will be warned before proceeding
+    def warn!(message)
+      raise Error::Warn, message
+    end
+
+    # rubocop:disable Style/AccessorMethodName
+    def set_fail(message)
+      execution.status = :fail
+      execution.output << message
+    end
+
+    def set_warn(message)
+      execution.status = :warning
+      execution.output << message
+    end
+
     # public method to be overriden
     def run
       raise NotImplementedError
     end
 
+    def executed?
+      @_execution ? true : false
+    end
+
     def execution
       if @_execution
         @_execution
@@ -70,22 +103,12 @@ module ForemanMaintain
     end
 
     # public method to be overriden: it can perform additional checks
-    # to say, if the step is actually necessary to run. For example an `InstallPackage`
+    # to say, if the step is actually necessary to run. For example an `Packages::Install`
     # procedure would not be necessary when the package is already installed.
     def necessary?
       true
     end
 
-    def fail!(message)
-      execution.status = :fail
-      execution.output << message
-    end
-
-    def warn!(message)
-      execution.status = :warning
-      execution.output << message
-    end
-
     # update reporter about the current message
     def say(message)
       execution.update(message)
@@ -110,6 +133,34 @@ module ForemanMaintain
       @next_steps = []
     end
 
+    # serialization methods
+    def to_hash
+      ret = { :label => label, :param_values => @param_values }
+      if @_execution
+        ret[:status] = @_execution.status
+        ret[:output] = @_execution.output
+      end
+      ret
+    end
+
+    def matches_hash?(hash)
+      label == hash[:label] && @param_values == hash[:param_values]
+    end
+
+    def update_from_hash(hash)
+      raise "The step is not matching the hash #{hash.inspect}" unless matches_hash?(hash)
+      raise "Can't update step that was already executed" if @_execution
+      @_execution = Runner::StoredExecution.new(self, :status => hash[:status],
+                                                      :output => hash[:output])
+    end
+
+    def inspect
+      ret = "#{self.class.name} label:#{label}"
+      ret << " params: #{@param_values.inspect}" unless @param_values.empty?
+      ret << " status: #{execution.status}" if executed?
+      ret
+    end
+
     class << self
       def ensure_instance
         new

data/lib/foreman_maintain/param.rb

@@ -1,6 +1,7 @@
 module ForemanMaintain
   class Param
     attr_reader :name, :description, :options
+
     def initialize(name, description, options, &block)
       options.validate_options!(:description, :required, :flag, :array)
       @name = name

data/lib/foreman_maintain/reporter.rb

@@ -7,8 +7,14 @@ module ForemanMaintain
     end
     require 'foreman_maintain/reporter/cli_reporter'
 
+    DECISION_MAPPER = {
+      %w[y yes] => :yes,
+      %w[n next no] => :no,
+      %w[q quit] => :quit
+    }.freeze
+
     # Each public method is a hook called by executor at the specific point
-    def before_scenario_starts(_scenario); end
+    def before_scenario_starts(_scenario, _last_scenario = nil); end
 
     def before_execution_starts(_execution); end
 
@@ -16,7 +22,14 @@ module ForemanMaintain
 
     def after_scenario_finishes(_scenario); end
 
-    def on_next_steps(_steps); end
+    def on_next_steps(steps)
+      return if steps.empty?
+      if steps.size > 1
+        multiple_steps_decision(steps)
+      else
+        single_step_decision(steps.first)
+      end
+    end
 
     def with_spinner(_message, &_block)
       yield DummySpinner.new
@@ -29,7 +42,75 @@ module ForemanMaintain
     def ask(_message); end
 
     def assumeyes?
-      false
+      @assumeyes
+    end
+
+    # simple yes/no question, returns :yes, :no or :quit
+    def ask_decision(message, options = {})
+      options.validate_options!(:assumeyes)
+      assumeyes = options.fetch(:assumeyes, assumeyes?)
+      if assumeyes
+        print("#{message} (assuming yes)")
+        return :yes
+      end
+      until_valid_decision do
+        filter_decision(ask("#{message}, [y(yes), n(no), q(quit)]"))
+      end
+    end
+
+    private
+
+    def single_step_decision(step)
+      answer = ask_decision("Continue with step [#{step.description}]?")
+      if answer == :yes
+        step
+      else
+        answer
+      end
+    end
+
+    def multiple_steps_decision(steps)
+      puts 'There are multiple steps to proceed:'
+      steps.each_with_index do |step, index|
+        puts "#{index + 1}) #{step.description}"
+      end
+      ask_to_select('Select step to continue', steps, &:description)
+    end
+
+    def filter_decision(answer)
+      decision = nil
+      DECISION_MAPPER.each do |options, decision_label|
+        decision = decision_label if options.include?(answer)
+      end
+      decision
+    end
+
+    # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+    def ask_to_select(message, steps)
+      if assumeyes?
+        puts('(assuming first option)')
+        return steps.first
+      end
+      until_valid_decision do
+        answer = ask("#{message}, [n(next), q(quit)]")
+        if answer =~ /^\d+$/ && (answer.to_i - 1) < steps.size
+          steps[answer.to_i - 1]
+        else
+          decision = filter_decision(answer)
+          if decision == :yes
+            steps.first
+          else
+            decision
+          end
+        end
+      end
+    end
+
+    # loop over the block until it returns some non-false value
+    def until_valid_decision
+      decision = nil
+      decision = yield until decision
+      decision
     end
   end
 end