foreman_maintain 0.5.4 → 0.6.4

data/definitions/scenarios/upgrade_to_satellite_6_8_z.rb

@@ -0,0 +1,88 @@
+module Scenarios::Satellite_6_8_z
+  class Abstract < ForemanMaintain::Scenario
+    def self.upgrade_metadata(&block)
+      metadata do
+        tags :upgrade_scenario
+        confine do
+          feature(:satellite) &&
+            (feature(:satellite).current_minor_version == '6.8' || \
+            ForemanMaintain.upgrade_in_progress == '6.8.z')
+        end
+        instance_eval(&block)
+      end
+    end
+
+    def target_version
+      '6.8.z'
+    end
+  end
+
+  class PreUpgradeCheck < Abstract
+    upgrade_metadata do
+      description 'Checks before upgrading to Satellite 6.8.z'
+      tags :pre_upgrade_checks
+      run_strategy :fail_slow
+    end
+
+    def compose
+      add_steps(find_checks(:default))
+      add_steps(find_checks(:pre_upgrade))
+      add_step(Checks::Repositories::Validate.new(:version => '6.8'))
+    end
+  end
+
+  class PreMigrations < Abstract
+    upgrade_metadata do
+      description 'Procedures before migrating to Satellite 6.8.z'
+      tags :pre_migrations
+    end
+
+    def compose
+      add_steps(find_procedures(:pre_migrations))
+      add_step(Procedures::Service::Stop.new)
+    end
+  end
+
+  class Migrations < Abstract
+    upgrade_metadata do
+      description 'Migration scripts to Satellite 6.8.z'
+      tags :migrations
+    end
+
+    def set_context_mapping
+      context.map(:assumeyes, Procedures::Installer::Upgrade => :assumeyes)
+    end
+
+    def compose
+      add_step(Procedures::Repositories::Setup.new(:version => '6.8'))
+      add_step(Procedures::Packages::UnlockVersions.new)
+      add_step(Procedures::Packages::Update.new(:assumeyes => true))
+      add_step_with_context(Procedures::Installer::Upgrade)
+    end
+  end
+
+  class PostMigrations < Abstract
+    upgrade_metadata do
+      description 'Procedures after migrating to Satellite 6.8.z'
+      tags :post_migrations
+    end
+
+    def compose
+      add_step(Procedures::Service::Start.new)
+      add_steps(find_procedures(:post_migrations))
+    end
+  end
+
+  class PostUpgradeChecks < Abstract
+    upgrade_metadata do
+      description 'Checks after upgrading to Satellite 6.8.z'
+      tags :post_upgrade_checks
+      run_strategy :fail_slow
+    end
+
+    def compose
+      add_steps(find_checks(:default))
+      add_steps(find_checks(:post_upgrade))
+    end
+  end
+end

data/lib/foreman_maintain.rb

@@ -139,5 +139,36 @@ module ForemanMaintain
     rescue StandardError => e
       logger.error "Invalid Storage label i.e #{label}. Error - #{e.message}"
     end
+
+    def upgrade_in_progress
+      storage[:upgrade_target_version]
+    end
+
+    def pkg_and_cmd_name
+      instance_feature = ForemanMaintain.available_features(:label => :instance).first
+      if instance_feature.downstream
+        return %w[satellite-maintain satellite-maintain]
+      end
+
+      [main_package_name, 'foreman-maintain']
+    end
+
+    def perform_self_upgrade
+      package_name, command = pkg_and_cmd_name
+
+      puts "Checking for new version of #{package_name}..."
+      if ForemanMaintain.package_manager.update_available?(main_package_name)
+        puts "\nUpdating #{package_name} package."
+        ForemanMaintain.package_manager.update(main_package_name, :assumeyes => true)
+        puts "\nThe #{package_name} package successfully updated."\
+             "\nRe-run #{command} with required options!"
+        exit 0
+      end
+      puts "Nothing to update, can't find new version of #{package_name}."
+    end
+
+    def main_package_name
+      'rubygem-foreman_maintain'
+    end
   end
 end

data/lib/foreman_maintain/cli.rb

@@ -10,6 +10,7 @@ require 'foreman_maintain/cli/service_command'
 require 'foreman_maintain/cli/restore_command'
 require 'foreman_maintain/cli/maintenance_mode_command'
 require 'foreman_maintain/cli/packages_command'
+require 'foreman_maintain/cli/content_command'
 
 module ForemanMaintain
   module Cli
