foreman_maintain 0.0.6 → 0.0.7

data/lib/foreman_maintain/reporter/cli_reporter.rb

@@ -4,12 +4,6 @@ require 'highline'
 module ForemanMaintain
   class Reporter
     class CLIReporter < Reporter
-      DECISION_MAPPER = {
-        %w[y yes] => :yes,
-        %w[n next no] => :no,
-        %w[q quit] => :quit
-      }.freeze
-
       # Simple spinner able to keep updating current line
       class Spinner
         def initialize(reporter, interval = 0.1)
@@ -87,7 +81,7 @@ module ForemanMaintain
       end
 
       def before_scenario_starts(scenario)
-        puts "\nRunning #{scenario.description || scenario.class}"
+        puts "Running #{scenario.description || scenario.class}"
         hline('=')
       end
 
@@ -147,33 +141,31 @@ module ForemanMaintain
       def after_execution_finishes(execution)
         puts_status(execution.status)
         puts(execution.output) unless execution.output.empty?
+        if execution.status == :already_run
+          puts(<<-MESSAGE.strip_heredoc)
+            The step was skipped as it was already run and it is marked
+            as run_once. Use --force to enforce the execution.
+          MESSAGE
+        end
         hline
         new_line_if_needed
       end
 
-      def after_scenario_finishes(_scenario); 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
+      def after_scenario_finishes(scenario)
+        scenario_failure_message(scenario)
+        puts "\n"
       end
 
       def clear_line
         print "\r" + ' ' * @max_length + "\r"
       end
 
-      private
-
       def assumeyes?
         @assumeyes
       end
 
       def single_step_decision(step)
-        answer = ask_decision("Continue with step [#{step.description}]?")
+        answer = ask_decision("Continue with step [#{step.runtime_message}]?")
         if answer == :yes
           step
         else
@@ -184,9 +176,9 @@ module ForemanMaintain
       def multiple_steps_decision(steps)
         puts 'There are multiple steps to proceed:'
         steps.each_with_index do |step, index|
-          puts "#{index + 1}) #{step.description}"
+          puts "#{index + 1}) #{step.runtime_message}"
         end
-        ask_to_select('Select step to continue', steps, &:description)
+        ask_to_select('Select step to continue', steps, &:runtime_message)
       end
 
       def ask_decision(message)
@@ -260,6 +252,7 @@ module ForemanMaintain
                     :fail => { :label => '[FAIL]', :color => :red },
                     :running => { :label => '[RUNNING]', :color => :blue },
                     :skipped => { :label => '[SKIPPED]', :color => :yellow },
+                    :already_run => { :label => '[ALREADY RUN]', :color => :yellow },
                     :warning => { :label => '[WARNING]', :color => :yellow } }
         properties = mapping[status]
         @hl.color(properties[:label], properties[:color], :bold)
@@ -272,6 +265,49 @@ module ForemanMaintain
       def record_last_line(string)
         @last_line = string.lines.to_a.last
       end
