foreman_maintain 0.0.1

data/lib/foreman_maintain/check.rb

@@ -0,0 +1,34 @@
+module ForemanMaintain
+  class Check < Executable
+    include Concerns::Logger
+    include Concerns::SystemHelpers
+    include Concerns::Metadata
+    include Concerns::Finders
+
+    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
+    end
+
+    # public method to be overriden
+    def run
+      raise NotImplementedError
+    end
+
+    # internal method called by executor
+    def __run__(execution)
+      super
+    rescue Fail => e
+      execution.status = :fail
+      execution.output << e.message
+    end
+  end
+end

data/lib/foreman_maintain/cli.rb

@@ -0,0 +1,14 @@
+require 'clamp'
+require 'highline'
+require 'foreman_maintain/cli/base'
+require 'foreman_maintain/cli/health_command'
+require 'foreman_maintain/cli/upgrade_command'
+
+module ForemanMaintain
+  module Cli
+    class MainCommand < Base
+      subcommand 'health', 'Health related commands', HealthCommand
+      subcommand 'upgrade', 'Upgrade related commands', UpgradeCommand
+    end
+  end
+end

data/lib/foreman_maintain/cli/base.rb

@@ -0,0 +1,47 @@
+module ForemanMaintain
+  module Cli
+    class Base < Clamp::Command
+      include Concerns::Finders
+
+      def dashize(string)
+        string.to_s.tr('_', '-')
+      end
+
+      def underscorize(string)
+        string.to_s.tr('-', '_')
+      end
+
+      def label_string(string)
+        HighLine.color("[#{dashize(string)}]", :yellow)
+      end
+
+      def tag_string(string)
+        HighLine.color("[#{dashize(string)}]", :cyan)
+      end
+
+      def reporter
+        @reporter ||= ForemanMaintain::Reporter::CLIReporter.new
+      end
+
+      def run_scenario(scenario)
+        ForemanMaintain::Runner.new(reporter, scenario).run
+      end
+
+      def available_checks
+        filter = {}
+        filter[:tags] = tags if respond_to?(:tags)
+        ForemanMaintain.available_checks(filter)
+      end
+
+      def available_tags(collection)
+        collection.inject([]) { |array, check| array.concat(check.tags).uniq }.sort_by(&:to_s)
+      end
+
+      def self.tags_option
+        option '--tags', 'tags', 'Limit only for specific set of tags' do |tags|
+          tags.split(',').map(&:strip).map { |tag| underscorize(tag).to_sym }
+        end
+      end
+    end
+  end
+end

data/lib/foreman_maintain/cli/health_command.rb

@@ -0,0 +1,39 @@
+module ForemanMaintain
+  module Cli
+    class HealthCommand < Base
+      subcommand 'list-checks', 'List the checks based on criteria' do
+        tags_option
+
+        def execute
+          available_checks.each { |check| print_check_info(check) }
+        end
+
+        def print_check_info(check)
+          desc = "#{label_string(check.label)} #{check.description}".ljust(80)
+          tags = check.tags.map { |t| tag_string(t) }.join(' ').to_s
+          puts "#{desc} #{tags}"
+        end
+      end
+
+      subcommand 'list-tags', 'List the tags to use for filtering checks' do
+        def execute
+          available_tags(available_checks).each { |tag| puts tag_string(tag) }
+        end
+
+        def print_check_info(check)
+          desc = "#{label_string(check.label)} #{check.description}".ljust(80)
+          tags = check.tags.map { |t| tag_string(t) }.join(' ').to_s
+          puts "#{desc} #{tags}"
+        end
+      end
+
+      subcommand 'check', 'Run the health checks against the system' do
+        tags_option
+
+        def execute
+          run_scenario(Scenario::ChecksScenario.new(tags || [:basic]))
+        end
+      end
+    end
+  end
+end

data/lib/foreman_maintain/cli/upgrade_command.rb

