foreman_maintain 1.6.3 → 1.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b13b3b3d17ba932466b1bee7b2de56dd7a83bb577236d8fba67dcd04674f595
-  data.tar.gz: 9f691170e95c2fbefb77db6218216b5d6dc0ec43d33fe4ca20dc84866f6dfd02
+  metadata.gz: 9832b114fa0e778b687140d47774ffa583742e69c0883f7e0738fad23e6d0f87
+  data.tar.gz: dfd33002a93b7171aab581342c169d0eef6cee318302bad7d24108581e05b514
 SHA512:
-  metadata.gz: 20e3f6408c0263c62a3bb2b11226f6d87bf6325fd5c14c980e0ca00af7375301e9d342700b400e4c4dca4915a14bac4cc68e006fea17ef5f6fa28120a2890987
-  data.tar.gz: 338362b5bbf7c82cd43ec5d20e18c15435a5c122b3d7d4a6c1c6e5cc99e7c795312ead32af13f94fbacd78a877d323396e602df6058b69e4e3256d14cad8f592
+  metadata.gz: 30c727eed2a0f6fb4402caedfcbca2b5e8466b322f94f938523e16726b9439d3b00737950d88c41993fdd61f8cedea7c67752d1917e91ff6a6dde57dfbca1544
+  data.tar.gz: fd20b2f2ea602071e1371266b62e7640b945a942208469019f0ee173ab90afd51de78e91c9790c525d1d6e689f5d47779e57ce22c032a1a1d3c53f61eb566135

data/definitions/checks/repositories/validate.rb

@@ -12,7 +12,7 @@ module Checks::Repositories
 
       param :version,
         'Version for which repositories needs to be validated',
-        :required => true
+        :required => false
 
       manual_detection
     end
@@ -21,6 +21,8 @@ module Checks::Repositories
       if feature(:instance).downstream.subscribed_using_activation_key?
         skip 'Your system is subscribed using custom activation key'
       else
+        @version ||= package_version(feature(:instance).downstream.package_name)
+
         with_spinner("Validating availability of repositories for #{@version}") do |spinner|
           find_absent_repos(spinner)
         end

data/definitions/procedures/packages/check_for_reboot.rb

@@ -5,7 +5,7 @@ module Procedures::Packages
     end
 
     def run
-      status, output = execute_with_status('dnf needs-restarting --reboothint')
+      status, output = package_manager.reboot_required?
       if status == 1
         set_info_warn(output)
       else

data/definitions/procedures/packages/update.rb

@@ -7,13 +7,18 @@ module Procedures::Packages
       param :warn_on_errors, 'Do not interrupt scenario on failure',
         :flag => true, :default => false
       param :dnf_options, 'Extra dnf options if any', :array => true, :default => []
+      param :download_only, 'Download and cache packages only', :flag => true, :default => false
       param :clean_cache, 'If true will cause a DNF cache clean', :flag => true, :default => true
     end
 
     def run
       assumeyes_val = @assumeyes.nil? ? assumeyes? : @assumeyes
       package_manager.clean_cache(:assumeyes => assumeyes_val) if @clean_cache
-      opts = { :assumeyes => assumeyes_val, :dnf_options => @dnf_options }
+      opts = {
+        :assumeyes => assumeyes_val,
+        :options => @dnf_options,
+        :download_only => @download_only,
+      }
       packages_action(:update, @packages, opts)
     rescue ForemanMaintain::Error::ExecutionError => e
       if @warn_on_errors
@@ -28,15 +33,11 @@ module Procedures::Packages
     end
 
     def description
-      if download_only?
+      if @download_only
         "Download package(s) #{@packages.join(', ')}"
       else
         "Update package(s) #{@packages.join(', ')}"
       end
     end
-
-    def download_only?
-      @dnf_options.include?('--downloadonly')
-    end
   end
 end

data/definitions/procedures/packages/update_all_confirmation.rb

@@ -10,13 +10,10 @@ module Procedures::Packages
       if @packages.nil? || @packages.empty?
         question = "\nWARNING: No specific packages to update were provided\n" \
           "so we are going to update all available packages.\n" \
