foreman_maintain 0.0.2 → 0.0.3

data/definitions/procedures/sync_plans/enable.rb

@@ -0,0 +1,21 @@
+module Procedures::SyncPlans
+  class Enable < ForemanMaintain::Procedure
+    metadata do
+      for_feature :sync_plans
+      description 're-enable sync plans'
+    end
+
+    def run
+      enabled_sync_plans
+    end
+
+    private
+
+    def enabled_sync_plans
+      with_spinner('re-enabling sync plans') do |spinner|
+        record_ids = feature(:sync_plans).make_enable
+        spinner.update "Total #{record_ids.length} sync plans are now enabled."
+      end
+    end
+  end
+end

data/definitions/scenarios/pre_upgrade_check_foreman_1_14.rb

@@ -1,12 +1,13 @@
 class Scenarios::PreUpgradeCheckForeman_1_14 < ForemanMaintain::Scenario
-  description 'checks before upgrading to Foreman 1.14'
-  confine do
-    feature(:upstream)
+  metadata do
+    description 'checks before upgrading to Foreman 1.14'
+    tags :pre_upgrade_check
+    confine do
+      feature(:upstream)
+    end
   end
 
-  tags :pre_upgrade_check
-
   def compose
-    steps.concat(find_checks(:basic))
+    add_steps(find_checks(:default))
   end
 end

data/definitions/scenarios/pre_upgrade_check_satellite_6_0_z.rb

@@ -1,12 +1,14 @@
 class Scenarios::PreUpgradeCheckSatellite_6_0_z < ForemanMaintain::Scenario
-  tags :pre_upgrade_check, :satellite_6_0_z
-  description 'checks before upgrading to Satellite 6.0'
-  confine do
-    feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.0.')
+  metadata do
+    tags :pre_upgrade_check, :satellite_6_0_z
+    description 'checks before upgrading to Satellite 6.0'
+    confine do
+      feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.0.')
+    end
   end
 
   def compose
-    steps.concat(find_checks(:basic))
-    steps.concat(find_checks(:pre_upgrade))
+    add_steps(find_checks(:default))
+    add_steps(find_checks(:pre_upgrade))
   end
 end

data/definitions/scenarios/pre_upgrade_check_satellite_6_1.rb

@@ -1,12 +1,14 @@
 class Scenarios::PreUpgradeCheckSatellite_6_1 < ForemanMaintain::Scenario
-  tags :pre_upgrade_check, :satellite_6_1
-  description 'checks before upgrading to Satellite 6.1'
-  confine do
-    feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.0.')
+  metadata do
+    description 'checks before upgrading to Satellite 6.1'
+    tags :pre_upgrade_check, :satellite_6_1
+    confine do
+      feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.0.')
+    end
   end
 
   def compose
-    steps.concat(find_checks(:basic))
-    steps.concat(find_checks(:pre_upgrade))
+    add_steps(find_checks(:default))
+    add_steps(find_checks(:pre_upgrade))
   end
 end

data/definitions/scenarios/pre_upgrade_check_satellite_6_1_z.rb

@@ -1,12 +1,14 @@
 class Scenarios::PreUpgradeCheckSatellite_6_1_z < ForemanMaintain::Scenario
-  tags :pre_upgrade_check, :satellite_6_1_z
-  description 'checks before upgrading to Satellite 6.1.z'
-  confine do
-    feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.1.')
+  metadata do
+    description 'checks before upgrading to Satellite 6.1.z'
+    tags :pre_upgrade_check, :satellite_6_1_z
+    confine do
+      feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.1.')
+    end
   end
 
   def compose
-    steps.concat(find_checks(:basic))
-    steps.concat(find_checks(:pre_upgrade))
+    add_steps(find_checks(:default))
+    add_steps(find_checks(:pre_upgrade))
   end
 end

data/definitions/scenarios/pre_upgrade_check_satellite_6_2.rb

@@ -1,12 +1,14 @@
 class Scenarios::PreUpgradeCheckSatellite_6_2 < ForemanMaintain::Scenario