@@ -0,0 +1,57 @@
+module ForemanMaintain
+  module Cli
+    class UpgradeCommand < Base
+      def tags_to_versions
+        { :satellite_6_0_z => '6.0.z',
+          :satellite_6_1 => '6.1',
+          :satellite_6_1_z => '6.1.z',
+          :satellite_6_2 => '6.2',
+          :satellite_6_2_z => '6.2.z',
+          :satellite_6_3 => '6.3' }
+      end
+
+      # We search for scenarios available for the system and determine
+      # user-friendly version numbers for it.
+      # This method returns a hash of mapping the versions to scenarios to run
+      # The tag is determining which kind of scenario we're searching for
+      # (such as pre_upgrade_check)
+      def available_target_versions(tag)
+        conditions = { :tags => [tag] }
+        find_scenarios(conditions).inject({}) do |hash, scenario|
+          # find tag that represent the version upgrade
+          version_tag = scenario.tags.find { |t| tags_to_versions.key?(t) }
+          if version_tag
+            hash.update(tags_to_versions[version_tag] => scenario)
+          else
+            hash
+          end
+        end
+      end
+
+      def print_versions(target_versions)
+        target_versions.keys.sort.each { |version| puts version }
+      end
+
+      subcommand 'list-versions', 'List versions this system is upgradable to' do
+        def execute
+          print_versions(available_target_versions(:pre_upgrade_check))
+        end
+      end
+
+      subcommand 'check', 'Run pre-upgrade checks for upgradeing to specified version' do
+        parameter 'TARGET_VERSION', 'Target version of the upgrade', :required => false
+        def execute
+          versions_to_scenarios = available_target_versions(:pre_upgrade_check)
+          scenario = versions_to_scenarios[target_version]
+          if scenario
+            run_scenario(scenario)
+          else
+            puts "The specified version #{target_version} is unavailable"
+            puts 'Possible target versions are:'
+            print_versions(versions_to_scenarios)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/foreman_maintain/concerns/finders.rb

@@ -0,0 +1,69 @@
+module ForemanMaintain
+  module Concerns
+    module Finders
+      def detector
+        @detector ||= ForemanMaintain.detector
+      end
+
+      def feature(label)
+        detector.feature(label)
+      end
+
+      def check(label)
+        ensure_one_object(:check, label)
+      end
+
+      def find_checks(conditions)
+        detector.available_checks(conditions)
+      end
+
+      def procedure(label)
+        ensure_one_object(:procedure, label)
+      end
+
+      def find_procedures(conditions)
+        detector.available_procedures(conditions)
+      end
+
+      def find_scenarios(conditions)
+        detector.available_scenarios(conditions)
+      end
+
+      private
+
+      def ensure_one_object(object_type, label_or_class)
+        objects = find_objects(object_type, label_or_class)
+        if objects.first.nil?
+          raise "#{object_type} #{label_or_class} not present"
+        elsif objects.size > 1
+          raise "Multiple objects of #{object_type} found for #{label_or_class}"
+        else
+          objects.first
+        end
+      end
+
+      def label_or_class_condition(label_or_class)
+        case label_or_class
+        when Symbol
+          { :label => label_or_class }
+        when Class
+          { :class => label_or_class }
+        else
+          raise 'Expecting symbol or class'
+        end
+      end
+
+      def find_objects(object_type, label_or_class)
+        conditions = label_or_class_condition(label_or_class)
+        case object_type
+        when :procedure
+          detector.available_procedures(conditions)
+        when :check
+          detector.available_checks(conditions)
+        else
+          raise "Unexpected object type #{object_type}"
+        end
+      end
+    end
+  end
+end

data/lib/foreman_maintain/concerns/logger.rb

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

data/lib/foreman_maintain/concerns/metadata.rb

