foreman_maintain 0.0.6 → 0.0.7

data/lib/foreman_maintain/cli/advanced_command.rb

@@ -0,0 +1,9 @@
+require 'foreman_maintain/cli/advanced/procedure_command'
+
+module ForemanMaintain
+  module Cli
+    class AdvancedCommand < Base
+      subcommand 'procedure', 'Run maintain procedures manually', ProcedureCommand
+    end
+  end
+end

data/lib/foreman_maintain/cli/base.rb

@@ -1,12 +1,18 @@
+require 'foreman_maintain/csv_parser'
+
 module ForemanMaintain
   module Cli
     class Base < Clamp::Command
       include Concerns::Finders
 
-      def dashize(string)
+      def self.dashize(string)
         string.to_s.tr('_', '-')
       end
 
+      def dashize(string)
+        self.class.dashize(string)
+      end
+
       def underscorize(string)
         string.to_s.tr('-', '_')
       end
@@ -19,14 +25,23 @@ module ForemanMaintain
         HighLine.color("[#{dashize(string)}]", :cyan)
       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}".strip
+      end
+
       def reporter
         @reporter ||= ForemanMaintain::Reporter::CLIReporter.new(STDOUT,
                                                                  STDIN,
                                                                  :assumeyes => assumeyes?)
       end
 
-      def run_scenario(scenario)
-        ForemanMaintain::Runner.new(reporter, scenario, :assumeyes => assumeyes?).run
+      def run_scenario(scenarios)
+        ForemanMaintain::Runner.new(reporter, scenarios,
+                                    :assumeyes => assumeyes?,
+                                    :whitelist => whitelist || [],
+                                    :force => force?).run
       end
 
       def available_checks
@@ -35,8 +50,28 @@ module ForemanMaintain
         ForemanMaintain.available_checks(filter)
       end
 
+      def available_procedures
+        filter = {}
+        filter[:tags] = tags if respond_to?(:tags)
+        ForemanMaintain.available_procedures(filter)
+      end
+
       def available_tags(collection)
-        collection.inject([]) { |array, check| array.concat(check.tags).uniq }.sort_by(&:to_s)
+        self.class.available_tags(collection)
+      end
+
+      def self.available_tags(collection)
+        collection.inject([]) { |array, item| array.concat(item.tags).uniq }.sort_by(&:to_s)
+      end
+
+      def self.option(switches, type, description, opts = {}, &block)
+        multivalued = opts.delete(:multivalued)
+        description += ' (comma-separated list)' if multivalued
+        super(switches, type, description, opts) do |value|
+          value = CSVParser.new.parse(value) if multivalued
+          value = instance_exec(value, &block) if block
+          value
+        end
       end
 
       def self.label_option
@@ -49,17 +84,27 @@ module ForemanMaintain
       end
 
       def self.tags_option
-        option '--tags', 'tags',
+        option('--tags', 'tags',
                'Limit only for specific set of labels. ' \
-                 '(Use list-tags command to see available tags)' do |tags|
+                 '(Use list-tags command to see available tags)',
+               :multivalued => true) do |tags|
           raise ArgumentError, 'value not specified' if tags.nil? || tags.empty?
-          tags.split(',').map(&:strip).map { |tag| underscorize(tag).to_sym }
+          tags.map { |tag| underscorize(tag).to_sym }
         end
       end
 
       def self.interactive_option
         option ['-y', '--assumeyes'], :flag,
                'Automatically answer yes for all questions'
+
+        option ['-w', '--whitelist'], 'whitelist',
+               'Comma-separated list of labels of steps to be ignored' do |whitelist|
+          raise ArgumentError, 'value not specified' if whitelist.nil? || whitelist.empty?
+          whitelist.split(',').map(&:strip)
+        end
+
+        option ['-f', '--force'], :flag,
+               'Force steps that would be skipped as they were already run'
       end
     end
   end

data/lib/foreman_maintain/cli/health_command.rb

@@ -9,24 +9,12 @@ module ForemanMaintain
             print_check_info(check)
           end
         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

data/lib/foreman_maintain/cli/transform_clamp_options.rb

