foreman_maintain 0.2.1 → 0.2.2

data/definitions/procedures/restore/candlepin_dump.rb

@@ -0,0 +1,30 @@
+module Procedures::Restore
+  class CandlepinDump < ForemanMaintain::Procedure
+    metadata do
+      description 'Restore candlepin postgresql dump from backup'
+      param :backup_dir,
+            'Path to backup directory',
+            :required => true
+      preparation_steps { Checks::Candlepin::DBUp.new }
+      confine do
+        feature(:candlepin_database)
+      end
+    end
+
+    def run
+      backup = ForemanMaintain::Utils::Backup.new(@backup_dir)
+
+      with_spinner('Restoring candlepin postgresql dump') do |spinner|
+        restore_candlepin_dump(backup, spinner)
+      end
+    end
+
+    def restore_candlepin_dump(backup, spinner)
+      if backup.file_map[:candlepin_dump][:present]
+        spinner.update('Restoring candlepin dump')
+        local = feature(:candlepin_database).local?
+        feature(:candlepin_database).restore_dump(backup.file_map[:candlepin_dump][:path], local)
+      end
+    end
+  end
+end

data/definitions/procedures/restore/configs.rb

@@ -0,0 +1,40 @@
+module Procedures::Restore
+  class Configs < ForemanMaintain::Procedure
+    metadata do
+      description 'Restore configs from backup'
+
+      param :backup_dir,
+            'Path to backup directory',
+            :required => true
+    end
+
+    def run
+      backup = ForemanMaintain::Utils::Backup.new(@backup_dir)
+      with_spinner('Resetting') do |spinner|
+        spinner.update('Restoring configs')
+        clean_conflicting_data
+        restore_configs(backup)
+      end
+    end
+
+    def restore_configs(backup)
+      tar_options = {
+        :overwrite => true,
+        :listed_incremental => '/dev/null',
+        :command => 'extract',
+        :directory => '/',
+        :archive => backup.file_map[:config_files][:path],
+        :gzip => true
+      }
+
+      feature(:tar).run(tar_options)
+    end
+
+    private
+
+    def clean_conflicting_data
+      # tar is unable to --overwrite dir with symlink
+      execute('rm -rf /usr/share/foreman-proxy/.ssh')
+    end
+  end
+end

data/definitions/procedures/restore/confirmation.rb

@@ -0,0 +1,17 @@
+module Procedures::Restore
+  class Confirmation < ForemanMaintain::Procedure
+    metadata do
+      description 'Confirm dropping databases and running restore'
+      tags :restore
+    end
+
+    def run
+      warning = "\nWARNING: This script will drop and restore your database.\n" \
+                "Your existing installation will be replaced with the backup database.\n" \
+                "Once this operation is complete there is no going back.\n" \
+                'Do you want to proceed?'
+      answer = ask_decision(warning, 'y(yes), q(quit)')
+      abort! unless answer == :yes
+    end
+  end
+end

data/definitions/procedures/restore/drop_databases.rb

@@ -0,0 +1,39 @@
+module Procedures::Restore
+  class DropDatabases < ForemanMaintain::Procedure
+    metadata do
+      description 'Drop postgresql databases'
+
+      param :backup_dir,
+            'Path to backup directory',
+            :required => true
+
+      confine do
+        feature(:foreman_database) || feature(:candlepin_database)
+      end
+    end
+
+    def run
+      backup = ForemanMaintain::Utils::Backup.new(@backup_dir)
+
+      with_spinner('Dropping databases') do |spinner|
+        feature(:service).handle_services(spinner, 'start', :only => ['postgresql'])
+        drop_foreman(backup, spinner)
+        drop_candlepin(backup, spinner)
+      end
+    end
+
+    def drop_foreman(backup, spinner)
+      if backup.file_map[:foreman_dump][:present]
+        spinner.update('Dropping foreman database')
+        feature(:foreman_database).dropdb
+      end
+    end
+
+    def drop_candlepin(backup, spinner)
+      if backup.file_map[:candlepin_dump][:present]
+        spinner.update('Dropping candlepin database')
+        feature(:candlepin_database).dropdb
+      end
+    end
+  end
+end

data/definitions/procedures/restore/extract_files.rb

