foreman_maintain 0.6.0 → 0.6.5

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/packages_command.rb

@@ -38,7 +38,7 @@ module ForemanMaintain
 
       subcommand 'update', 'Update packages in an unlocked session' do
         interactive_option
-        parameter 'PACKAGES ...', 'packages to update', :attribute_name => :packages
+        parameter '[PACKAGES ...]', 'packages to update', :attribute_name => :packages
 
         def execute
           run_scenarios_and_exit(

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

@@ -87,8 +87,7 @@ module ForemanMaintain
                  else
                    "rhel-#{rh_version_major}-server-#{package_name}-#{full_version}-rpms"
                  end
-
-        if current_minor_version == '6.3' && server_version.to_s != '6.4' && (
+        if current_minor_version == '6.3' && full_version.to_s != '6.4' && (
           feature(:puppet_server) && feature(:puppet_server).puppet_version.major == 4)
           # TODO: confirm repo for capsule. It might be same repo
           repos << "rhel-#{rh_version_major}-server-satellite-tools-6.3-puppet4-rpms"
@@ -98,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/feature.rb

@@ -41,5 +41,9 @@ module ForemanMaintain
     def config_files_to_exclude
       []
     end
+
+    def config_files_exclude_for_online
+      []
+    end
   end
 end

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
 
@@ -184,9 +184,9 @@ module ForemanMaintain
         ask_to_select('Select step to continue', steps, &:runtime_message)
       end
 
-      def ask_decision(message, options = 'y(yes), n(no), q(quit)')
-        if assumeyes?
-          print("#{message} (assuming yes)")
+      def ask_decision(message, options = 'y(yes), n(no), q(quit)', ignore_assumeyes: false)
+        if !ignore_assumeyes && assumeyes?
+          print("#{message} (assuming yes)\n")
           return :yes
         end
         until_valid_decision do

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

data/lib/foreman_maintain/utils/backup.rb

@@ -16,6 +16,9 @@ module ForemanMaintain
         @backup_dir = backup_dir
         @standard_files = ['config_files.tar.gz']
         @katello_online_files = ['mongo_dump', 'candlepin.dump', 'foreman.dump']
+        if feature(:pulpcore)
+          @katello_online_files << 'pulpcore.dump'
+        end
         @katello_offline_files = ['mongo_data.tar.gz', 'pgsql_data.tar.gz']
         @foreman_online_files = ['foreman.dump']
         @foreman_offline_files = ['pgsql_data.tar.gz']
@@ -35,6 +38,10 @@ module ForemanMaintain
           :pg_globals => map_file(@backup_dir, 'pg_globals.dump'),
           :metadata => map_file(@backup_dir, 'metadata.yml')
         }
+        if feature(:pulpcore)
+          @file_map[:pulpcore_dump] = map_file(@backup_dir, 'pulpcore.dump')
+        end
+        @file_map
       end
 
       def map_file(backup_dir, filename)
@@ -77,92 +84,80 @@ module ForemanMaintain
         foreman_standard_backup? || foreman_online_backup? || foreman_logical_backup?
       end
 
+      def check_file_existence(existence_map)
+        unless feature(:pulpcore)
+          existence_map[:present].delete(:pulpcore_dump)
+          existence_map[:absent].delete(:pulpcore_dump)
+        end
+
+        existence_map[:present].each do |file|
+          unless file_map[file][:present]
+            return false
+          end
+        end
+
+        existence_map[:absent].each do |file|
+          if file_map[file][:present]
+            return false
+          end
+        end
+
+        true
+      end
+
+      # TODO: Need to check for pulpcore feature?
       def katello_standard_backup?
-        file_map[:mongo_data][:present] &&
-          file_map[:pgsql_data][:present] &&
-          !(
-            file_map[:candlepin_dump][:present] ||
-            file_map[:foreman_dump][:present] ||
-            file_map[:mongo_dump][:present]
-          )
+        check_file_existence(:present => [:mongo_data, :pgsql_data],
+                             :absent => [:candlepin_dump, :foreman_dump,
+                                         :pulpcore_dump, :mongo_dump])
       end
 
       def katello_online_backup?
-        file_map[:candlepin_dump][:present] &&
-          file_map[:foreman_dump][:present] &&
-          file_map[:mongo_dump][:present] &&
-          !(
-            file_map[:mongo_data][:present] ||
-            file_map[:pgsql_data][:present]
-          )
+        check_file_existence(:present => [:candlepin_dump, :foreman_dump,
+                                          :pulpcore_dump, :mongo_dump],
+                             :absent => [:mongo_data, :pgsql_data])
       end
 
       def katello_logical_backup?
-        file_map[:mongo_dump][:present] &&
-          file_map[:mongo_data][:present] &&
-          file_map[:pgsql_data][:present] &&
-          file_map[:candlepin_dump][:present] &&
-          file_map[:foreman_dump][:present]
+        check_file_existence(:present => [:mongo_dump, :mongo_data, :pgsql_data,
+                                          :candlepin_dump, :pulpcore_dump, :foreman_dump],
+                             :absent => [])
       end
 
       def fpc_standard_backup?
-        file_map[:mongo_data][:present] &&
-          !(
-            file_map[:pgsql_data][:present] ||
-            file_map[:candlepin_dump][:present] ||
-            file_map[:foreman_dump][:present] ||
-            file_map[:mongo_dump][:present]
-          )
+        check_file_existence(:present => [:mongo_data],
+                             :absent => [:pgsql_data, :candlepin_dump,
+                                         :foreman_dump, :mongo_dump, :pulpcore_dump])
       end
 
       def fpc_online_backup?
-        file_map[:mongo_dump][:present] &&
-          !(
-            file_map[:mongo_data][:present] ||
-            file_map[:pgsql_data][:present] ||
-            file_map[:candlepin_dump][:present] ||
-            file_map[:foreman_dump][:present]
-          )
+        absent = [:mongo_data, :pgsql_data, :candlepin_dump, :foreman_dump]
+
+        check_file_existence(:present => [:mongo_dump], :absent => absent) ||
+          check_file_existence(:present => [:pulpcore_dump], :absent => absent)
       end
 
       def fpc_logical_backup?
-        file_map[:mongo_dump][:present] &&
-          file_map[:mongo_data][:present] &&
-          !(
-            file_map[:pgsql_data][:present] ||
-            file_map[:candlepin_dump][:present] ||
-            file_map[:foreman_dump][:present]
-          )
+        absent = [:pgsql_data, :candlepin_dump, :foreman_dump]
+        check_file_existence(:present => [:mongo_dump, :mongo_data], :absent => absent) ||
+          check_file_existence(:present => [:pulpcore_dump], :absent => absent)
       end
 
       def foreman_standard_backup?
-        file_map[:pgsql_data][:present] &&
-          !(
-            file_map[:candlepin_dump][:present] ||
-            file_map[:foreman_dump][:present] ||
-            file_map[:mongo_data][:present] ||
-            file_map[:mongo_dump][:present]
-          )
+        check_file_existence(:present => [:pgsql_data],
+                             :absent => [:candlepin_dump, :foreman_dump, :pulpcore_dump,
+                                         :mongo_data, :mongo_dump])
       end
 
       def foreman_online_backup?
-        file_map[:foreman_dump][:present] &&
-          !(
-            file_map[:candlepin_dump][:present] ||
-            file_map[:pgsql_data][:present] ||
-            file_map[:mongo_data][:present] ||
-            file_map[:mongo_dump][:present]
-          )
+        check_file_existence(:present => [:foreman_dump],
+                             :absent => [:candlepin_dump, :pgsql_data,
+                                         :mongo_data, :mongo_dump])
       end
 
       def foreman_logical_backup?
-        file_map[:pgsql_data][:present] &&
-          file_map[:foreman_dump][:present] &&
-          !(
-            file_map[:candlepin_dump][:present] ||
-            file_map[:mongo_data][:present] ||
-            file_map[:mongo_dump][:present]
-          )
+        check_file_existence(:present => [:pgsql_data, :foreman_dump],
+                             :absent => [:candlepin_dump, :mongo_data, :mongo_dump])
       end
 
       def validate_hostname?
@@ -202,12 +197,17 @@ module ForemanMaintain
 
       def sql_dump_files_exist?
         file_map[:foreman_dump][:present] ||
-          file_map[:candlepin_dump][:present]
+          file_map[:candlepin_dump][:present] ||
+          (feature(:pulpcore) && file_map[:pulpcore_dump][:present])
       end
 
       def incremental?
         !!metadata.fetch('incremental', false)
       end
+
+      def online_backup?
+        !!metadata.fetch('online', false)
+      end
     end
   end
 end