-          "It is recommended to update everything only as part of upgrade\n" \
-          "of the #{feature(:instance).product_name} to the next version. \n" \
           "To Upgrade to next version use 'foreman-maintain upgrade'.\n\n" \
-          "NOTE: --assumeyes is not applicable for this check\n\n" \
           "Do you want to proceed with update of everything regardless\n" \
           'of the recommendations?'
-        answer = ask_decision(question, actions_msg: 'y(yes), q(quit)', ignore_assumeyes: true)
+        answer = ask_decision(question, actions_msg: 'y(yes), q(quit)')
         abort! unless answer == :yes
       end
     end

data/definitions/scenarios/packages.rb

@@ -97,25 +97,41 @@ module ForemanMaintain::Scenarios
         description 'update packages in unlocked session'
         param :packages, 'List of packages to Update', :array => true
         param :assumeyes, 'Do not ask for confirmation'
+        param :downloadonly, 'Download and cache packages'
         manual_detection
       end
 
+      # rubocop:disable  Metrics/MethodLength
       def compose
         if Packages.skip_installer_run?(context.get(:packages))
           add_step_with_context(Procedures::Packages::Update,
             :force => true, :warn_on_errors => true)
         else
-          add_steps_with_context(
-            Procedures::Packages::UpdateAllConfirmation,
-            Procedures::Packages::InstallerConfirmation
-          )
+          unless context.get(:downloadonly)
+            add_steps_with_context(
+              Procedures::Packages::UpdateAllConfirmation,
+              Procedures::Packages::InstallerConfirmation
+            )
+          end
+
           add_step_with_context(Procedures::Packages::UnlockVersions)
-          add_step_with_context(Procedures::Packages::Update,
-            :force => true, :warn_on_errors => true)
-          add_step_with_context(Procedures::Installer::Run)
+          add_step_with_context(
+            Procedures::Packages::Update,
+            :force => true,
+            :warn_on_errors => true,
+            :download_only => context.get(:downloadonly)
+          )
+
+          if context.get(:downloadonly)
+            add_step_with_context(Procedures::Packages::LockVersions)
+          else
+            add_step_with_context(Procedures::Installer::Run)
+          end
+
           add_step(Procedures::Packages::LockingStatus)
         end
       end