@@ -0,0 +1,70 @@
+module Procedures::Restore
+  class ExtractFiles < ForemanMaintain::Procedure
+    metadata do
+      description 'Extract any existing tar files in backup'
+
+      param :backup_dir,
+            'Path to backup directory',
+            :required => true
+    end
+
+    def run
+      backup = ForemanMaintain::Utils::Backup.new(@backup_dir)
+      with_spinner('Extracting Files') do |spinner|
+        if backup.file_map[:pulp_data][:present]
+          spinner.update('Extracting pulp data')
+          extract_pulp_data(backup)
+        end
+        if backup.file_map[:mongo_data][:present]
+          spinner.update('Extracting mongo data')
+          extract_mongo_data(backup)
+        end
+        if backup.file_map[:pgsql_data][:present]
+          spinner.update('Extracting pgsql data')
+          extract_pgsql_data(backup)
+        end
+      end
+    end
+
+    def base_tar
+      {
+        :overwrite => true,
+        :listed_incremental => '/dev/null',
+        :command => 'extract',
+        :directory => '/'
+      }
+    end
+
+    def extract_pulp_data(backup)
+      pulp_data_tar = if backup.pulp_tar_split?
+                        base_tar.merge(
+                          :multi_volume => true,
+                          :split_data => true,
+                          :archive => backup.file_map[:pulp_data][:path]
+                        )
+                      else
+                        base_tar.merge(
+                          :archive => backup.file_map[:pulp_data][:path]
+                        )
+                      end
+
+      feature(:tar).run(pulp_data_tar)
+    end
+
+    def extract_mongo_data(backup)
+      mongo_data_tar = base_tar.merge(
+        :archive => backup.file_map[:mongo_data][:path],
+        :gzip => true
+      )
+      feature(:tar).run(mongo_data_tar)
+    end
+
+    def extract_pgsql_data(backup)
+      pgsql_data_tar = base_tar.merge(
+        :archive => backup.file_map[:pgsql_data][:path],
+        :gzip => true
+      )
+      feature(:tar).run(pgsql_data_tar)
+    end
+  end
+end

data/definitions/procedures/restore/foreman_dump.rb

@@ -0,0 +1,30 @@
+module Procedures::Restore
+  class ForemanDump < ForemanMaintain::Procedure
+    metadata do
+      description 'Restore foreman postgresql dump from backup'
+      param :backup_dir,
+            'Path to backup directory',
+            :required => true
+      preparation_steps { Checks::Foreman::DBUp.new }
+      confine do
+        feature(:foreman_database)
+      end
+    end
+
+    def run
+      backup = ForemanMaintain::Utils::Backup.new(@backup_dir)
+
+      with_spinner('Restoring foreman postgresql dump') do |spinner|
+        restore_foreman_dump(backup, spinner)
+      end
+    end
+
+    def restore_foreman_dump(backup, spinner)
+      if backup.file_map[:foreman_dump][:present]
+        spinner.update('Restoring foreman dump')
+        local = feature(:foreman_database).local?
+        feature(:foreman_database).restore_dump(backup.file_map[:foreman_dump][:path], local)
+      end
+    end
+  end
+end

data/definitions/procedures/restore/installer_reset.rb

@@ -0,0 +1,39 @@
+module Procedures::Restore
+  class InstallerReset < ForemanMaintain::Procedure
+    metadata do
+      description 'Run installer reset'
+
+      param :incremental_backup,
+            'Is the backup incremental?'
+    end
+
+    def run
+      with_spinner('Resetting') do |spinner|
+        if @incremental_backup
+          spinner.update('Skipping installer reset for incremental update')
+        else
+          spinner.update('Installer reset')
+          execute!(installer_cmd)
+        end
+      end
+    end
+
+    def installer_cmd
+      installer = "yes | #{feature(:installer).installer_command} "
+      installer << '-v --reset '
+      if feature(:instance).foreman_proxy_with_content?
+        installer << '--foreman-proxy-register-in-foreman false '
+      end
+
+      # We always disable system checks to avoid unnecessary errors. The installer should have
+      # already ran since this is to be run on an existing system, which means installer checks
+      # has already been skipped
+      if feature(:foreman_proxy) &&
+         feature(:foreman_proxy).with_content? &&
+         check_min_version('katello-installer-base', '3.2.0')
+        installer << '--disable-system-checks '
+      end
+      installer
+    end
+  end
+end

data/definitions/procedures/restore/mongo_dump.rb