@@ -23,6 +24,7 @@ module ForemanMaintain
       subcommand 'restore', 'Restore a backup', RestoreCommand
       subcommand 'packages', 'Lock/Unlock package protection, install, update', PackagesCommand
       subcommand 'advanced', 'Advanced tools for server maintenance', AdvancedCommand
+      subcommand 'content', 'Content related commands', ContentCommand
       subcommand 'maintenance-mode', 'Control maintenance-mode for application',
                  MaintenanceModeCommand
 

data/lib/foreman_maintain/cli/content_command.rb

@@ -0,0 +1,17 @@
+module ForemanMaintain
+  module Cli
+    class ContentCommand < Base
+      subcommand 'prepare', 'Prepare content for Pulp 3' do
+        def execute
+          run_scenarios_and_exit(Scenarios::Content::Prepare.new)
+        end
+      end
+
+      subcommand 'switchover', 'Switch support for certain content from Pulp 2 to Pulp 3' do
+        def execute
+          run_scenarios_and_exit(Scenarios::Content::Switchover.new)
+        end
+      end
+    end
+  end
+end

data/lib/foreman_maintain/cli/upgrade_command.rb

@@ -6,6 +6,11 @@ module ForemanMaintain
                :required => false
       end
 
+      def self.disable_self_upgrade_option
+        option '--disable-self-upgrade', :flag, 'Disable automatic self upgrade',
+               :default => false
+      end
+
       def current_target_version
         current_target_version = ForemanMaintain::UpgradeRunner.current_target_version
         if current_target_version && target_version && target_version != current_target_version
@@ -56,8 +61,10 @@ module ForemanMaintain
       subcommand 'check', 'Run pre-upgrade checks before upgrading to specified version' do
         target_version_option
         interactive_option
+        disable_self_upgrade_option
 
         def execute
+          ForemanMaintain.perform_self_upgrade unless disable_self_upgrade?
           upgrade_runner.run_phase(:pre_upgrade_checks)
           exit upgrade_runner.exit_code
         end
@@ -66,6 +73,8 @@ module ForemanMaintain
       subcommand 'run', 'Run full upgrade to a specified version' do
         target_version_option
         interactive_option
+        disable_self_upgrade_option
+
         option '--phase', 'phase', 'run only a specific phase', :required => false do |phase|
           unless UpgradeRunner::PHASES.include?(phase.to_sym)
             raise Error::UsageError, "Unknown phase #{phase}"
@@ -74,6 +83,7 @@ module ForemanMaintain
         end
 
         def execute
+          ForemanMaintain.perform_self_upgrade unless disable_self_upgrade?
           if phase
             upgrade_runner.run_phase(phase.to_sym)
           else

data/lib/foreman_maintain/concerns/base_database.rb

@@ -2,7 +2,11 @@ module ForemanMaintain
   module Concerns
     module BaseDatabase
       def data_dir
-        '/var/lib/pgsql/data/'
+        if check_min_version('foreman', '2.0')
+          '/var/opt/rh/rh-postgresql12/lib/pgsql/data/'
+        else
+          '/var/lib/pgsql/data/'
+        end
       end
 
       def configuration
@@ -146,6 +150,17 @@ module ForemanMaintain
         end
       end
 
+      def db_version(config = configuration)
+        if ping(config)
+          # Note - t removes headers, -A removes alignment whitespace
+          server_version_cmd = psql_command(config) + ' -c "SHOW server_version" -t -A'
+          version_string = execute!(server_version_cmd, :hidden_patterns => [config['password']])
+          version(version_string)
+        else
+          raise_service_error
+        end
+      end
+
       private
 
       def base_command(config, command = 'psql')

data/lib/foreman_maintain/concerns/downstream.rb

@@ -97,16 +97,21 @@ module ForemanMaintain
       end
 
       def common_repos(rh_version_major, full_version)
-        tools_repo_id = "rhel-#{rh_version_major}-server-satellite-tools-#{full_version}-rpms"
-        maintenance_repo_id = "rhel-#{rh_version_major}-server-satellite-maintenance-6-rpms"
+        repos_arrary = common_repos_array(rh_version_major, full_version)
+        return repos_arrary.first(1) if feature(:capsule)
 
