foreman_maintain 0.0.2 → 0.0.3

data/lib/foreman_maintain/concerns/system_helpers.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'csv'
-require 'English'
+require 'shellwords'
 
 module ForemanMaintain
   module Concerns
@@ -15,28 +15,27 @@ module ForemanMaintain
       class Version < Gem::Version
       end
 
-      class ExecutionError < StandardError
-        def initialize(command, input, output)
-          @command = command
-          @input = input
-          @output = output
-          super(generate_message)
-        end
+      def hostname
+        execute('hostname -f')
+      end
 
-        def generate_message
-          ret = "Could not execute #{command}"
-          ret << "with input '#{input}'" if input
-          ret << ":\n #{output}" if output && !output.empty?
-          ret
-        end
+      def file_exists?(filename)
+        File.exist?(filename)
       end
 
       def version(value)
         Version.new(value)
       end
 
+      def install_packages(packages, options = {})
+        options.validate_options!(:assumeyes)
+        yum_options = []
+        yum_options << '-y' if options[:assumeyes]
+        execute!("yum #{yum_options.join(' ')} install #{packages.join(' ')}", :interactive => true)
+      end
+
       def check_min_version(name, minimal_version)
-        current_version = rpm_version(name)
+        current_version = package_version(name)
         if current_version
           return current_version >= version(minimal_version)
         end
@@ -47,6 +46,11 @@ module ForemanMaintain
           (execute('rpm -q foreman') =~ /6sat.noarch/)
       end
 
+      def package_version(name)
+        # space for extension to support non-rpm distributions
+        rpm_version(name)
+      end
+
       def rpm_version(name)
         rpm_version = execute(%(rpm -q '#{name}' --queryformat="%{VERSION}"))
         if $CHILD_STATUS.success?
@@ -63,30 +67,30 @@ module ForemanMaintain
       end
 
       def execute?(command, input = nil)
-        execute(command, input)
+        execute(command, :stdin => input)
         $CHILD_STATUS.success?
       end
 
-      def execute!(command, input = nil)
-        output = execute(command, input)
-        if $CHILD_STATUS.success?
-          output
+      def execute!(command, options = {})
+        command_runner = Utils::CommandRunner.new(logger, command, options)
+        execution.puts '' if command_runner.interactive? && respond_to?(:execution)
+        command_runner.run
+        if command_runner.success?
+          command_runner.output
         else
-          raise ExecutionError.new(command, input, output)
+          raise command_runner.execution_error
         end
       end
 
-      def execute(command, stdin = nil)
-        logger.debug("Running command #{command.inspect} with stdin #{stdin.inspect}")
-        IO.popen("#{command} 2>&1", 'r+') do |f|
-          if stdin
-            f.puts(stdin)
-            f.close_write
-          end
-          output = f.read
-          logger.debug("output of the command:\n #{output}")
-          output.strip
-        end
+      def execute(command, options = {})
+        command_runner = Utils::CommandRunner.new(logger, command, options)
+        execution.puts '' if command_runner.interactive? && respond_to?(:execution)
+        command_runner.run
+        command_runner.output
+      end
+
+      def shellescape(string)
+        Shellwords.escape(string)
       end
     end
   end

data/lib/foreman_maintain/config.rb

@@ -1,17 +1,52 @@
+require 'fileutils'
 module ForemanMaintain
   class Config
-    attr_accessor :definitions_dirs, :log_level
+    attr_accessor :pre_setup_log_messages,
+                  :config_file, :definitions_dirs, :log_level, :log_dir, :storage_file
 
-    def initialize(options = {})
-      @definitions_dirs = options.fetch(:definitions_dirs,
-                                        [File.join(source_path, 'definitions')])
-      @log_level = options.fetch(:log_level, ::Logger::ERROR)
+    def initialize(options)
+      @pre_setup_log_messages = []
+      @config_file = options.fetch(:config_file, default_config_file)
+      @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_log_dir_path(@options.fetch(:log_dir, 'log'))
+      @storage_file = @options.fetch(:storage_file, 'data.yml')
     end
 
     private
 
+    def load_config
+      if File.exist?(config_file)
+        YAML.load(File.open(config_file)) || {}
+      else
+        @pre_setup_log_messages <<
+          "Config file #{config_file} not found, using default configuration"
+        {}
+      end
+    rescue => e
+      raise "Couldn't load configuration file. Error: #{e.message}"
+    end
+
+    def default_config_file
+      File.join(source_path, 'config/foreman_maintain.yml')
+    end
+
     def source_path
       File.expand_path('../../..', __FILE__)
     end