-  tags :pre_upgrade_check, :satellite_6_2
-  description 'checks before upgrading to Satellite 6.2'
-  confine do
-    feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.1.')
+  metadata do
+    description 'checks before upgrading to Satellite 6.2'
+    tags :pre_upgrade_check, :satellite_6_2
+    confine do
+      feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.1.')
+    end
   end
 
   def compose
-    steps.concat(find_checks(:basic))
-    steps.concat(find_checks(:pre_upgrade))
+    add_steps(find_checks(:default))
+    add_steps(find_checks(:pre_upgrade))
   end
 end

data/definitions/scenarios/pre_upgrade_check_satellite_6_2_z.rb

@@ -1,12 +1,14 @@
 class Scenarios::PreUpgradeCheckSatellite_6_2_z < ForemanMaintain::Scenario
-  tags :pre_upgrade_check, :satellite_6_2_z
-  description 'checks before upgrading to Satellite 6.2.z'
-  confine do
-    feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.2.')
+  metadata do
+    description 'checks before upgrading to Satellite 6.2.z'
+    tags :pre_upgrade_check, :satellite_6_2_z
+    confine do
+      feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.2.')
+    end
   end
 
   def compose
-    steps.concat(find_checks(:basic))
-    steps.concat(find_checks(:pre_upgrade))
+    add_steps(find_checks(:default))
+    add_steps(find_checks(:pre_upgrade))
   end
 end

data/definitions/scenarios/pre_upgrade_check_satellite_6_3.rb

@@ -1,12 +1,14 @@
 class Scenarios::PreUpgradeCheckSatellite_6_3 < ForemanMaintain::Scenario
-  tags :pre_upgrade_check, :satellite_6_3
-  description 'checks before upgrading to Satellite 6.3'
-  confine do
-    feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.2.')
+  metadata do
+    description 'checks before upgrading to Satellite 6.3'
+    tags :pre_upgrade_check, :satellite_6_3
+    confine do
+      feature(:downstream) && feature(:downstream).current_version.to_s.start_with?('6.2.')
+    end
   end
 
   def compose
-    steps.concat(find_checks(:basic))
-    steps.concat(find_checks(:pre_upgrade))
+    add_steps(find_checks(:default))
+    add_steps(find_checks(:pre_upgrade))
   end
 end

data/lib/foreman_maintain.rb

@@ -2,16 +2,23 @@ if RUBY_VERSION <= '1.8.7'
   require 'rubygems'
 end
 
+require 'forwardable'
 require 'json'
+require 'logger'
+require 'yaml'
 
 module ForemanMaintain
+  require 'foreman_maintain/core_ext'
   require 'foreman_maintain/concerns/logger'
+  require 'foreman_maintain/concerns/finders'
   require 'foreman_maintain/concerns/metadata'
   require 'foreman_maintain/concerns/system_helpers'
-  require 'foreman_maintain/concerns/finders'
+  require 'foreman_maintain/concerns/hammer'
   require 'foreman_maintain/top_level_modules'
+  require 'foreman_maintain/yaml_storage'
   require 'foreman_maintain/config'
   require 'foreman_maintain/detector'
+  require 'foreman_maintain/param'
   require 'foreman_maintain/feature'
   require 'foreman_maintain/executable'
   require 'foreman_maintain/check'
@@ -20,13 +27,29 @@ module ForemanMaintain
   require 'foreman_maintain/runner'
   require 'foreman_maintain/reporter'
   require 'foreman_maintain/utils'
+  require 'foreman_maintain/error'
 
   class << self
-    attr_accessor :config
+    attr_accessor :config, :logger
+
+    LOGGER_LEVEL_MAPPING = {
+      'debug' => ::Logger::DEBUG,
+      'info' => ::Logger::INFO,
+      'warn' => ::Logger::WARN,
+      'error' => ::Logger::ERROR,
+      'fatal' => ::Logger::FATAL,
+      'unknown' => ::Logger::UNKNOWN
+    }.freeze
 
-    def setup(configuration = {})
-      self.config = Config.new(configuration)
+    def setup(options = {})
+      # using a queue, we can log the messages which are generated before initializing logger
+      self.config = Config.new(options)
       load_definitions