+      # rubocop:enable  Metrics/MethodLength
 
       def set_context_mapping
         context.map(:packages,

data/definitions/scenarios/update.rb

@@ -0,0 +1,126 @@
+module Scenarios::Update
+  class Abstract < ForemanMaintain::Scenario
+    def self.update_metadata(&block)
+      metadata do
+        tags :update_scenario
+        instance_eval(&block)
+      end
+    end
+  end
+
+  class PreUpdateCheck < Abstract
+    update_metadata do
+      description 'Checks before updating'
+      tags :pre_update_checks
+      run_strategy :fail_slow
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def compose
+      add_steps(
+        Checks::Foreman::FactsNames, # if Foreman database present
+        Checks::ForemanProxy::CheckTftpStorage, # if Satellite with foreman-proxy+tftp
+        Checks::ForemanProxy::VerifyDhcpConfigSyntax, # if foreman-proxy+dhcp-isc
+        Checks::ForemanTasks::NotPaused, # if foreman-tasks present
+        Checks::Puppet::VerifyNoEmptyCacertRequests, # if puppetserver
+        Checks::ServerPing,
+        Checks::ServicesUp,
+        Checks::SystemRegistration,
+        Checks::CheckHotfixInstalled,
+        Checks::CheckTmout,
+        Checks::CheckUpstreamRepository,
+        Checks::Disk::AvailableSpace,
+        Checks::Disk::AvailableSpaceCandlepin, # if candlepin
+        Checks::Foreman::ValidateExternalDbVersion, # if external database
+        Checks::Foreman::CheckCorruptedRoles,
+        Checks::Foreman::CheckDuplicatePermissions,
+        Checks::Foreman::TuningRequirements, # if katello present
+        Checks::ForemanOpenscap::InvalidReportAssociations, # if foreman-openscap
+        Checks::ForemanTasks::Invalid::CheckOld, # if foreman-tasks
+        Checks::ForemanTasks::Invalid::CheckPendingState, # if foreman-tasks
+        Checks::ForemanTasks::Invalid::CheckPlanningState, # if foreman-tasks
+        Checks::ForemanTasks::NotRunning, # if foreman-tasks
+        Checks::NonRhPackages,
+        Checks::PackageManager::Dnf::ValidateDnfConfig,
+        Checks::Repositories::CheckNonRhRepository,
+        Checks::Repositories::Validate
+      )
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+
+  class PreMigrations < Abstract
+    update_metadata do
+      description 'Procedures before migrating'
+      tags :pre_migrations
+    end
+
+    def compose
+      add_steps(
+        Procedures::Packages::Update.new(
+          :assumeyes => true,
+          :dnf_options => ['--downloadonly']
+        ),
+        Procedures::MaintenanceMode::EnableMaintenanceMode,
+        Procedures::Crond::Stop,
+        Procedures::SyncPlans::Disable
+      )
+    end
+  end
+
+  class Migrations < Abstract
+    update_metadata do
+      description 'Migration scripts'
+      tags :migrations
+      run_strategy :fail_fast
+    end
+
+    def compose
+      add_steps(
+        Procedures::Service::Stop,
+        Procedures::Packages::Update.new(:assumeyes => true, :clean_cache => false),
+        Procedures::Installer::Run.new(:assumeyes => true),
+        Procedures::Installer::UpgradeRakeTask
+      )
+    end
+  end
+
+  class PostMigrations < Abstract
+    update_metadata do
+      description 'Procedures after migrating'
+      tags :post_migrations
+    end
+
+    def compose
+      add_steps(
+        Procedures::RefreshFeatures,
+        Procedures::Service::Start,
+        Procedures::Crond::Start,
+        Procedures::SyncPlans::Enable,
+        Procedures::MaintenanceMode::DisableMaintenanceMode
+      )
+    end
+  end
+
+  class PostUpdateChecks < Abstract
+    update_metadata do
+      description 'Checks after update'
+      tags :post_update_checks
+      run_strategy :fail_slow
+    end
+
+    def compose
+      add_steps(
+        Checks::Foreman::FactsNames, # if Foreman database present
+        Checks::ForemanProxy::CheckTftpStorage, # if Satellite with foreman-proxy+tftp
+        Checks::ForemanProxy::VerifyDhcpConfigSyntax, # if foreman-proxy+dhcp-isc
+        Checks::ForemanTasks::NotPaused, # if foreman-tasks present
+        Checks::Puppet::VerifyNoEmptyCacertRequests, # if puppetserver
+        Checks::ServerPing,
+        Checks::ServicesUp,
+        Checks::SystemRegistration,
+        Procedures::Packages::CheckForReboot
+      )
+    end
+  end
+end

data/definitions/scenarios/upgrade_to_capsule_6_16.rb

@@ -63,7 +63,7 @@ module Scenarios::Capsule_6_16
       end
       add_step(Procedures::Packages::Update.new(
         :assumeyes => true,
-        :dnf_options => ['--downloadonly']
+        :download_only => true
       ))
       add_step(Procedures::Service::Stop.new)
       add_step(Procedures::Packages::Update.new(:assumeyes => true, :clean_cache => false))

data/definitions/scenarios/upgrade_to_capsule_6_16_z.rb

@@ -45,7 +45,7 @@ module Scenarios::Capsule_6_16_z
       end
       add_step(Procedures::Packages::Update.new(
         :assumeyes => true,
-        :dnf_options => ['--downloadonly']
+        :download_only => true
       ))
       add_steps(find_procedures(:pre_migrations))
     end

data/definitions/scenarios/upgrade_to_katello_nightly.rb

@@ -60,7 +60,7 @@ module Scenarios::Katello_Nightly
       end
       add_step(Procedures::Packages::Update.new(
         :assumeyes => true,
-        :dnf_options => ['--downloadonly']
+        :download_only => true
       ))
       add_step(Procedures::Service::Stop.new)
       add_step(Procedures::Packages::Update.new(:assumeyes => true, :clean_cache => false))

data/definitions/scenarios/upgrade_to_satellite_6_16.rb

@@ -65,7 +65,7 @@ module Scenarios::Satellite_6_16
       end
       add_step(Procedures::Packages::Update.new(
         :assumeyes => true,
-        :dnf_options => ['--downloadonly']
+        :download_only => true
       ))
       add_step(Procedures::Service::Stop.new)
       add_step(Procedures::Packages::Update.new(:assumeyes => true, :clean_cache => false))

data/definitions/scenarios/upgrade_to_satellite_6_16_z.rb

@@ -45,7 +45,7 @@ module Scenarios::Satellite_6_16_z
       end
       add_step(Procedures::Packages::Update.new(
         :assumeyes => true,
-        :dnf_options => ['--downloadonly']
+        :download_only => true
       ))
       add_steps(find_procedures(:pre_migrations))
     end

data/extras/foreman_protector/dnf/foreman-protector.py

@@ -1,8 +1,10 @@
+import configparser
+import os
+
 import dnf
 import dnf.exceptions
 from dnfpluginscore import _, logger
 
-import configparser
 
 PROTECT_COMMANDS = ('install', 'downgrade', 'reinstall', 'distro-sync', 'swap', 'upgrade', 'upgrade-minimal')
 
@@ -53,6 +55,8 @@ class ForemanProtector(dnf.Plugin):
     def sack(self):
         if self.cli is not None and self.cli.command._basecmd not in PROTECT_COMMANDS:
             return
+        if os.environ.get('LEAPP_IPU_IN_PROGRESS') is not None:
+            return
         whitelist_and_obsoletes = self._add_obsoletes()
         all_available_packages = self.base.sack.query().available()
         excluded_pkgs_query = all_available_packages.difference(whitelist_and_obsoletes)

data/lib/foreman_maintain/cli/packages_command.rb

@@ -55,12 +55,15 @@ module ForemanMaintain
       subcommand 'update', 'Update packages in an unlocked session' do
         interactive_option(['assumeyes'])
         parameter '[PACKAGES] ...', 'packages to update', :attribute_name => :packages
+        option '--downloadonly', :flag, 'Downloads and caches package updates only',
+          :default => false
 
         def execute
           run_scenarios_and_exit(
             Scenarios::Packages::Update.new(
               :packages => packages,
-              :assumeyes => assumeyes?
+              :assumeyes => assumeyes?,
+              :downloadonly => @downloadonly
             )
           )
         end

data/lib/foreman_maintain/cli/update_command.rb

@@ -0,0 +1,48 @@
+require 'foreman_maintain/update_runner'
+
+module ForemanMaintain
+  module Cli
+    class UpdateCommand < Base
+      def self.disable_self_update_option
+        option '--disable-self-update', :flag, 'Disable automatic self update',
+          :default => false
+      end
+
+      def update_runner
+        update_runner = ForemanMaintain::UpdateRunner.new(
+          reporter,
+          :assumeyes => assumeyes?,
+          :whitelist => whitelist || [],
+          :force => force?
+        )
+        update_runner.load
+        update_runner
+      end
+
+      subcommand 'check', 'Run pre-update checks before updating' do
+        interactive_option
+        disable_self_update_option
+
+        def execute
+          ForemanMaintain.validate_downstream_packages
+          ForemanMaintain.perform_self_upgrade unless disable_self_update?
+          update_runner.run_phase(:pre_update_checks)
+          exit update_runner.exit_code
+        end
+      end
+
+      subcommand 'run', 'Run an update' do
+        interactive_option
+        disable_self_update_option
+
+        def execute
+          ForemanMaintain.validate_downstream_packages
+          ForemanMaintain.perform_self_upgrade unless disable_self_update?
+          update_runner.run
+          update_runner.save
+          exit update_runner.exit_code
+        end
+      end
+    end
+  end
+end

data/lib/foreman_maintain/cli.rb

@@ -12,6 +12,7 @@ require 'foreman_maintain/cli/maintenance_mode_command'
 require 'foreman_maintain/cli/packages_command'
 require 'foreman_maintain/cli/plugin_command'
 require 'foreman_maintain/cli/self_upgrade_command'
+require 'foreman_maintain/cli/update_command'
 
 Clamp.allow_options_after_parameters = true
 
@@ -22,6 +23,7 @@ module ForemanMaintain
 
       subcommand 'health', 'Health related commands', HealthCommand
       subcommand 'upgrade', 'Upgrade related commands', UpgradeCommand
+      subcommand 'update', 'Update related commands', UpdateCommand
       subcommand 'service', 'Control applicable services', ServiceCommand
       subcommand 'backup', 'Backup server', BackupCommand
       subcommand 'restore', 'Restore a backup', RestoreCommand

data/lib/foreman_maintain/concerns/system_helpers.rb

@@ -100,13 +100,17 @@ module ForemanMaintain
       end
 
       def packages_action(action, packages, options = {})
-        options.validate_options!(:assumeyes, :dnf_options)
+        options.validate_options!(:assumeyes, :options, :download_only)
         case action
         when :install
           package_manager.install(packages, :assumeyes => options[:assumeyes])
         when :update
-          package_manager.update(packages, :assumeyes => options[:assumeyes],
-            :dnf_options => options[:dnf_options])
+          package_manager.update(
+            packages,
+            :assumeyes => options[:assumeyes],
+            :options => options[:options],
+            :download_only => options[:download_only]
+          )
         when :remove
           package_manager.remove(packages, :assumeyes => options[:assumeyes])
         else

data/lib/foreman_maintain/executable.rb

@@ -138,7 +138,11 @@ module ForemanMaintain
     def __run__(execution)
       setup_execution_state(execution)
       unless skipped?
-        run
+        if defined?(self.class.present?)
+          run if self.class.present?
+        else
+          run
+        end
       end
     rescue Error::Skip => e
       set_skip(e.message)

data/lib/foreman_maintain/package_manager/apt.rb

@@ -19,10 +19,12 @@ module ForemanMaintain::PackageManager
       apt_action('remove', packages, :assumeyes => assumeyes)
     end
 
-    def update(packages = [], assumeyes: false)
+    # rubocop:disable Lint/UnusedMethodArgument
+    def update(packages = [], assumeyes: false, options: [], download_only: false)
       action = packages.any? ? '--only-upgrade install' : 'upgrade'
-      apt_action(action, packages, :assumeyes => assumeyes)
+      apt_action(action, packages, :assumeyes => assumeyes, :download_only => download_only)
     end
+    # rubocop:enable Lint/UnusedMethodArgument
 
     def clean_cache(assumeyes: false)
       apt_action('clean', :assumeyes => assumeyes)
@@ -60,10 +62,18 @@ module ForemanMaintain::PackageManager
       false
     end
 
-    def apt_action(action, packages, with_status: false, assumeyes: false, valid_exit_statuses: [0])
+    def reboot_required?
+      status = File.exist?('/var/run/reboot-required') ? 1 : 0
+      output = ''
+      [status, output]
+    end
+
+    # rubocop:disable Layout/LineLength
+    def apt_action(action, packages, with_status: false, assumeyes: false, valid_exit_statuses: [0], download_only: false)
       apt_options = []
       packages = [packages].flatten(1)
       apt_options << '-y' if assumeyes
+      apt_options << '--download-only' if download_only
       apt_options_s = apt_options.empty? ? '' : ' ' + apt_options.join(' ')
       packages_s = packages.empty? ? '' : ' ' + packages.join(' ')
       if with_status
@@ -74,5 +84,6 @@ module ForemanMaintain::PackageManager
           :interactive => !assumeyes, :valid_exit_statuses => valid_exit_statuses)
       end
     end