+
+    def find_log_dir_path(log_dir)
+      log_dir_path = File.expand_path(log_dir)
+      begin
+        FileUtils.mkdir_p(log_dir_path, :mode => 0o750) unless File.exist?(log_dir_path)
+      rescue => e
+        $stderr.puts "No permissions to create log dir #{log_dir}"
+        $stderr.puts e.message.inspect
+      end
+      log_dir_path
+    end
   end
 end

data/lib/foreman_maintain/core_ext.rb

@@ -0,0 +1,24 @@
+module ForemanMaintain
+  module CoreExt
+    module StripHeredoc
+      def strip_heredoc
+        indent = scan(/^[ \t]*(?=\S)/).min.size || 0
+        gsub(/^[ \t]{#{indent}}/, '')
+      end
+    end
+    String.send(:include, StripHeredoc)
+
+    module ValidateOptions
+      def validate_options!(*valid_keys)
+        valid_keys.flatten!
+        unexpected_options = keys - valid_keys - valid_keys.map(&:to_s)
+        unless unexpected_options.empty?
+          raise ArgumentError, "Unexpected options #{unexpected_options.inspect}. "\
+            "Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+        end
+        self
+      end
+    end
+    Hash.send(:include, ValidateOptions)
+  end
+end

data/lib/foreman_maintain/detector.rb

@@ -34,7 +34,7 @@ module ForemanMaintain
     def available_checks(filter_conditions = nil)
       unless @available_checks
         ensure_features_detected
-        @available_checks = find_present_objects(Check)
+        @available_checks = find_present_classes(Check)
       end
       filter(@available_checks, filter_conditions)
     end
@@ -42,16 +42,14 @@ module ForemanMaintain
     def available_procedures(filter_conditions = nil)
       unless @available_procedures
         ensure_features_detected
-        @available_procedures = find_present_objects(Procedure)
+        @available_procedures = find_present_classes(Procedure)
       end
       filter(@available_procedures, filter_conditions)
     end
 
-    def find_present_objects(object_base_class)
+    def find_present_classes(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 << object_class if object_class.present?
         array
       end
     end
@@ -60,7 +58,7 @@ module ForemanMaintain
       unless @available_scenarios
         ensure_features_detected
         @available_scenarios = Scenario.all_sub_classes.select(&:autodetect?).
-                               map(&:new).select(&:present?)
+                               select(&:present?).map(&:new)
       end
       filter(@available_scenarios, filter_conditions)
     end
@@ -84,11 +82,10 @@ module ForemanMaintain
     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]
+      return false if conditions[:class] && object != 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
@@ -107,8 +104,9 @@ module ForemanMaintain
     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
+      present_feature_class = autodetect_features[label].find(&:present?)
+      return unless present_feature_class
+      present_feature = present_feature_class.new
       @available_features << present_feature
       # we don't allow duplicities of features that are autodetected
       add_feature_by_label(label, present_feature, false)
@@ -116,14 +114,15 @@ module ForemanMaintain
       @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)
+        add_feature_by_label(feature.label, feature, true)
       end
+      present_feature
     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))
+                      feature_class.all_sub_classes.select(&:autodetect?).reverse)
       end
     end
 

data/lib/foreman_maintain/error.rb

@@ -0,0 +1,28 @@
+module ForemanMaintain
+  module Error
+    class Fail < StandardError
+    end
+
+    class Warn < StandardError
+    end
+
+    class ExecutionError < StandardError
+      attr_reader :command, :input, :output, :exit_status
+
+      def initialize(command, exit_status, input, output)
+        @command = command
+        @exit_status = exit_status
+        @input = input
+        @output = output
+        super(generate_message)
+      end
+
+      def generate_message
+        ret = "Failed executing #{command}, exit status #{exit_status}"
+        ret << "with input '#{input}'" if input
+        ret << ":\n #{output}" if output && !output.empty?
+        ret
+      end
+    end
+  end
+end

data/lib/foreman_maintain/executable.rb

@@ -1,9 +1,59 @@
 module ForemanMaintain
   class Executable