+      init_logger
+    end
+
+    def config_file
+      config.config_file
     end
 
     def load_definitions
@@ -34,7 +57,8 @@ module ForemanMaintain
       # between the definitions directories
       $LOAD_PATH.concat(config.definitions_dirs)
       config.definitions_dirs.each do |definitions_dir|
-        Dir.glob(File.join(definitions_dir, '**', '*.rb')).each { |f| require f }
+        file_paths = File.expand_path(File.join(definitions_dir, '**', '*.rb'))
+        Dir.glob(file_paths).each { |f| require f }
       end
     end
 
@@ -57,5 +81,28 @@ module ForemanMaintain
     def available_procedures(*args)
       detector.available_procedures(*args)
     end
+
+    def init_logger
+      # Note - If timestamp added to filename then number of log files i.e second
+      # argument to Logger.new will not work as expected
+      filename = File.expand_path("#{config.log_dir}/foreman-maintain.log")
+      @logger = Logger.new(filename, 10, 10_240_000).tap do |logger|
+        logger.level = LOGGER_LEVEL_MAPPING[config.log_level] || Logger::DEBUG
+        logger.datetime_format = '%Y-%m-%d %H:%M:%S%z '
+      end
+      pickup_log_messages
+    end
+
+    def pickup_log_messages
+      return if config.pre_setup_log_messages.empty?
+      config.pre_setup_log_messages.each { |msg| logger.info msg }
+      config.pre_setup_log_messages.clear
+    end
+
+    def storage(label)
+      ForemanMaintain::YamlStorage.load(label)
+    rescue => e
+      logger.error "Invalid Storage label i.e #{label}. Error - #{e.message}"
+    end
   end
 end

data/lib/foreman_maintain/check.rb

@@ -7,15 +7,20 @@ module ForemanMaintain
 
     attr_accessor :associated_feature
 
-    class Fail < StandardError
-    end
-
-    def initialize(associated_feature)
-      @associated_feature = associated_feature
-    end
-
-    def assert(condition, error_message)
-      raise Fail, error_message unless condition
+    # run condition and mark the check as failed when not passing
+    #
+    # ==== Options
+    #
+    # * +:next_steps* - one or more procedures that can be followed to address
+    #                   the failure, will be offered to the user when running
+    #                   in interactive mode
+    def assert(condition, error_message, options = {})
+      options = options.validate_options!(:next_steps)
+      unless condition
+        next_steps = Array(options.fetch(:next_steps, []))
+        self.next_steps.concat(next_steps)
+        raise Error::Fail, error_message
+      end
     end
 
     # public method to be overriden
@@ -26,9 +31,10 @@ module ForemanMaintain
     # internal method called by executor
     def __run__(execution)
       super
-    rescue Fail => e
-      execution.status = :fail
-      execution.output << e.message
+    rescue Error::Fail => e
+      fail!(e.message)
+    rescue Error::Warn => e
+      warn!(e.message)
     end
   end
 end

data/lib/foreman_maintain/cli/base.rb

@@ -20,11 +20,13 @@ module ForemanMaintain
       end
 
       def reporter
-        @reporter ||= ForemanMaintain::Reporter::CLIReporter.new
+        @reporter ||= ForemanMaintain::Reporter::CLIReporter.new(STDOUT,
+                                                                 STDIN,
+                                                                 :assumeyes => assumeyes?)
       end
 
       def run_scenario(scenario)
-        ForemanMaintain::Runner.new(reporter, scenario).run
+        ForemanMaintain::Runner.new(reporter, scenario, :assumeyes => assumeyes?).run
       end
 
       def available_checks
@@ -54,6 +56,11 @@ module ForemanMaintain
           tags.split(',').map(&:strip).map { |tag| underscorize(tag).to_sym }
         end
       end
+
+      def self.interactive_option
+        option ['-y', '--assumeyes'], :flag,
+               'Automatically answer yes for all questions'
+      end
     end
   end
 end

data/lib/foreman_maintain/cli/health_command.rb

@@ -30,6 +30,7 @@ module ForemanMaintain
       subcommand 'check', 'Run the health checks against the system' do
         label_option
         tags_option
