foreman_maintain 0.0.1

data/lib/foreman_maintain/config.rb

@@ -0,0 +1,17 @@
+module ForemanMaintain
+  class Config
+    attr_accessor :definitions_dirs, :log_level
+
+    def initialize(options = {})
+      @definitions_dirs = options.fetch(:definitions_dirs,
+                                        [File.join(source_path, 'definitions')])
+      @log_level = options.fetch(:log_level, ::Logger::ERROR)
+    end
+
+    private
+
+    def source_path
+      File.expand_path('../../..', __FILE__)
+    end
+  end
+end

data/lib/foreman_maintain/detector.rb

@@ -0,0 +1,146 @@
+module ForemanMaintain
+  class Detector
+    include Concerns::Logger
+
+    def initialize
+      refresh
+    end
+
+    # Returns instance of feature detected on system by label
+    def feature(label)
+      detect_feature(label)
+    end
+
+    def filter(collection, conditions)
+      if conditions
+        collection = collection.find_all { |object| match_object?(object, conditions) }
+      end
+      sort(collection)
+    end
+
+    def refresh
+      @features_by_label = {}
+      @available_features = []
+      @all_features_scanned = false
+      @available_checks = nil
+      @available_scenarios = nil
+    end
+
+    def available_features(filter_conditions = nil)
+      ensure_features_detected
+      filter(@available_features, filter_conditions)
+    end
+
+    def available_checks(filter_conditions = nil)
+      unless @available_checks
+        ensure_features_detected
+        @available_checks = find_present_objects(Check)
+      end
+      filter(@available_checks, filter_conditions)
+    end
+
+    def available_procedures(filter_conditions = nil)
+      unless @available_procedures
+        ensure_features_detected
+        @available_procedures = find_present_objects(Procedure)
+      end
+      filter(@available_procedures, filter_conditions)
+    end
+
+    def find_present_objects(object_base_class)
+      object_base_class.all_sub_classes.reduce([]) do |array, object_class|
+        feature_label = object_class.metadata[:for_feature]
+        object = object_class.new(feature_label && feature(feature_label))
+        array << object if object.present?
+        array
+      end
+    end
+
+    def available_scenarios(filter_conditions = nil)
+      unless @available_scenarios
+        ensure_features_detected
+        @available_scenarios = Scenario.all_sub_classes.select(&:autodetect?).
+                               map(&:new).select(&:present?)
+      end
+      filter(@available_scenarios, filter_conditions)
+    end
+
+    def ensure_features_detected
+      return if @all_features_scanned
+      @available_features = []
+      @features_by_label = {}
+      autodetect_features.keys.each do |label|
+        detect_feature(label)
+      end
+      @all_features_scanned = true
+    end
+
+    private
+
+    def sort(collection)
+      collection.sort_by { |item| item.label.to_s }
+    end
+
+    def match_object?(object, conditions)
+      conditions = normalize_filter_conditions(conditions)
+      return false if conditions[:label] && object.label != conditions[:label]
+      return false if conditions[:class] && object.class != conditions[:class]
+      conditions[:tags].all? { |tag| object.metadata[:tags].include?(tag) }
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def normalize_filter_conditions(conditions)
+      ret = conditions.is_a?(Hash) ? conditions.dup : {}
+      ret[:tags] = case conditions
+                   when Symbol
+                     [conditions]
+                   when Array
+                     conditions
+                   when Hash
+                     ret[:tags]
+                   end
+      ret[:tags] = Array(ret.fetch(:tags, []))
+      ret
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def detect_feature(label)
+      return @features_by_label[label] if @features_by_label.key?(label)
+      return unless autodetect_features.key?(label)
+      present_feature = autodetect_features[label].find(&:present?)
+      return unless present_feature
+      @available_features << present_feature
+      # we don't allow duplicities of features that are autodetected
+      add_feature_by_label(label, present_feature, false)
+      additional_features = present_feature.additional_features
+      @available_features.concat(additional_features)
+      additional_features.each do |feature|
+        # we allow duplicities if the feature is added via additional_features
+        add_feature_by_label(feature.metadata[:label], feature, true)
+      end
+    end
+
+    def autodetect_features
+      @autodetect_features ||= Feature.sub_classes.reduce({}) do |hash, feature_class|
+        hash.update(feature_class.metadata[:label] =>
+                      feature_class.all_sub_classes.select(&:autodetect?).reverse.map(&:new))
+      end
+    end
+
+    def add_feature_by_label(feature_label, feature, allow_duplicities)
+      if @features_by_label.key?(feature_label)
+        if allow_duplicities
+          unless @features_by_label[feature_label].is_a? Array
+            @features_by_label[feature_label] = Array(@features_by_label[feature_label])
+          end
+          @features_by_label[feature_label] << feature
+        else
+          raise "Double detection of feature with the same label #{feature_label}:" \
+                  "#{feature.inspect} vs. #{@features_by_label[feature_label].inspect}"
+        end
+      else
+        @features_by_label[feature_label] = feature
+      end
+    end
+  end
+end