-        # Override to use Beta repositories for sat version until GA
-        if ENV['FOREMAN_MAINTAIN_USE_BETA'] == '1'
-          tools_repo_id = "rhel-#{rh_version_major}-server-satellite-tools-6-beta-rpms"
-          maintenance_repo_id = "rhel-#{rh_version_major}-server-satellite-maintenance-6-beta-rpms"
-        end
+        repos_arrary
+      end
+
+      def common_repos_array(rh_version_major, full_version)
+        ["rhel-#{rh_version_major}-server-satellite-maintenance-6#{use_beta}-rpms",
+         "rhel-#{rh_version_major}-server-satellite-tools-#{full_version}#{use_beta}-rpms"]
+      end
+
+      def use_beta
+        return '-beta' if ENV['FOREMAN_MAINTAIN_USE_BETA'] == '1'
 
-        [tools_repo_id, maintenance_repo_id]
+        nil
       end
 
       def main_rh_repos(rh_version_major)

data/lib/foreman_maintain/concerns/system_helpers.rb

@@ -53,10 +53,15 @@ module ForemanMaintain
         execute?("command -v #{command_name}")
       end
 
-      def execute!(command, options = {})
+      def execute_runner(command, options = {})
         command_runner = Utils::CommandRunner.new(logger, command, options)
         execution.puts '' if command_runner.interactive? && respond_to?(:execution)
         command_runner.run
+        command_runner
+      end
+
+      def execute!(command, options = {})
+        command_runner = execute_runner(command, options)
         if command_runner.success?
           command_runner.output
         else
@@ -65,15 +70,12 @@ module ForemanMaintain
       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
+        execute_runner(command, options).output
       end
 
       def execute_with_status(command, options = {})
-        result_msg = execute(command, options)
-        [$CHILD_STATUS.to_i, result_msg]
+        command_runner = execute_runner(command, options)
+        [command_runner.exit_status, command_runner.output]
       end
 
       def file_exists?(filename)

data/lib/foreman_maintain/package_manager/dnf.rb

@@ -1,17 +1,23 @@
 module ForemanMaintain::PackageManager
   class Dnf < Yum
-    def clean_cache
-      dnf_action('clean', 'all')
+    def clean_cache(assumeyes: false)
+      dnf_action('clean', 'all', :assumeyes => assumeyes)
       super
     end
 
     private
 
-    def dnf_action(action, packages, assumeyes: false)
+    def dnf_action(action, packages, with_status: false, assumeyes: false)
       yum_options = []
       yum_options << '-y' if assumeyes
-      sys.execute!("dnf #{yum_options.join(' ')} #{action} #{packages.join(' ')}",
-                   :interactive => true)
+      if with_status
+        sys.execute_with_status("dnf #{yum_options.join(' ')} #{action} #{packages.join(' ')}",
+                                :interactive => !assumeyes)
+      else
+        sys.execute!("dnf #{yum_options.join(' ')} #{action} #{packages.join(' ')}",
+                     :interactive => !assumeyes)
+
+      end
     end
   end
 end

data/lib/foreman_maintain/package_manager/yum.rb

@@ -57,8 +57,13 @@ module ForemanMaintain::PackageManager
       yum_action('update', packages, :assumeyes => assumeyes)
     end
 
-    def clean_cache
-      yum_action('clean', 'all')
+    def clean_cache(assumeyes: false)
+      yum_action('clean', 'all', :assumeyes => assumeyes)
+    end
+
+    def update_available?(package)
+      cmd_output = yum_action('check-update -q', package, :with_status => true, :assumeyes => false)
+      cmd_output[0] == 100
     end
 
     def files_not_owned_by_package(directory)
@@ -96,14 +101,19 @@ module ForemanMaintain::PackageManager
       File.open(protector_config_file, 'w') { |file| file.puts config }
     end
 
-    def yum_action(action, packages, assumeyes: false)
+    def yum_action(action, packages, with_status: false, assumeyes: false)
       yum_options = []
       packages = [packages].flatten(1)
       yum_options << '-y' if assumeyes
       yum_options_s = yum_options.empty? ? '' : ' ' + yum_options.join(' ')
       packages_s = packages.empty? ? '' : ' ' + packages.join(' ')
-      sys.execute!("yum#{yum_options_s} #{action}#{packages_s}",
-                   :interactive => true)
+      if with_status
+        sys.execute_with_status("yum#{yum_options_s} #{action}#{packages_s}",
+                                :interactive => !assumeyes)
+      else
+        sys.execute!("yum#{yum_options_s} #{action}#{packages_s}",
+                     :interactive => !assumeyes)
+      end
     end
 
     def install_extras(src, dest, override: false)

data/lib/foreman_maintain/reporter/cli_reporter.rb

@@ -16,7 +16,6 @@ module ForemanMaintain
           @spinner_chars = %w[| / - \\]
           @current_line = ''
           @puts_needed = false