+    # rubocop:enable Layout/LineLength
   end
 end

data/lib/foreman_maintain/package_manager/dnf.rb

@@ -59,8 +59,14 @@ module ForemanMaintain::PackageManager
       dnf_action('remove', packages, assumeyes: assumeyes)
     end
 
-    def update(packages = [], assumeyes: false, dnf_options: [])
-      dnf_action('update', packages, assumeyes: assumeyes, dnf_options: dnf_options)
+    def update(packages = [], assumeyes: false, options: [], download_only: false)
+      dnf_action(
+        'update',
+        packages,
+        assumeyes: assumeyes,
+        dnf_options: options,
+        download_only: download_only
+      )
     end
 
     def check_update(packages: nil, with_status: false)
@@ -121,13 +127,18 @@ module ForemanMaintain::PackageManager
       dnf_action('module info', name, with_status: true, assumeyes: true)
     end
 
+    def reboot_required?
+      sys.execute_with_status('dnf needs-restarting --reboothint', :interactive => false)
+    end
+
     private
 
-    # rubocop:disable Metrics/LineLength, Metrics/ParameterLists
-    def dnf_action(action, packages, with_status: false, assumeyes: false, dnf_options: [], valid_exit_statuses: [0])
+    # rubocop:disable Layout/LineLength, Metrics/ParameterLists
+    def dnf_action(action, packages, with_status: false, assumeyes: false, dnf_options: [], valid_exit_statuses: [0], download_only: false)
       packages = [packages].flatten(1)
 
       dnf_options << '-y' if assumeyes