@@ -0,0 +1,41 @@
+module Procedures::Restore
+  class MongoDump < ForemanMaintain::Procedure
+    metadata do
+      description 'Restore mongo dump'
+      for_feature :pulp
+      param :backup_dir,
+            'Path to backup directory',
+            :required => true
+      preparation_steps do
+        [Checks::Mongo::DBUp.new, Checks::Mongo::ToolsInstalled.new]
+      end
+      confine do
+        feature(:mongo) && feature(:pulp)
+      end
+    end
+
+    def run
+      backup = ForemanMaintain::Utils::Backup.new(@backup_dir)
+      with_spinner('Restoring mongo dump') do |spinner|
+        handle_mongo_service('start', spinner)
+        drop_and_restore_mongo(backup, spinner)
+        handle_mongo_service('stop', spinner)
+      end
+    end
+
+    def handle_mongo_service(action, spinner)
+      if feature(:instance).database_local?(:mongo)
+        feature(:service).handle_services(spinner, action,
+                                          :only => feature(:mongo).services.keys)
+      end
+    end
+
+    def drop_and_restore_mongo(backup, spinner)
+      spinner.update('Dropping pulp_database')
+      feature(:mongo).dropdb
+
+      spinner.update('Restoring mongo dump')
+      feature(:mongo).restore(backup.file_map[:mongo_dump][:path])
+    end
+  end
+end

data/definitions/procedures/restore/pg_global_objects.rb

@@ -0,0 +1,36 @@
+module Procedures::Restore
+  class PgGlobalObjects < ForemanMaintain::Procedure
+    include ForemanMaintain::Concerns::SystemHelpers
+
+    metadata do
+      description 'Restore any existing postgresql global objects from backup'
+
+      param :backup_dir,
+            'Path to backup directory',
+            :required => true
+
+      confine do
+        feature(:foreman_database) || feature(:candlepin_database)
+      end
+    end
+
+    def run
+      backup = ForemanMaintain::Utils::Backup.new(@backup_dir)
+      restore_global_objects(backup.file_map[:pg_globals][:path])
+    end
+
+    def restore_global_objects(pg_global_file)
+      if feature(:instance).postgresql_local?
+        with_spinner('') do |spinner|
+          feature(:service).handle_services(spinner, 'start', :only => ['postgresql'])
+
+          spinner.update('Restoring postgresql global objects')
+          local_db = feature(:foreman_database).local? ? :foreman_database : :candlepin_database
+          feature(local_db).restore_pg_globals(pg_global_file)
+        end
+      else
+        skip 'Restore of global objects is not supported for remote databases.'
+      end
+    end
+  end
+end

data/definitions/procedures/restore/postgres_owner.rb

@@ -0,0 +1,18 @@
+module Procedures::Restore
+  class PostgresOwner < ForemanMaintain::Procedure
+    include ForemanMaintain::Concerns::SystemHelpers
+    metadata do
+      description 'Make postgres owner of backup directory'
+
+      param :backup_dir,
+            'Path to backup directory',
+            :required => true
+    end
+
+    def run
+      if feature(:instance).foreman_proxy_with_content?
+        FileUtils.chown(nil, 'postgres', @backup_dir)
+      end
+    end
+  end
+end

data/definitions/procedures/selinux/set_file_security.rb

@@ -0,0 +1,22 @@
+module Procedures::Selinux
+  class SetFileSecurity < ForemanMaintain::Procedure
+    metadata do
+      description 'Setting file security'
+
+      param :incremental_backup,
+            'Is the backup incremental?',
+            :required => true
+      manual_detection
+    end
+
+    def run
+      with_spinner('Restoring SELinux context') do |spinner|
+        if @incremental_backup
+          spinner.update('Skipping for incremental update')
+        else
+          execute!('restorecon -Rn /')
+        end
+      end
+    end
+  end
+end

data/definitions/procedures/service/daemon_reload.rb

@@ -0,0 +1,18 @@
+module Procedures::Service
+  class DaemonReload < ForemanMaintain::Procedure
+    include ForemanMaintain::Concerns::SystemHelpers
+    metadata do
+      description 'Run daemon reload'
+
+      confine do
+        systemd_installed?
+      end
+    end
+
+    def run
+      unless feature(:instance).foreman_proxy_with_content?
+        execute!('systemctl daemon-reload')
+      end
+    end
+  end
+end