@@ -0,0 +1,66 @@
+module ForemanMaintain
+  module Cli
+    module TransformClampOptions
+      def self.included(base)
+        base.send(:include, OptionsToParams)
+        base.extend(ParamsToOptions)
+      end
+
+      module OptionsToParams
+        def options_to_params
+          @params ||= self.class.recognised_options.inject({}) do |par, option|
+            par[option_sym(option)] = send(option.read_method) if metadata_option?(option)
+            par
+          end
+        end
+
+        def get_params_for(definition)
+          all_params = options_to_params
+          params = {}
+          definition.params.values.each do |param|
+            params[param.name] = all_params[param.name]
+          end
+          params
+        end
+
+        private
+
+        def option_sym(option)
+          option.switches.first[2..-1].to_sym
+        end
+
+        def metadata_option?(option)
+          !option.switches.include?('--help') && !option.switches.include?('--assumeyes')
+        end
+      end
+
+      module ParamsToOptions
+        def params_to_options(params)
+          params.values.each do |param|
+            param_to_option(param)
+          end
+        end
+
+        def param_to_option(param, custom = {})
+          switches = custom.fetch(:switches, option_switches(param))
+          opt_type = custom.fetch(:type, option_type(param))
+          description = custom.fetch(:description, param.description)
+          options = custom.fetch(:options, {})
+
+          # clamp doesnt allow required flags
+          options[:required] ||= param.required? unless param.flag?
+          options[:multivalued] ||= param.array?
+          option(switches, opt_type, description, options)
+        end
+
+        def option_switches(param)
+          ['--' + dashize(param.name.to_s)]
+        end
+
+        def option_type(param)
+          param.flag? ? :flag : param.name.to_s.upcase
+        end
+      end
+    end
+  end
+end

data/lib/foreman_maintain/cli/upgrade_command.rb

@@ -1,57 +1,69 @@
 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' }
+      def self.target_version_option
+        option '--target-version', 'TARGET_VERSION', 'Target version of the upgrade',
+               :required => false
       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
+      def validate_target_version!
+        unless UpgradeRunner.available_targets.include?(target_version)
+          message_start = if target_version
+                            "Can't upgrade to #{target_version}"
+                          else
+                            '--target-version not specified'
+                          end
+          message = <<-MESSAGE.strip_heredoc
+            #{message_start}
+            Possible target versions are:
+          MESSAGE
+          versions = UpgradeRunner.available_targets.join("\n")
+          raise Error::UsageError, message + versions
         end
       end
 
+      def upgrade_runner
+        return @upgrade_runner if defined? @upgrade_runner
+        validate_target_version!
+        @upgrade_runner = ForemanMaintain::UpgradeRunner.new(target_version, reporter,
+                                                             :assumeyes => assumeyes?,
+                                                             :whitelist => whitelist || [],
+                                                             :force => force?).tap(&:load)
+      end
+
       def print_versions(target_versions)
-        target_versions.keys.sort.each { |version| puts version }
+        target_versions.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))
+          print_versions(UpgradeRunner.available_targets)
+        end
+      end
+
+      subcommand 'check', 'Run pre-upgrade checks before upgrading to specified version' do
+        target_version_option
+        interactive_option
+
+        def execute
+          upgrade_runner.run_phase(:pre_upgrade_checks)
+          exit upgrade_runner.exit_code
         end
       end
 
-      subcommand 'check', 'Run pre-upgrade checks for upgradeing to specified version' do
-        parameter 'TARGET_VERSION', 'Target version of the upgrade', :required => false
+      subcommand 'run', 'Run full upgrade to a specified version' do
+        target_version_option
         interactive_option
+        option '--phase', 'phase', 'run only a specific phase', :required => false
 
         def execute
-          versions_to_scenarios = available_target_versions(:pre_upgrade_check)
-          scenario = versions_to_scenarios[target_version]
-          if scenario
-            run_scenario(scenario)
+          if phase
+            upgrade_runner.run_phase(phase.to_sym)
           else
-            puts "The specified version #{target_version} is unavailable"
-            puts 'Possible target versions are:'
-            print_versions(versions_to_scenarios)
+            upgrade_runner.run
           end
+          upgrade_runner.save
+          exit upgrade_runner.exit_code
         end
       end
     end

data/lib/foreman_maintain/concerns/metadata.rb

@@ -90,6 +90,12 @@ module ForemanMaintain
           end
         end
 
+        # Ensure to not run the step twice: expects the scenario to be persisted
+        # between runs to work properly
+        def run_once
+          @data[:run_once] = true
+        end
+
         def self.eval_dsl(metadata, &block)
           new(metadata).tap do |dsl|
             dsl.instance_eval(&block)
@@ -131,11 +137,15 @@ module ForemanMaintain
         def metadata(&block)
           @metadata ||= initialize_metadata
           if block
-            DSL.eval_dsl(@metadata, &block)
+            metadata_class.eval_dsl(@metadata, &block)
           end
           @metadata
         end
 
+        def metadata_class
+          DSL
+        end
+
         def label
           metadata[:label] || generate_label
         end