+      dnf_topions << '--downloadonly' if download_only
       dnf_options << '--disableplugin=foreman-protector'
 
       command = ['dnf', dnf_options.join(' '), action]
@@ -148,7 +159,7 @@ module ForemanMaintain::PackageManager
         )
       end
     end
-    # rubocop:enable Metrics/LineLength, Metrics/ParameterLists
+    # rubocop:enable Layout/LineLength, Metrics/ParameterLists
 
     def protector_config
       File.exist?(protector_config_file) ? File.read(protector_config_file) : ''

data/lib/foreman_maintain/scenario.rb

@@ -163,14 +163,14 @@ module ForemanMaintain
       scenarios
     end
 
-    def add_steps(steps)
-      steps.each do |step|
+    def add_steps(*steps)
+      steps.flatten.each do |step|
         self.steps << step.ensure_instance
       end
     end
 
     def add_step(step)
-      add_steps([step]) unless step.nil?
+      add_steps(step) unless step.nil?
     end
 
     def add_step_with_context(definition, extra_params = {})

data/lib/foreman_maintain/update_runner.rb

@@ -0,0 +1,156 @@
+module ForemanMaintain
+  class UpdateRunner < Runner
+    include Concerns::Finders
+
+    PHASES = [
+      :pre_update_checks,
+      :pre_migrations,
+      :migrations,
+      :post_migrations,
+      :post_update_checks,
+    ].freeze
+
+    attr_reader :phase
+
+    def initialize(reporter, options = {})
+      super(reporter, [], options)
+      @scenario_cache = {}
+      self.phase = :pre_update_checks
+    end
+
+    def find_scenario(phase)
+      return @scenario_cache[phase] if @scenario_cache.key?(phase)
+
+      condition = { :tags => [:update_scenario, phase] }
+      matching_scenarios = find_scenarios(condition)
+      @scenario_cache[phase] = matching_scenarios.first
+    end
+
+    def run
+      PHASES.each do |phase|
+        return run_rollback if quit?
+
+        run_phase(phase)
+      end
+
+      finish_update unless quit?
+    end
+
+    def run_rollback
+      # we only are able to rollback from pre_migrations phase
+      if phase == :pre_migrations
+        rollback_pre_migrations
+      end
+    end
+
+    def finish_update
+      @finished = true
+      @reporter.hline
+      @reporter.puts("Update finished.")
+    end
+
+    def storage
+      ForemanMaintain.storage("update")
+    end
+
+    # serializes the state of the run to storage
+    def save
+      if @finished
+        storage.delete(:serialized)
+      else
+        storage[:serialized] = to_hash
+      end
+      storage.save
+    end
+
+    # deserializes the state of the run from the storage
+    def load
+      return unless storage[:serialized]
+
+      load_from_hash(storage[:serialized])
+    end
+
+    def run_phase(phase)
+      scenario = find_scenario(phase)
+      return if scenario.nil? || scenario.steps.empty?
+
+      confirm_scenario(scenario)
+      return if quit?
+
+      self.phase = phase
+      run_scenario(scenario)
+      # if we started from the :pre_update_checks, ensure to ask before
+      # continuing with the rest of the update
+      @ask_to_confirm_update = phase == :pre_update_checks
+    end
+
+    private
+
+    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
+        # prevent the unnecessary confirmation questions
+        @last_scenario = nil
+        @last_scenario_continuation_confirmed = true
+        [:post_migrations, :post_update_checks].each do |phase|
+          run_phase(phase)
+        end
+      end
+      self.phase = :pre_update_checks # rollback finished
+      @reporter.puts("The update failed and system was restored to pre-update state.")
+    end
+
+    def with_non_empty_scenario(phase)
+      next_scenario = scenario(phase)
+      unless next_scenario.nil? || next_scenario.steps.empty?
+        yield next_scenario
+      end
+    end
+
+    def to_hash
+      ret = { :phase => phase, :scenarios => {} }
+      @scenario_cache.each do |key, scenario|
+        ret[:scenarios][key] = scenario.to_hash
+      end
+      ret
+    end
+
+    def load_from_hash(hash)
+      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)
+      end
+    end
+
+    def confirm_scenario(scenario)
+      decision = super(scenario)
+      # we have not asked the user already about next steps
+      if decision.nil? && @ask_to_confirm_update
+        response = reporter.ask_decision(<<-MESSAGE.strip_heredoc.strip)
+            The pre-update checks indicate that the system is ready for update.
+            It's recommended to perform a backup at this stage.
+            Confirm to continue with the modification part of the update
+        MESSAGE
+        if [:no, :quit].include?(response)
+          ask_to_quit
+        end
+      end
+      response
+    ensure
+      @ask_to_confirm_update = false
+    end
+
+    def phase=(phase)
+      raise "Unknown phase #{phase}" unless PHASES.include?(phase)
+
+      @phase = phase
+    end
+  end
+end