data/definitions/procedures/service/restart.rb

@@ -28,11 +28,11 @@ module Procedures::Service
             break
           elsif retry_count < (RETRIES_FOR_SERVICES_RESTART - 1)
             apply_sleep_before_retry(spinner, result)
+          else
+            raise 'Hammer ping failed!'
           end
         end
       end
-    rescue StandardError => e
-      logger.error e.message
     end
 
     def retry_message(retry_count)

data/definitions/scenarios/restore.rb

@@ -0,0 +1,91 @@
+require 'foreman_maintain/utils/backup'
+
+module ForemanMaintain::Scenarios
+  class Restore < ForemanMaintain::Scenario
+    metadata do
+      description 'Restore backup'
+      param :backup_dir, 'Path to backup directory'
+      param :incremental_backup, 'Is the backup incremental?'
+      manual_detection
+    end
+
+    # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+    def compose
+      backup = ForemanMaintain::Utils::Backup.new(context.get(:backup_dir))
+
+      add_steps(find_checks(:root_user))
+      supported_version_check
+      add_steps_with_context(Checks::Restore::ValidateBackup,
+                             Procedures::Restore::Confirmation,
+                             Checks::Restore::ValidateHostname,
+                             Procedures::Selinux::SetFileSecurity,
+                             Procedures::Restore::Configs,
+                             Procedures::Restore::InstallerReset,
+                             Procedures::Service::Stop)
+      add_steps_with_context(Procedures::Restore::ExtractFiles) if backup.tar_backups_exist?
+      drop_dbs(backup)
+      if backup.sql_dump_files_exist? && feature(:instance).postgresql_local?
+        add_step(Procedures::Service::Start.new(:only => ['postgresql']))
+      end
+      restore_sql_dumps(backup)
+      if backup.sql_dump_files_exist? && feature(:instance).postgresql_local?
+        add_step(Procedures::Service::Stop.new(:only => ['postgresql']))
+      end
+      restore_mongo_dump(backup)
+      add_steps_with_context(Procedures::Pulp::Migrate,
+                             Procedures::Service::Start,
+                             Procedures::Service::DaemonReload)
+    end
+    # rubocop:enable Metrics/MethodLength,Metrics/AbcSize
+
+    def drop_dbs(backup)
+      if backup.file_map[:candlepin_dump][:present] ||
+         backup.file_map[:foreman_dump][:present]
+        add_steps_with_context(Procedures::Restore::DropDatabases)
+      end
+    end
+
+    def restore_sql_dumps(backup)
+      if backup.file_map[:pg_globals][:present]
+        add_steps_with_context(Procedures::Restore::PgGlobalObjects)
+      end
+      if backup.file_map[:candlepin_dump][:present]
+        add_steps_with_context(Procedures::Restore::CandlepinDump)
+      end
+      if backup.file_map[:foreman_dump][:present]
+        add_steps_with_context(Procedures::Restore::ForemanDump)
+      end
+    end
+
+    def restore_mongo_dump(backup)
+      if backup.file_map[:mongo_dump][:present]
+        add_steps_with_context(Procedures::Restore::MongoDump)
+      end
+    end
+
+    def supported_version_check
+      if feature(:downstream) && feature(:downstream).less_than_version?('6.3')
+        msg = 'ERROR: Restore subcommand is supported by Satellite 6.3+. ' \
+              'Please use katello-restore instead.'
+        abort(msg)
+      end
+    end
+
+    def set_context_mapping
+      context.map(:backup_dir,
+                  Checks::Restore::ValidateBackup => :backup_dir,
+                  Checks::Restore::ValidateHostname => :backup_dir,
+                  Procedures::Restore::Configs => :backup_dir,
+                  Procedures::Restore::DropDatabases => :backup_dir,
+                  Procedures::Restore::PgGlobalObjects => :backup_dir,
+                  Procedures::Restore::CandlepinDump => :backup_dir,
+                  Procedures::Restore::ForemanDump => :backup_dir,
+                  Procedures::Restore::ExtractFiles => :backup_dir,
+                  Procedures::Restore::MongoDump => :backup_dir)
+
+      context.map(:incremental_backup,
+                  Procedures::Selinux::SetFileSecurity => :incremental_backup,
+                  Procedures::Restore::InstallerReset => :incremental_backup)
+    end
+  end
+end