+
+      private
+
+      def scenario_failure_message(scenario)
+        return if scenario.passed?
+        message = []
+        message << <<-MESSAGE.strip_heredoc
+          Scenario [#{scenario.description}] failed.
+        MESSAGE
+        recommend = []
+        steps_with_error = scenario.steps_with_error(:whitelisted => false)
+        unless steps_with_error.empty?
+          message << <<-MESSAGE.strip_heredoc
+          The following steps ended up in failing state:
+
+          #{format_steps(steps_with_error, "\n", 2)}
+          MESSAGE
+          recommend << <<-MESSAGE.strip_heredoc
+          Resolve the failed steps and rerun
+          the command. In case the failures are false positives,
+          use --whitelist="#{steps_with_error.map(&:label_dashed).join(',')}"
+          MESSAGE
+        end
+
+        steps_with_warning = scenario.steps_with_warning(:whitelisted => false)
+        unless steps_with_warning.empty?
+          message << <<-MESSAGE.strip_heredoc
+          The following steps ended up in warning state:
+
+          #{format_steps(steps_with_warning, "\n", 2)}
+          MESSAGE
+
+          recommend << <<-MESSAGE.strip_heredoc
+          The steps in warning state itself might not mean there is an error,
+          but it should be reviews to ensure the behavior is expected
+          MESSAGE
+        end
+        puts((message + recommend).join("\n"))
+      end
+
+      def format_steps(steps, join_with = ', ', indent = 0)
+        steps.map { |s| "#{' ' * indent}[#{s.label_dashed}]" }.join(join_with)
+      end
     end
   end
 end

data/lib/foreman_maintain/runner.rb

@@ -1,48 +1,73 @@
 module ForemanMaintain
   # Class responsible for running the scenario
   class Runner
+    attr_reader :reporter, :exit_code
+
     require 'foreman_maintain/runner/execution'
+    require 'foreman_maintain/runner/stored_execution'
     def initialize(reporter, scenarios, options = {})
-      options.validate_options!(:assumeyes)
+      options.validate_options!(:assumeyes, :whitelist, :force)
       @assumeyes = options.fetch(:assumeyes, false)
+      @whitelist = options.fetch(:whitelist, [])
+      @force = options.fetch(:force, false)
       @reporter = reporter
       @scenarios = Array(scenarios)
-      @scenarios_with_dependencies = scenarios_with_dependencies
       @quit = false
+      @last_scenario = nil
+      @exit_code = 0
     end
 
-    def assumeyes?
-      @assumeyes
+    def quit?
+      @quit
     end
 
-    def scenarios_with_dependencies
-      @scenarios.map do |scenario|
-        scenario.before_scenarios + [scenario]
-      end.flatten
+    def assumeyes?
+      @assumeyes
     end
 
     def run
-      scenarios_with_dependencies.each do |scenario|
+      @scenarios.each do |scenario|
         run_scenario(scenario)
+        break if @quit
       end
     end
 
-    def run_scenario(scenario)
-      @steps_to_run = scenario.steps.dup
-      @steps_to_run = ForemanMaintain::DependencyGraph.sort(@steps_to_run)
-      @reporter.before_scenario_starts(scenario)
-      while !@quit && !@steps_to_run.empty?
-        step = @steps_to_run.shift
-        @reporter.puts('Rerunning the check after fix procedure') if rerun_check?(step)
-        execution = Execution.new(step, @reporter)
-        execution.run
-        ask_about_offered_steps(step)
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+    def run_scenario(scenario, confirm = true)
+      return if scenario.steps.empty?
+      raise 'The runner is already in quit state' if quit?
+      if confirm
+        confirm_scenario(scenario)
+        return if quit?
       end
+      scenario.before_scenarios.flatten.each { |before_scenario| run_scenario(before_scenario) }
+      return if quit? # the before scenarios caused the stop of the execution
+      @reporter.before_scenario_starts(scenario)
+      run_steps(scenario, scenario.steps)
       @reporter.after_scenario_finishes(scenario)
+    ensure
+      @last_scenario = scenario unless scenario.steps.empty?
+    end
+
+    def whitelisted_step?(step)
+      @whitelist.include?(step.label_dashed.to_s)
+    end
+
+    def confirm_scenario(scenario)
+      return unless @last_scenario
+      decision = if @last_scenario.steps_with_error(:whitelisted => false).any?
+                   :quit
+                 elsif @last_scenario.steps_with_warning(:whitelisted => false).any?
+                   reporter.ask_decision("Continue with [#{scenario.description}]")
+                 end
+
+      ask_to_quit if [:quit, :no].include?(decision)
+      decision
     end
 
-    def ask_to_quit(_step = nil)
+    def ask_to_quit(exit_code = 1)
       @quit = true
+      @exit_code = exit_code
     end
 
     def add_steps(*steps)
@@ -53,9 +78,42 @@ module ForemanMaintain
       end
     end
 
+    def storage
+      ForemanMaintain.storage(:default)
+    end
+
     private
 
-    # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+    def run_steps(scenario, steps)
+      @steps_to_run = ForemanMaintain::DependencyGraph.sort(steps)
+      while !@quit && !@steps_to_run.empty?
+        execution = run_step(@steps_to_run.shift)
+        post_step_decisions(scenario, execution)
+      end
+    end
+
+    def run_step(step)
+      @reporter.puts('Rerunning the check after fix procedure') if rerun_check?(step)
+      execution = Execution.new(step, @reporter,
+                                :whitelisted => whitelisted_step?(step),
+                                :storage => storage,
+                                :force => @force)
+      execution.run
+      execution
+    ensure
+      storage.save
+    end
+
+    def post_step_decisions(scenario, execution)
+      step = execution.step
+      next_steps_decision = ask_about_offered_steps(step)
+      if next_steps_decision != :yes &&
+         execution.fail? && !execution.whitelisted? &&
+         scenario.run_strategy == :fail_fast
+        ask_to_quit
+      end
+    end
+
     def ask_about_offered_steps(step)
       if assumeyes? && rerun_check?(step)
         @reporter.puts 'Check still failing after attempt to fix. Skipping'
@@ -72,6 +130,7 @@ module ForemanMaintain
           chosen_steps = [decision]
           chosen_steps << step if step.is_a?(Check)
           add_steps(*chosen_steps)
+          :yes
         end
       end
     end

data/lib/foreman_maintain/runner/execution.rb

@@ -4,7 +4,7 @@ module ForemanMaintain
     class Execution
       include Concerns::Logger
       extend Forwardable
-      def_delegators :@reporter, :with_spinner, :puts, :print, :ask, :assumeyes?
+      def_delegators :reporter, :with_spinner, :puts, :print, :ask, :assumeyes?
 
       # Step performed as part of the execution
       attr_reader :step
@@ -20,32 +20,57 @@ module ForemanMaintain
 
       attr_reader :reporter
 
-      def initialize(step, reporter)
+      def initialize(step, reporter, options = {})
+        options.validate_options!(:whitelisted, :storage, :force)
         @step = step
         @reporter = reporter
         @status = :pending
         @output = ''
+        @whitelisted = options[:whitelisted]
+        @storage = options[:storage]
+        @force = options[:force]
       end
 
       def name
         @step.description
       end
 
+      def whitelisted?
+        @whitelisted
+      end
+
       def success?
-        @status == :success
+        [:success, :already_run, :skipped].include?(@status)
       end
 
       def fail?
         @status == :fail
       end
 
+      def skipped?
+        @status == :skipped
+      end
+
+      def skip?
+        !@force && step.run_once? && step.executed? && step.success?
+      end
+
       def warning?
         @status == :warning
       end
 
+      # yaml storage to preserve key/value pairs between runs.
+      def storage
+        @storage || ForemanMaintain.storage(:default)
+      end
+
       def run
-        @status = :running
         @reporter.before_execution_starts(self)
+        if skip?
+          @status = :already_run
+          return
+        end
+        @status = :running
         with_metadata_calculation do
           capture_errors do
             step.__run__(self)

data/lib/foreman_maintain/runner/stored_execution.rb

@@ -0,0 +1,23 @@
+module ForemanMaintain
+  class Runner
+    # Class representing an execution of a single step in scenario
+    class StoredExecution < Execution
+      include Concerns::Logger
+      extend Forwardable
+
+      def initialize(step, hash)
+        @step = step
+        @status = hash[:status]
+        @output = hash[:output]
+      end
+
+      def reporter
+        raise 'Can not access reporter from stored execution'
+      end
+
+      def run
+        raise 'Can not run stored execution'
+      end
+    end
+  end
+end

data/lib/foreman_maintain/scenario.rb

@@ -2,33 +2,48 @@ module ForemanMaintain
   class Scenario
     include Concerns::Logger
     include Concerns::SystemHelpers
-    include Concerns::Metadata
+    include Concerns::ScenarioMetadata
     include Concerns::Finders
+    extend Concerns::Finders
 
     attr_reader :steps
 
     class FilteredScenario < Scenario
-      metadata { manual_detection }
+      metadata do
+        manual_detection
+        run_strategy :fail_slow
+      end
 
       attr_reader :filter_label, :filter_tags
 
-      def initialize(filter)
+      def initialize(filter, definition_kinds = [:check])
         @filter_tags = filter[:tags]
         @filter_label = filter[:label]
-        @steps = ForemanMaintain.available_checks(filter).map(&:ensure_instance)
+        @definition_kinds = definition_kinds
+        @steps = []
+        @steps += checks(filter) if definition_kinds.include?(:check)
+        @steps += procedures(filter) if definition_kinds.include?(:procedure)
         @steps = DependencyGraph.sort(@steps)
       end
 
-      def description
+      def runtime_message
         if @filter_label
-          "check with label [#{dashize(@filter_label)}]"
+          "#{kind_list} with label [#{dashize(@filter_label)}]"
         else
-          "checks with tags #{tag_string(@filter_tags)}"
+          "#{kinds_list} with tags #{tag_string(@filter_tags)}"
         end
       end
 
       private
 
+      def kinds_list
+        @definition_kinds.map { |kind| kind.to_s + 's' }.join(' and ')
+      end
+
+      def kind_list
+        @definition_kinds.map(&:to_s).join(' or ')
+      end
+
       def tag_string(tags)
         tags.map { |tag| dashize("[#{tag}]") }.join(' ')
       end
@@ -36,12 +51,21 @@ module ForemanMaintain
       def dashize(string)
         string.to_s.tr('_', '-')
       end
+
+      def checks(filter)
+        ForemanMaintain.available_checks(filter).map(&:ensure_instance)
+      end
+
+      def procedures(filter)
+        ForemanMaintain.available_procedures(filter).map(&:ensure_instance)
+      end
     end
 
     class PreparationScenario < Scenario
       metadata do
         manual_detection
         description 'preparation steps required to run the next scenarios'
+        run_strategy :fail_slow
       end
 
       attr_reader :main_scenario
@@ -71,6 +95,37 @@ module ForemanMaintain
       end.uniq
     end
 
+    def executed_steps
+      steps.find_all(&:executed?)
+    end
+
+    def steps_with_error(options = {})
+      filter_whitelisted(executed_steps.find_all(&:fail?), options)
+    end
+
+    def steps_with_warning(options = {})
+      filter_whitelisted(executed_steps.find_all(&:warning?), options)
+    end
+
+    def filter_whitelisted(steps, options)
+      options.validate_options!(:whitelisted)
+      if options.key?(:whitelisted)
+        steps.select do |step|
+          options[:whitelisted] ? step.whitelisted? : !step.whitelisted?
+        end
+      else
+        steps
+      end
+    end
+
+    def passed?
+      (steps_with_error(:whitelisted => false) + steps_with_warning(:whitelisted => false)).empty?
+    end
+
+    def failed?
+      !passed?
+    end
+
     # scenarios to be run before this scenario
     def before_scenarios
       scenarios = []
@@ -96,5 +151,33 @@ module ForemanMaintain
     def inspect
       "#{self.class.metadata[:description]}<#{self.class.name}>"
     end
+
+    def to_hash
+      { :label => label,
+        :steps => steps.map(&:to_hash) }
+    end
+
+    def self.new_from_hash(hash)
+      scenarios = find_scenarios(:label => hash[:label])
+      unless scenarios.size == 1
+        raise "Could not find scenario #{hash[:label]}, found #{scenarios.size} scenarios"
+      end
+      scenario = scenarios.first
+      scenario.load_step_states(hash[:steps])
+      scenario
+    end
+
+    def load_step_states(steps_hash)
+      steps = self.steps.dup
+      steps_hash.each do |step_hash|
+        until steps.empty?
+          step = steps.shift
+          if step.matches_hash?(step_hash)
+            step.update_from_hash(step_hash)
+            break
+          end
+        end
+      end
+    end
   end
 end