data/lib/foreman_maintain/executable.rb

@@ -0,0 +1,44 @@
+module ForemanMaintain
+  class Executable
+    attr_accessor :associated_feature
+
+    def initialize(associated_feature)
+      @associated_feature = associated_feature
+    end
+
+    # public method to be overriden
+    def run
+      raise NotImplementedError
+    end
+
+    # override to offer steps to be executed after this one
+    def next_steps; end
+
+    def execution
+      if @_execution
+        @_execution
+      else
+        raise 'Trying to get execution information before the run started happened'
+      end
+    end
+
+    def success?
+      execution.success?
+    end
+
+    def fail?
+      execution.fail?
+    end
+
+    # update reporter about the current message
+    def say(message)
+      @_execution.update(message)
+    end
+
+    # internal method called by executor
+    def __run__(execution)
+      @_execution = execution
+      run
+    end
+  end
+end

data/lib/foreman_maintain/feature.rb

@@ -0,0 +1,22 @@
+module ForemanMaintain
+  class Feature
+    include Concerns::Logger
+    include Concerns::SystemHelpers
+    include Concerns::Metadata
+    include Concerns::Finders
+
+    def self.inspect
+      "Feature Class #{metadata[:label]}<#{name}>"
+    end
+
+    def inspect
+      "#{self.class.metadata[:label]}<#{self.class.name}>"
+    end
+
+    # Override to generate additional feature instances that can't be
+    # autodetected directly
+    def additional_features
+      []
+    end
+  end
+end

data/lib/foreman_maintain/logger.rb

@@ -0,0 +1,11 @@
+require 'logger'
+
+module ForemanMaintain
+  module Logger
+    def logger
+      @logger ||= ::Logger.new($stderr).tap do |logger|
+        logger.level = ForemanMaintain.config.log_level
+      end
+    end
+  end
+end

data/lib/foreman_maintain/procedure.rb

@@ -0,0 +1,8 @@
+module ForemanMaintain
+  class Procedure < Executable
+    include Concerns::Logger
+    include Concerns::SystemHelpers
+    include Concerns::Metadata
+    include Concerns::Finders
+  end
+end

data/lib/foreman_maintain/reporter.rb

@@ -0,0 +1,18 @@
+module ForemanMaintain
+  class Reporter
+    require 'foreman_maintain/reporter/cli_reporter'
+
+    # Each public method is a hook called by executor at the specific point
+    def before_scenario_starts(_scenario); end
+
+    def before_execution_starts(_execution); end
+
+    def on_execution_update(_execution, _update); end
+
+    def after_execution_finishes(_execution); end
+
+    def after_scenario_finishes(_scenario); end
+
+    def on_next_steps_offer(_runner, _steps); end
+  end
+end

data/lib/foreman_maintain/reporter/cli_reporter.rb