data/lib/foreman_maintain/utils/service/systemd.rb

@@ -63,6 +63,14 @@ module ForemanMaintain::Utils
         end
       end
 
+      def matches?(service)
+        if service.is_a? String
+          service == @name || File.fnmatch(service, @name)
+        else
+          super
+        end
+      end
+
       private
 
       def execute(action)

data/lib/foreman_maintain/version.rb

@@ -1,3 +1,3 @@
 module ForemanMaintain
-  VERSION = '1.6.3'.freeze
+  VERSION = '1.6.5'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman_maintain
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.6.5
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-09 00:00:00.000000000 Z
+date: 2024-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clamp
@@ -316,6 +316,7 @@ files:
 - definitions/scenarios/restore.rb
 - definitions/scenarios/self_upgrade.rb
 - definitions/scenarios/services.rb
+- definitions/scenarios/update.rb
 - definitions/scenarios/upgrade_to_capsule_6_16.rb
 - definitions/scenarios/upgrade_to_capsule_6_16_z.rb
 - definitions/scenarios/upgrade_to_foreman_nightly.rb
@@ -346,6 +347,7 @@ files:
 - lib/foreman_maintain/cli/self_upgrade_command.rb
 - lib/foreman_maintain/cli/service_command.rb
 - lib/foreman_maintain/cli/transform_clamp_options.rb
+- lib/foreman_maintain/cli/update_command.rb
 - lib/foreman_maintain/cli/upgrade_command.rb
 - lib/foreman_maintain/concerns/base_database.rb
 - lib/foreman_maintain/concerns/directory_marker.rb
@@ -391,6 +393,7 @@ files:
 - lib/foreman_maintain/runner/stored_execution.rb
 - lib/foreman_maintain/scenario.rb
 - lib/foreman_maintain/top_level_modules.rb
+- lib/foreman_maintain/update_runner.rb
 - lib/foreman_maintain/upgrade_runner.rb
 - lib/foreman_maintain/utils.rb
 - lib/foreman_maintain/utils/backup.rb
@@ -433,7 +436,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.3.27
 signing_key: 
 specification_version: 4
 summary: Foreman maintenance tool belt