@@ -0,0 +1,124 @@
+module ForemanMaintain
+  module Concerns
+    module Metadata
+      module DSL
+        def label(label)
+          metadata[:label] = label
+        end
+
+        def tags(*tags)
+          metadata[:tags].concat(tags)
+        end
+
+        def description(description)
+          metadata[:description] = description
+        end
+
+        def confine(&block)
+          metadata[:confine_blocks] << block
+        end
+
+        # Mark the class as manual: this means the instance
+        # of class will not be initialized by detector to check the confine block
+        # to determine if it's valid on the system or not.
+        # 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
+        end
+
+        def autodetect?
+          defined?(@autodetect) ? @autodetect : true
+        end
+
+        # Specify what feature the definition related to.
+        def for_feature(feature_label)
+          metadata[:for_feature] = feature_label
+          confine do
+            feature(feature_label)
+          end
+        end
+      end
+
+      module ClassMethods
+        def inherited(klass)
+          sub_classes << klass
+        end
+
+        # Override if the class should be used as parent class only.
+        # By default, we assume the class that does't inherit from class with
+        # Metadata is abstract = the base class of particular concept
+        def abstract_class
+          !(superclass < Metadata)
+        end
+
+        def sub_classes
+          @sub_classes ||= []
+        end
+
+        def all_sub_classes(ignore_abstract_classes = true)
+          ret = []
+          ret << self if !ignore_abstract_classes || !abstract_class
+          sub_classes.each do |sub_class|
+            ret.concat(sub_class.all_sub_classes(ignore_abstract_classes))
+          end
+          ret
+        end
+
+        def metadata
+          @metadata ||= initialize_metadata
+        end
+
+        def initialize_metadata
+          { :tags => [],
+            :confine_blocks => [] }.tap do |metadata|
+            if superclass.respond_to?(:metadata)
+              metadata[:label] = superclass.metadata[:label]
+            end
+          end
+        end
+      end
+
+      def self.included(klass)
+        klass.extend(DSL)
+        klass.extend(ClassMethods)
+      end
+
+      def metadata
+        self.class.metadata
+      end
+
+      def label
+        metadata[:label] || generate_label
+      end
+
+      def description
+        metadata[:description] || to_s
+      end
+
+      def tags
+        metadata[:tags]
+      end
+
+      def present?
+        @_present ||= evaluate_confines
+      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
+      end
+
+      def generate_label
+        self.class.name.split('::').last.split(/(?=[A-Z])/).map(&:downcase).join('_').to_sym
+      end
+    end
+  end
+end

data/lib/foreman_maintain/concerns/system_helpers.rb

@@ -0,0 +1,93 @@
+require 'rubygems'
+require 'csv'
+require 'English'
+
+module ForemanMaintain
+  module Concerns
+    module SystemHelpers
+      include Logger
+
+      def self.included(klass)
+        klass.extend(self)
+      end
+
+      # class we use for comparing the versions
+      class Version < Gem::Version
+      end
+
+      class ExecutionError < StandardError
+        def initialize(command, input, output)
+          @command = command
+          @input = input
+          @output = output
+          super(generate_message)
+        end
+
+        def generate_message
+          ret = "Could not execute #{command}"
+          ret << "with input '#{input}'" if input
+          ret << ":\n #{output}" if output && !output.empty?
+          ret
+        end
+      end
+
+      def version(value)
+        Version.new(value)
+      end
+
+      def check_min_version(name, minimal_version)
+        current_version = rpm_version(name)
+        if current_version
+          return current_version >= version(minimal_version)
+        end
+      end
+
+      def downstream_installation?
+        execute?('rpm -q satellite') ||
+          (execute('rpm -q foreman') =~ /6sat.noarch/)
+      end
+
+      def rpm_version(name)
+        rpm_version = execute(%(rpm -q '#{name}' --queryformat="%{VERSION}"))
+        if $CHILD_STATUS.success?
+          version(rpm_version)
+        end
+      end
+
+      def parse_csv(data)
+        parsed_data = CSV.parse(data)
+        header = parsed_data.first
+        parsed_data[1..-1].map do |row|
+          Hash[*header.zip(row).flatten(1)]
+        end
+      end
+
+      def execute?(command, input = nil)
+        execute(command, input)
+        $CHILD_STATUS.success?
+      end
+
+      def execute!(command, input = nil)
+        output = execute(command, input)
+        if $CHILD_STATUS.success?
+          output
+        else
+          raise ExecutionError.new(command, input, output)
+        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
+        end
+      end
+    end
+  end
+end