@@ -0,0 +1,177 @@
+require 'thread'
+require 'highline'
+
+module ForemanMaintain
+  class Reporter
+    class CLIReporter < Reporter
+      # Simple spinner able to keep updating current line
+      class Spinner
+        def initialize(reporter, interval = 0.1)
+          @reporter = reporter
+          @mutex = Mutex.new
+          @active = false
+          @interval = interval
+          @spinner_index = 0
+          @spinner_chars = %w(| / - \\)
+          @current_line = ''
+          @puts_needed = false
+          start_spinner
+        end
+
+        def update(line)
+          @mutex.synchronize { @current_line = line }
+        end
+
+        def activate
+          @mutex.synchronize { @active = true }
+          spin
+        end
+
+        def deactivate
+          @mutex.synchronize do
+            @active = false
+            @reporter.print "\r"
+          end
+        end
+
+        private
+
+        def start_spinner
+          @thread = Thread.new do
+            loop do
+              spin
+              sleep @interval
+            end
+          end
+        end
+
+        def spin
+          @mutex.synchronize do
+            return unless @active
+            @reporter.clear_line
+            @reporter.print "\r"
+            line = "#{@spinner_chars[@spinner_index]} #{@current_line}"
+            @reporter.print(line)
+            @spinner_index = (@spinner_index + 1) % @spinner_chars.size
+          end
+        end
+      end
+
+      def initialize(stdout = STDOUT, stdin = STDIN)
+        @stdout = stdout
+        @stdin = stdin
+        @hl = HighLine.new
+        @max_length = 80
+        @line_char = '-'
+        @cell_char = '|'
+        @spinner = Spinner.new(self)
+      end
+
+      def before_scenario_starts(scenario)
+        puts "Running #{scenario.description || scenario.class}"
+        hline
+      end
+
+      def before_execution_starts(execution)
+        @spinner.update(execution_info(execution, 'running'))
+        @spinner.activate
+      end
+
+      def on_execution_update(execution, update)
+        @spinner.update(execution_info(execution, update))
+      end
+
+      def after_execution_finishes(execution)
+        @spinner.deactivate
+        cell(execution_info(execution, status_label(execution, 11), @max_length - 15))
+        cell(execution.output) if execution.fail?
+        hline
+      end
+
+      def after_scenario_finishes(_scenario); end
+
+      def on_next_steps(runner, steps)
+        choice = if steps.size > 1
+                   multiple_steps_selection(steps)
+                 elsif ask_to_confirm("Continue with step [#{steps.first.description}]?")
+                   steps.first
+                 else
+                   :quit
+                 end
+        choice == :quit ? runner.ask_to_quit : runner.add_step(choice)
+      end
+
+      def multiple_steps_selection(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 ask_to_confirm(message)
+        print "#{message}, [yN]"
+        answer = @stdin.gets.chomp
+        case answer
+        when 'y'
+          true
+        when 'n'
+          false
+        end
+      ensure
+        clear_line
+      end
+
+      def ask_to_select(message, steps)
+        print "#{message}, (q) for quit"
+        answer = @stdin.gets.chomp
+        case answer
+        when 'q'
+          :quit
+        when /^\d+$/
+          steps[answer.to_i - 1]
+        end
+      ensure
+        clear_line
+      end
+
+      def clear_line
+        print "\r" + ' ' * @max_length + "\r"
+      end
+
+      def execution_info(execution, text, ljust = nil)
+        prefix = "#{execution.name}:"
+        prefix = prefix.ljust(ljust) if ljust
+        "#{prefix} #{text}"
+      end
+
+      def status_label(execution, ljust)
+        mapping = { :success => { :label => '[OK]', :color => :green },
+                    :fail => { :label => '[FAIL]', :color => :red },
+                    :running => { :label => '[RUNNING]', :color => :blue },
+                    :skipped => { :label => '[SKIPPED]', :color => :yellow } }
+        properties = mapping[execution.status]
+        @hl.color(properties[:label].ljust(ljust), properties[:color], :bold)
+      end
+
+      def hline
+        puts @line_char * @max_length
+      end
+
+      def cell(content)
+        print "#{@cell_char} #{content}".ljust(@max_length - 1)
+        puts @cell_char
+      end
+
+      def print(string)
+        @stdout.print(string)
+        @stdout.flush
+      end
+
+      def puts(string)
+        @stdout.puts(string)
+        @stdout.flush
+      end
+    end
+  end
+end