+        interactive_option
 
         def execute
           scenario = Scenario::FilteredScenario.new(filter)
@@ -45,7 +46,7 @@ module ForemanMaintain
           if label
             { :label => label }
           else
-            { :tags => tags || [:basic] }
+            { :tags => tags || [:default] }
           end
         end
 

data/lib/foreman_maintain/cli/upgrade_command.rb

@@ -40,6 +40,8 @@ module ForemanMaintain
 
       subcommand 'check', 'Run pre-upgrade checks for upgradeing to specified version' do
         parameter 'TARGET_VERSION', 'Target version of the upgrade', :required => false
+        interactive_option
+
         def execute
           versions_to_scenarios = available_target_versions(:pre_upgrade_check)
           scenario = versions_to_scenarios[target_version]

data/lib/foreman_maintain/concerns/hammer.rb

@@ -0,0 +1,20 @@
+module ForemanMaintain
+  module Concerns
+    module Hammer
+      def self.included(base)
+        base.metadata do
+          preparation_steps { Procedures::HammerSetup.new }
+        end
+      end
+
+      # Run a hammer command, examples:
+      # hammer('host list')
+      def hammer(args)
+        Utils::Hammer.instance.run_command(args)
+      end
+
+      # TODO: method for specifying that the check that includes this method
+      # requires hammer to be setup
+    end
+  end
+end

data/lib/foreman_maintain/concerns/logger.rb

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

data/lib/foreman_maintain/concerns/metadata.rb

@@ -1,21 +1,61 @@
 module ForemanMaintain
   module Concerns
     module Metadata
-      module DSL
+      # limit of steps dependent on each other, to avoid endless recursion
+      MAX_PREPARATION_STEPS_DEPTH = 20
+
+      class << self
+        # modules not to be included in autogenerated labels
+        attr_accessor :top_level_modules
+      end
+
+      class DSL
+        attr_reader :data
+
+        def initialize(data = {})
+          @data = data
+        end
+
         def label(label)
-          metadata[:label] = label
+          @data[:label] = label
         end
 
         def tags(*tags)
-          metadata[:tags].concat(tags)
+          @data[:tags].concat(tags)
         end
 
         def description(description)
-          metadata[:description] = description
+          @data[:description] = description
         end
 
         def confine(&block)
-          metadata[:confine_blocks] << block
+          @data[:confine_blocks] << block
+        end
+
+        # Parametrize the definition.
+        #
+        # == Arguments
+        #
+        #  +name+: Name (Symbol) of the attribute
+        #  +description_or_options+: Description string or a Hash with options
+        #  +options+: Hash with options (unless specified in +descriptions_or_options+)
+        #  +&block+: block to be called when processing the data: can be used for validation
+        #     and type-casing of the value: expected to return the value to be used
+        #
+        # == Options
+        #
+        #  +:description+: String describing the parameter
+        #  +:required+: true if required
+        #  +:flag+: param is just a true/false value: not expecting other values
+        #
+        def param(name, descripiton_or_options = {}, options = {}, &block)
+          case descripiton_or_options
+          when String
+            description = descripiton_or_options
+          when Hash
+            options = options.merge(descripiton_or_options) if descripiton_or_options.is_a?(Hash)
+          end
+          @data[:params][name] = Param.new(name, description, options, &block)
         end
 
         # Mark the class as manual: this means the instance
@@ -24,23 +64,33 @@ module ForemanMaintain
         # The classes marked for manual detect need to be initialized
         # in from other places (such as `additional_features` in Feature)
         def manual_detection
-          @autodetect = false
+          @data[:autodetect] = false
         end
 
-        def autodetect?
-          defined?(@autodetect) ? @autodetect : true
+        # in the block, define one or more preparation steps needed
+        # before executing this definition
+        def preparation_steps(&block)
+          @data[:preparation_steps_blocks] << block
         end
 
         # Specify what feature the definition related to.
         def for_feature(feature_label)
-          metadata[:for_feature] = feature_label
+          @data[:for_feature] = feature_label
           confine do
             feature(feature_label)
           end
         end