+    extend Forwardable
+    attr_reader :options
+    def_delegators :execution, :success?, :fail?, :output, :assumeyes?
+    def_delegators :execution, :puts, :print, :with_spinner, :ask
+
     attr_accessor :associated_feature
 
-    def initialize(associated_feature)
-      @associated_feature = associated_feature
+    def initialize(options = {})
+      @options = options.inject({}) { |h, (k, v)| h.update(k.to_s => v) }
+      @param_values = {}
+      setup_params
+      after_initialize
+    end
+
+    # To be able to call uniq on a set of steps to deduplicate the same steps
+    # inside the scenario
+    def eql?(other)
+      self.class.eql?(other.class) && options.eql?(other.options)
+    end
+
+    def hash
+      [self.class, options].hash
+    end
+
+    # public method to be overriden to perform after-initialization steps
+    def after_initialize; end
+
+    # processes the params from provided options
+    def setup_params
+      @options.validate_options!(params.values.map(&:name).map(&:to_s))
+      params.values.each do |param|
+        set_param_variable(param.name, param.process(@options[param.name.to_s]))
+      end
+    end
+
+    def set_param_variable(param_name, value)
+      @param_values[param_name] = value
+      if instance_variable_defined?("@#{param_name}")
+        raise "Instance variable @#{param_name} already set"
+      end
+      instance_variable_set("@#{param_name}", value)
+    end
+
+    def associated_feature
+      return @associated_feature if defined? @associated_feature
+      if metadata[:for_feature]
+        @associated_feature = feature(metadata[:for_feature])
+      end
+    end
+
+    # next steps to be offered to the user after the step is run
+    # It can be added for example from the assert method
+    def next_steps
+      @next_steps ||= []
     end
 
     # public method to be overriden
@@ -11,9 +61,6 @@ module ForemanMaintain
       raise NotImplementedError
     end
 
-    # override to offer steps to be executed after this one
-    def next_steps; end
-
     def execution
       if @_execution
         @_execution
@@ -22,23 +69,51 @@ module ForemanMaintain
       end
     end
 
-    def success?
-      execution.success?
+    # public method to be overriden: it can perform additional checks
+    # to say, if the step is actually necessary to run. For example an `InstallPackage`
+    # procedure would not be necessary when the package is already installed.
+    def necessary?
+      true
     end
 
-    def fail?
-      execution.fail?
+    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)
+      execution.update(message)
     end
 
     # internal method called by executor
     def __run__(execution)
-      @_execution = execution
+      setup_execution_state(execution)
       run
     end
+
+    # method defined both on object and class to ensure we work always with object
+    # even when the definitions provide us only class
+    def ensure_instance
+      self
+    end
+
+    # clean the execution-specific state to prepare for the next execution
+    # attempts
+    def setup_execution_state(execution)
+      @_execution = execution
+      @next_steps = []
+    end
+
+    class << self
+      def ensure_instance
+        new
+      end
+    end
   end
 end

data/lib/foreman_maintain/feature.rb

@@ -4,6 +4,7 @@ module ForemanMaintain
     include Concerns::SystemHelpers
     include Concerns::Metadata
     include Concerns::Finders
+    include ForemanMaintain::Concerns::Hammer
 
     def self.inspect
       "Feature Class #{metadata[:label]}<#{name}>"

data/lib/foreman_maintain/param.rb

@@ -0,0 +1,47 @@
+module ForemanMaintain
+  class Param
+    attr_reader :name, :description, :options
+    def initialize(name, description, options, &block)
+      options.validate_options!(:description, :required, :flag, :array)
+      @name = name
+      @description = description || options[:description] || ''
+      @options = options
+      @required = @options.fetch(:required, false)
+      @flag = @options.fetch(:flag, false)
+      @block = block
+      @array = @options.fetch(:array, false)
+    end
+
+    def flag?
+      @flag
+    end
+
+    def required?
+      @required
+    end
+
+    def array?
+      @array
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
+    def process(value)
+      value = process_array(value) if array?
+      value = @block.call(value) if @block
+      if value.nil? && required?
+        raise ArgumentError, "Param #{name} is required but no value given"
+      elsif flag?
+        value = value ? true : false
+      end
+      value
+    end
+
+    def process_array(value)
+      if value.is_a?(Array)
+        value
+      else
+        value.to_s.split(',').map(&:strip)
+      end
+    end
+  end
+end