-          start_spinner
         end
 
         def update(line)
@@ -42,8 +41,6 @@ module ForemanMaintain
           end
         end
 
-        private
-
         def start_spinner
           @thread = Thread.new do
             loop do
@@ -53,6 +50,8 @@ module ForemanMaintain
           end
         end
 
+        private
+
         def spin
           @mutex.synchronize do
             return unless @active
@@ -80,6 +79,7 @@ module ForemanMaintain
         @line_char = '-'
         @cell_char = '|'
         @spinner = Spinner.new(self)
+        @spinner.start_spinner if @stdout.tty?
         @last_line = ''
       end
 

data/lib/foreman_maintain/upgrade_runner.rb

@@ -15,29 +15,8 @@ module ForemanMaintain
       def available_targets
         # when some upgrade is in progress, we don't allow upgrade to different version
         return [current_target_version] if current_target_version
-        versions_to_tags.inject([]) do |available_targets, (version, tag)|
-          if !find_scenarios(:tags => [tag]).empty?
-            available_targets << version
-          else
-            available_targets
-          end
-        end.sort
-      end
-
-      def versions_to_tags
-        @versions_to_tags ||= {}
-      end
-
-      # registers target version to specific tag
-      def register_version(version, tag)
-        if versions_to_tags.key?(version) && versions_to_tags[version] != tag
-          raise "Version #{version} already registered to tag #{versions_to_tags[version]}"
-        end
-        @versions_to_tags[version] = tag
-      end
 
-      def clear_register
-        versions_to_tags.clear
+        find_scenarios(:tags => :upgrade_scenario).map(&:target_version).uniq.sort
       end
 
       def current_target_version
@@ -57,25 +36,35 @@ module ForemanMaintain
 
     def initialize(version, reporter, options = {})
       super(reporter, [], options)
-      @tag = self.class.versions_to_tags[version]
-      raise "Unknown version #{version}" unless tag
       @version = version
+      scenarios_present = find_scenarios(:tags => :upgrade_scenario).any?(&matching_version_test)
+      raise "Unknown version #{version}" unless scenarios_present
+
       @scenario_cache = {}
       self.phase = :pre_upgrade_checks
     end
 
     def scenario(phase)
       return @scenario_cache[phase] if @scenario_cache.key?(phase)
-      condition = { :tags => [tag, phase] }
-      matching_scenarios = find_all_scenarios(condition)
+
+      condition = { :tags => [:upgrade_scenario, phase] }
+      matching_scenarios = find_scenarios(condition).select(&matching_version_test)
       raise "Too many scenarios match #{condition.inspect}" if matching_scenarios.size > 1
+
       @scenario_cache[phase] = matching_scenarios.first
     end
 
+    def matching_version_test
+      proc do |scenario|
+        scenario.respond_to?(:target_version) && scenario.target_version == @version
+      end
+    end
+
     def run
       self.class.current_target_version = @version
       PHASES.each do |phase|
         return run_rollback if quit?
+
         if skip?(phase)
           skip_phase(phase)
         else
@@ -127,6 +116,7 @@ module ForemanMaintain
     # deserializes the state of the run from the storage
     def load
       return unless storage[:serialized]
+
       load_from_hash(storage[:serialized])
     end
 
@@ -134,6 +124,7 @@ module ForemanMaintain
       with_non_empty_scenario(phase) do |scenario|
         confirm_scenario(scenario)
         return if quit?
+
         self.phase = phase
         run_scenario(scenario)
         # if we started from the :pre_upgrade_checks, ensure to ask before
@@ -158,6 +149,7 @@ module ForemanMaintain
     # rubocop:disable Metrics/MethodLength
     def rollback_pre_migrations
       raise "Unexpected phase #{phase}, expecting pre_migrations" unless phase == :pre_migrations
+
       rollback_needed = scenario(:pre_migrations).steps.any? { |s| s.executed? && s.success? }
       if rollback_needed
         @quit = false
@@ -198,6 +190,7 @@ module ForemanMaintain
       unless @scenario_cache.empty?
         raise "Some scenarios are already initialized: #{@scenario_cache.keys}"
       end
+
       self.phase = hash[:phase]
       hash[:scenarios].each do |key, scenario_hash|
         @scenario_cache[key] = Scenario.new_from_hash(scenario_hash)
@@ -229,6 +222,7 @@ module ForemanMaintain
 
     def phase=(phase)
       raise "Unknown phase #{phase}" unless PHASES.include?(phase)
+
       @phase = phase
     end
   end