+
+        def self.eval_dsl(metadata, &block)
+          new(metadata).tap do |dsl|
+            dsl.instance_eval(&block)
+          end.data
+        end
       end
 
       module ClassMethods
+        include Finders
+
         def inherited(klass)
           sub_classes << klass
         end
@@ -56,6 +106,10 @@ module ForemanMaintain
           @sub_classes ||= []
         end
 
+        def autodetect?
+          metadata.fetch(:autodetect, true)
+        end
+
         def all_sub_classes(ignore_abstract_classes = true)
           ret = []
           ret << self if !ignore_abstract_classes || !abstract_class
@@ -65,22 +119,87 @@ module ForemanMaintain
           ret
         end
 
-        def metadata
+        def metadata(&block)
           @metadata ||= initialize_metadata
+          if block
+            DSL.eval_dsl(@metadata, &block)
+          end
+          @metadata
+        end
+
+        def label
+          metadata[:label] || generate_label
+        end
+
+        def description
+          metadata[:description] || to_s
+        end
+
+        def tags
+          metadata[:tags]
+        end
+
+        def params
+          metadata[:params] || []
         end
 
         def initialize_metadata
           { :tags => [],
-            :confine_blocks => [] }.tap do |metadata|
+            :confine_blocks => [],
+            :params => {},
+            :preparation_steps_blocks => [] }.tap do |metadata|
             if superclass.respond_to?(:metadata)
               metadata[:label] = superclass.metadata[:label]
             end
           end
         end
+
+        def present?
+          evaluate_confines
+        end
+
+        def preparation_steps(recursion_depth = 0, trace = [])
+          raise "Too many dependent steps #{trace}" if recursion_depth > MAX_PREPARATION_STEPS_DEPTH
+          return @preparation_steps if defined?(@preparation_steps)
+          preparation_steps = metadata[:preparation_steps_blocks].map(&:call)
+          preparation_steps.each { |step| raise ArgumentError unless step.is_a?(Executable) }
+          all_preparation_steps = []
+          preparation_steps.each do |step|
+            all_preparation_steps.concat(
+              step.preparation_steps(recursion_depth + 1, trace + [step])
+            )
+            all_preparation_steps << step
+          end
+          @preparation_steps = all_preparation_steps
+        end
+
+        private
+
+        def evaluate_confines
+          raise 'Recursive confine block call detected' if @confines_evaluation_in_progress
+          @confines_evaluation_in_progress = true
+          metadata[:confine_blocks].all? do |block|
+            instance_exec(&block)
+          end
+        ensure
+          @confines_evaluation_in_progress = false
+        end
+
+        def generate_label
+          label_parts = []
+          name.split('::').reduce(Object) do |parent_constant, name|
+            constant = parent_constant.const_get(name)
+            unless Metadata.top_level_modules.include?(constant)
+              # CamelCase -> camel_case
+              label_parts << name.split(/(?=[A-Z])/).map(&:downcase)
+            end
+            constant
+          end
+          label_parts.join('_').to_sym
+        end
       end
 
       def self.included(klass)
-        klass.extend(DSL)
         klass.extend(ClassMethods)
       end
 
@@ -89,35 +208,23 @@ module ForemanMaintain
       end
 
       def label
-        metadata[:label] || generate_label
+        self.class.label
       end
 
       def description
-        metadata[:description] || to_s
+        self.class.description
       end
 
       def tags
-        metadata[:tags]
-      end
-
-      def present?
-        @_present ||= evaluate_confines
+        self.class.tags
       end
 
-      private
-
-      def evaluate_confines
-        raise 'Recursive dependency in confine blocks detected' if @confines_evaluation_in_progress
-        @confines_evaluation_in_progress = true
-        metadata[:confine_blocks].all? do |block|
-          instance_exec(&block)
-        end
-      ensure
-        @confines_evaluation_in_progress = false
+      def params
+        self.class.params
       end
 
-      def generate_label
-        self.class.name.split('::').last.split(/(?=[A-Z])/).map(&:downcase).join('_').to_sym
+      def preparation_steps(*args)
+        self.class.preparation_steps(*args)
       end
     end
   end