@@ -149,7 +159,7 @@ module ForemanMaintain
         end
 
         def params
-          metadata[:params] || []
+          metadata[:params] || {}
         end
 
         def before
@@ -160,6 +170,10 @@ module ForemanMaintain
           metadata[:after] || []
         end
 
+        def run_once?
+          metadata[:run_once]
+        end
+
         def initialize_metadata
           { :tags => [],
             :confine_blocks => [],
@@ -230,10 +244,18 @@ module ForemanMaintain
         self.class.label
       end
 
+      def label_dashed
+        label.to_s.tr('_', '-')
+      end
+
       def description
         self.class.description
       end
 
+      def runtime_message
+        description + (params.empty? ? '' : " (#{params})")
+      end
+
       def tags
         self.class.tags
       end
@@ -242,6 +264,10 @@ module ForemanMaintain
         self.class.params
       end
 
+      def run_once?
+        self.class.run_once?
+      end
+
       def preparation_steps(*args)
         self.class.preparation_steps(*args)
       end

data/lib/foreman_maintain/concerns/scenario_metadata.rb

@@ -0,0 +1,44 @@
+module ForemanMaintain
+  module Concerns
+    module ScenarioMetadata
+      class DSL < Metadata::DSL
+        VALID_STRATEGIES = [:fail_fast, :fail_slow].freeze
+
+        def initialize(*args)
+          super
+          # the default strategy is to fail as soon as first step fails
+          run_strategy :fail_fast
+        end
+
+        # Possible run strategies:
+        #
+        #  * +:fail_fast+ - the scenario stops as soon as the first step fails
+        #  * +:fail_slow+ - the step failure doesn't cause the scenario to stop:
+        #                   it runs all the steps, for the tailures to be reported
+        #                   at the end
+        def run_strategy(run_strategy)
+          unless VALID_STRATEGIES.include?(run_strategy)
+            raise "Run strategy #{run_strategy} not one of #{VALID_STRATEGIES}"
+          end
+          @data[:run_strategy] = run_strategy
+        end
+      end
+
+      module ClassMethods
+        # modules not to be included in autogenerated labels
+        def metadata_class
+          ScenarioMetadata::DSL
+        end
+      end
+
+      def self.included(klass)
+        klass.send(:include, Metadata)
+        klass.extend(ClassMethods)
+      end
+
+      def run_strategy
+        self.class.metadata[:run_strategy]
+      end
+    end
+  end
+end

data/lib/foreman_maintain/concerns/system_helpers.rb

@@ -13,6 +13,17 @@ module ForemanMaintain
 
       # class we use for comparing the versions
       class Version < Gem::Version
+        def major
+          segments[0]
+        end
+
+        def minor
+          segments[1]
+        end
+
+        def build
+          segments[2]
+        end
       end
 
       def hostname
@@ -27,11 +38,16 @@ module ForemanMaintain
         Version.new(value)
       end
 
-      def install_packages(packages, options = {})
+      def packages_action(action, packages, options = {})
+        expected_actions = [:install, :update]
+        unless expected_actions.include?(action)
+          raise ArgumentError, "Unexpected action #{action} expected #{expected_actions.inspect}"
+        end
         options.validate_options!(:assumeyes)
         yum_options = []
         yum_options << '-y' if options[:assumeyes]
-        execute!("yum #{yum_options.join(' ')} install #{packages.join(' ')}", :interactive => true)
+        execute!("yum #{yum_options.join(' ')} #{action} #{packages.join(' ')}",
+                 :interactive => true)
       end
 
       def check_min_version(name, minimal_version)
@@ -43,7 +59,7 @@ module ForemanMaintain
 
       def downstream_installation?
         execute?('rpm -q satellite') ||
-          (execute('rpm -q foreman') =~ /6sat.noarch/)
+          (execute('rpm -q foreman') =~ /sat.noarch/)
       end
 
       def package_version(name)
@@ -51,8 +67,8 @@ module ForemanMaintain
         rpm_version(name)
       end
 
-      def rpm_version(name)
-        rpm_version = execute(%(rpm -q '#{name}' --queryformat="%{VERSION}"))
+      def rpm_version(name, queryformat = 'VERSION')
+        rpm_version = execute(%(rpm -q '#{name}' --queryformat="%{#{queryformat}}"))
         if $CHILD_STATUS.success?
           version(rpm_version)
         end
@@ -92,6 +108,12 @@ module ForemanMaintain
       def shellescape(string)
         Shellwords.escape(string)
       end
+
+      def json_parse(json_string)
+        JSON.parse(json_string)
+      rescue
+        nil
+      end
     end
   end
 end