foreman_maintain 1.3.0 → 1.3.2

data/lib/foreman_maintain/config.rb

@@ -2,17 +2,17 @@ require 'fileutils'
 module ForemanMaintain
   class Config
     attr_accessor :pre_setup_log_messages,
-                  :config_file, :definitions_dirs, :log_level, :log_dir, :log_file_size,
-                  :log_filename, :storage_file, :backup_dir, :foreman_proxy_cert_path,
-                  :db_backup_dir, :completion_cache_file, :disable_commands, :manage_crond,
-                  :foreman_url, :foreman_port
+      :config_file, :definitions_dirs, :log_level, :log_dir, :log_file_size,
+      :log_filename, :storage_file, :backup_dir, :foreman_proxy_cert_path,
+      :db_backup_dir, :completion_cache_file, :disable_commands, :manage_crond,
+      :foreman_url, :foreman_port
 
     def initialize(options)
       @pre_setup_log_messages = []
       @config_file = options.fetch(:config_file, config_file_path)
       @options = load_config
       @definitions_dirs = @options.fetch(:definitions_dirs,
-                                         [File.join(source_path, 'definitions')])
+        [File.join(source_path, 'definitions')])
       load_log_configs
       load_backup_dir_paths
       load_cron_option
@@ -28,7 +28,7 @@ module ForemanMaintain
     private
 
     def load_log_configs
-      @log_level = @options.fetch(:log_level, ::Logger::DEBUG)
+      @log_level = @options.fetch(:log_level, ::Logger::INFO)
       @log_dir = find_dir_path(@options.fetch(:log_dir, 'log'))
       @log_file_size = @options.fetch(:log_file_size, 10_000)
       # Note - If timestamp added to filename then number of log files i.e second
@@ -68,7 +68,7 @@ module ForemanMaintain
     end
 
     def source_path
-      File.expand_path('../../..', __FILE__)
+      File.expand_path('../..', __dir__)
     end
 
     def find_dir_path(dir_path_str)

data/lib/foreman_maintain/core_ext.rb

@@ -10,7 +10,7 @@ module ForemanMaintain
         gsub(/^[ \t]{#{indent}}/, '')
       end
     end
-    String.send(:include, StripHeredoc)
+    String.include StripHeredoc
 
     module ValidateOptions
       def validate_options!(*valid_keys)
@@ -23,6 +23,6 @@ module ForemanMaintain
         self
       end
     end
-    Hash.send(:include, ValidateOptions)
+    Hash.include ValidateOptions
   end
 end

data/lib/foreman_maintain/executable.rb

@@ -3,10 +3,11 @@ module ForemanMaintain
     extend Forwardable
     extend Concerns::Finders
     attr_reader :options
+
     def_delegators :execution,
-                   :success?, :skipped?, :fail?, :aborted?, :warning?, :output,
-                   :assumeyes?, :whitelisted?, :ask_decision,
-                   :execution, :puts, :print, :with_spinner, :ask, :storage
+      :success?, :skipped?, :fail?, :aborted?, :warning?, :output,
+      :assumeyes?, :whitelisted?, :ask_decision,
+      :execution, :puts, :print, :with_spinner, :ask, :storage
 
     def initialize(options = {})
       @options = options.inject({}) { |h, (k, v)| h.update(k.to_s => v) }
@@ -26,7 +27,8 @@ module ForemanMaintain
     end
 
     # public method to be overriden to perform after-initialization steps
-    def after_initialize; end
+    def after_initialize
+    end
 
     # processes the params from provided options
     def setup_params
@@ -113,11 +115,7 @@ module ForemanMaintain
     end
 
     def execution
-      if @_execution
-        @_execution
-      else
-        raise 'Trying to get execution information before the run started happened'
-      end
+      @_execution || raise('Trying to get execution information before the run started happened')
     end
 
     # public method to be overriden: it can perform additional checks

data/lib/foreman_maintain/package_manager/apt.rb

@@ -68,10 +68,10 @@ module ForemanMaintain::PackageManager
       packages_s = packages.empty? ? '' : ' ' + packages.join(' ')
       if with_status
         sys.execute_with_status("apt-get#{apt_options_s} #{action}#{packages_s}",
-                                :interactive => !assumeyes)
+          :interactive => !assumeyes)
       else
         sys.execute!("apt-get#{apt_options_s} #{action}#{packages_s}",
-                     :interactive => !assumeyes, :valid_exit_statuses => valid_exit_statuses)
+          :interactive => !assumeyes, :valid_exit_statuses => valid_exit_statuses)
       end
     end
   end

data/lib/foreman_maintain/package_manager/base.rb

@@ -1,5 +1,4 @@
 module ForemanMaintain::PackageManager
-  # rubocop:disable Lint/UnusedMethodArgument
   class Base
     # confirms that Package Manager supports the locking mechanism
     def version_locking_supported?
@@ -62,5 +61,4 @@ module ForemanMaintain::PackageManager
       ForemanMaintain::Utils::SystemHelpers
     end
   end
-  # rubocop:enable Lint/UnusedMethodArgument
 end

data/lib/foreman_maintain/package_manager/dnf.rb

@@ -35,10 +35,10 @@ module ForemanMaintain::PackageManager
       yum_options << '-y' if assumeyes
       if with_status
         sys.execute_with_status("dnf #{yum_options.join(' ')} #{action} #{packages.join(' ')}",
-                                :interactive => !assumeyes)
+          :interactive => !assumeyes)
       else
         sys.execute!("dnf #{yum_options.join(' ')} #{action} #{packages.join(' ')}",
-                     :interactive => !assumeyes)
+          :interactive => !assumeyes)
 
       end
     end

data/lib/foreman_maintain/package_manager/yum.rb

@@ -68,7 +68,7 @@ module ForemanMaintain::PackageManager
     end
 
     def check_update(packages: nil, with_status: false)
-      yum_action('check-update', packages, :assumeyes => true, :valid_exit_statuses => [100],
+      yum_action('check-update', packages, :assumeyes => true, :valid_exit_statuses => [0, 100],
                                            :with_status => with_status)
     end
 
@@ -120,7 +120,6 @@ module ForemanMaintain::PackageManager
       File.open(protector_config_file, 'w') { |file| file.puts config }
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def yum_action(action, packages, options)
       with_status = options.fetch(:with_status, false)
       assumeyes = options.fetch(:assumeyes, false)
@@ -133,10 +132,10 @@ module ForemanMaintain::PackageManager
       packages_s = packages.empty? ? '' : ' ' + packages.join(' ')
       if with_status
         sys.execute_with_status("yum#{yum_options_s} #{action}#{packages_s}",
-                                :interactive => !assumeyes)
+          :interactive => !assumeyes)
       else
         sys.execute!("yum#{yum_options_s} #{action}#{packages_s}",
-                     :interactive => !assumeyes, :valid_exit_statuses => valid_exit_statuses)
+          :interactive => !assumeyes, :valid_exit_statuses => valid_exit_statuses)
       end
     end
   end

data/lib/foreman_maintain/package_manager.rb

@@ -5,14 +5,12 @@ require 'foreman_maintain/package_manager/apt'
 
 module ForemanMaintain
   def self.package_manager
-    @package_manager ||= if el7?
-                           ForemanMaintain::PackageManager::Yum.new
-                         elsif el?
-                           ForemanMaintain::PackageManager::Dnf.new
-                         elsif debian_or_ubuntu?
-                           ForemanMaintain::PackageManager::Apt.new
-                         else
-                           raise 'No supported package manager was found'
-                         end
+    if el?
+      ForemanMaintain::PackageManager::Dnf.new
+    elsif debian_or_ubuntu?
+      ForemanMaintain::PackageManager::Apt.new
+    else
+      raise 'No supported package manager was found'
+    end
   end
 end

data/lib/foreman_maintain/param.rb

@@ -4,7 +4,7 @@ module ForemanMaintain
 
     def initialize(name, description, options, &block)
       options.validate_options!(:description, :required, :flag, :array,
-                                :allowed_values, :default)
+        :allowed_values, :default)
       @name = name
       @description = description || options[:description] || ''
       @options = options
@@ -63,7 +63,7 @@ module ForemanMaintain
       return if within_allowed
       error_msg = "'#{value}' not allowed for #{name} param."
       raise ForemanMaintain::Error::UsageError,
-            "#{error_msg} Possible values are #{@allowed_values.join(', ')}"
+        "#{error_msg} Possible values are #{@allowed_values.join(', ')}"
     end
   end
 end

data/lib/foreman_maintain/reporter/cli_reporter.rb

@@ -1,4 +1,3 @@
-require 'thread'
 require 'highline'
 
 module ForemanMaintain
@@ -73,7 +72,7 @@ module ForemanMaintain
       attr_accessor :select_option_counter
       attr_reader :last_line, :max_length
 
-      def initialize(stdout = STDOUT, stdin = STDIN, options = {})
+      def initialize(stdout = $stdout, stdin = $stdin, options = {})
         @stdout = stdout
         @stdin = stdin
         options.validate_options!(:assumeyes)
@@ -127,9 +126,9 @@ module ForemanMaintain
         @new_line_next_time = false
         @last_line = ''
         # add space at the end as otherwise highline would add new line there :/
-        message = "#{message} " unless message =~ /\s\Z/
+        message = "#{message} " unless /\s\Z/.match?(message)
         answer = @hl.ask(message) { |q| q.echo = false if options[:password] }
-        answer.to_s.chomp if answer
+        answer&.to_s&.chomp
       end
 
       def new_line_if_needed
@@ -179,7 +178,7 @@ module ForemanMaintain
 
       def single_step_decision(step, run_strategy)
         answer = ask_decision("Continue with step [#{step.runtime_message}]?",
-                              run_strategy: run_strategy)
+          run_strategy: run_strategy)
         if answer == :yes
           step
         else
@@ -339,13 +338,13 @@ module ForemanMaintain
 
               In case the failures are false positives, use
               --whitelist="%s"
-              MESSAGE
+                           MESSAGE
                          else
                            format(<<-MESSAGE.strip_heredoc, whitelist_labels)
               Resolve the failed steps and rerun the command.
               In case the failures are false positives, use
               --whitelist="%s"
-              MESSAGE
+                           MESSAGE
                          end
           end
         end

data/lib/foreman_maintain/reporter.rb

@@ -10,17 +10,21 @@ module ForemanMaintain
     DECISION_MAPPER = {
       %w[y yes] => :yes,
       %w[n next no] => :no,
-      %w[q quit] => :quit
+      %w[q quit] => :quit,
     }.freeze
 
     # Each public method is a hook called by executor at the specific point
-    def before_scenario_starts(_scenario, _last_scenario = nil); end
+    def before_scenario_starts(_scenario, _last_scenario = nil)
+    end
 
-    def before_execution_starts(_execution); end
+    def before_execution_starts(_execution)
+    end
 
-    def after_execution_finishes(_execution); end
+    def after_execution_finishes(_execution)
+    end
 
-    def after_scenario_finishes(_scenario); end
+    def after_scenario_finishes(_scenario)
+    end
 
     def on_next_steps(steps, run_strategy = :fail_fast)
       return if steps.empty?
@@ -36,11 +40,14 @@ module ForemanMaintain
       yield DummySpinner.new
     end
 
-    def print(_message); end
+    def print(_message)
+    end
 
-    def puts(_message); end
+    def puts(_message)
+    end
 
-    def ask(_message); end
+    def ask(_message)
+    end
 
     def assumeyes?
       @assumeyes
@@ -100,7 +107,6 @@ module ForemanMaintain
       decision
     end
 
-    # rubocop:disable Metrics/MethodLength
     def ask_to_select(message, steps, run_strategy)
       if assumeyes?
         puts('(assuming first option)')
@@ -122,7 +128,6 @@ module ForemanMaintain
         end
       end
     end
-    # rubocop:enable Metrics/MethodLength
 
     # loop over the block until it returns some non-false value
     def until_valid_decision

data/lib/foreman_maintain/repository_manager/el.rb

@@ -4,11 +4,7 @@ module ForemanMaintain::RepositoryManager
     include ForemanMaintain::Concerns::SystemHelpers
 
     def disable_repos(repo_ids)
-      if el7?
-        execute!("yum-config-manager #{config_manager_options(repo_ids, 'disable')}")
-      else
-        execute!("dnf config-manager #{config_manager_options(repo_ids, 'set-disabled')}")
-      end
+      execute!("dnf config-manager #{config_manager_options(repo_ids, 'set-disabled')}")
     end
 
     def rhsm_disable_repos(repo_ids)
@@ -22,11 +18,7 @@ module ForemanMaintain::RepositoryManager
     end
 
     def enable_repos(repo_ids)
-      if el7?
-        execute!("yum-config-manager #{config_manager_options(repo_ids, 'enable')}")
-      else
-        execute!("dnf config-manager #{config_manager_options(repo_ids, 'enable')}")
-      end
+      execute!("dnf config-manager #{config_manager_options(repo_ids, 'enable')}")
     end
 
     def rhsm_enable_repos(repo_ids)

data/lib/foreman_maintain/repository_manager.rb

@@ -1,6 +1,7 @@
 require 'foreman_maintain/repository_manager/el'
-include ForemanMaintain::Concerns::OsFacts
 module ForemanMaintain
+  extend ForemanMaintain::Concerns::OsFacts
+
   def self.repository_manager
     @repository_manager ||= if el?
                               ForemanMaintain::RepositoryManager::El.new

data/lib/foreman_maintain/runner.rb

@@ -78,7 +78,7 @@ module ForemanMaintain
                  elsif @last_scenario.steps_with_warning(:whitelisted => false).any?
                    @last_scenario_continuation_confirmed = true
                    reporter.ask_decision("Continue with [#{scenario.description}]",
-                                         run_strategy: scenario.run_strategy)
+                     run_strategy: scenario.run_strategy)
                  end
 
       ask_to_quit if [:quit, :no].include?(decision)
@@ -93,7 +93,7 @@ module ForemanMaintain
     def add_steps(*steps)
       # we we add the steps at the beginning, but still keeping the
       # order of steps passed in the arguments
-      steps.reverse.each do |step|
+      steps.reverse_each do |step|
         @steps_to_run.unshift(step)
       end
     end
@@ -125,9 +125,9 @@ module ForemanMaintain
     def run_step(step)
       @reporter.puts('Rerunning the check after fix procedure') if rerun_check?(step)
       execution = Execution.new(step, @reporter,
-                                :whitelisted => whitelisted_step?(step),
-                                :storage => storage,
-                                :force => @force)
+        :whitelisted => whitelisted_step?(step),
+        :storage => storage,
+        :force => @force)
       execution.run
       execution
     ensure

data/lib/foreman_maintain/scenario.rb

@@ -88,10 +88,12 @@ module ForemanMaintain
     end
 
     # Override to compose steps for the scenario
-    def compose; end
+    def compose
+    end
 
     # Override to map context for the scenario
-    def set_context_mapping; end
+    def set_context_mapping
+    end
 
     def preparation_steps
       # we first take the preparation steps defined for the scenario + collect

data/lib/foreman_maintain/upgrade_runner.rb

@@ -146,7 +146,6 @@ module ForemanMaintain
 
     private
 
-    # rubocop:disable Metrics/MethodLength
     def rollback_pre_migrations
       raise "Unexpected phase #{phase}, expecting pre_migrations" unless phase == :pre_migrations
 
@@ -169,7 +168,6 @@ module ForemanMaintain
         The upgrade failed and system was restored to pre-upgrade state.
       MESSAGE
     end
-    # rubocop:enable Metrics/MethodLength
 
     def with_non_empty_scenario(phase)
       next_scenario = scenario(phase)

data/lib/foreman_maintain/utils/backup.rb

@@ -8,42 +8,30 @@ module ForemanMaintain
       include Concerns::SystemHelpers
 
       attr_accessor :standard_files, :katello_online_files, :katello_offline_files,
-                    :foreman_online_files, :foreman_offline_files, :fpc_offline_files,
-                    :fpc_online_files
+        :foreman_online_files, :foreman_offline_files, :fpc_offline_files,
+        :fpc_online_files
 
-      # rubocop:disable Metrics/MethodLength
       def initialize(backup_dir)
         # fpc stands for foreman proxy w/ content
         @backup_dir = backup_dir
         @standard_files = ['config_files.tar.gz']
         @foreman_online_files = ['foreman.dump']
         @foreman_offline_files = ['pgsql_data.tar.gz']
-        @katello_online_files = ['candlepin.dump', 'foreman.dump']
+        @katello_online_files = @foreman_online_files + ['candlepin.dump', 'pulpcore.dump']
         @katello_offline_files = ['pgsql_data.tar.gz']
-        if feature(:pulp2)
-          @katello_online_files  << 'mongo_dump'
-          @katello_offline_files << 'mongo_data.tar.gz'
-          @fpc_online_files = ['mongo_dump']
-          @fpc_offline_files = ['mongo_data.tar.gz']
-        elsif feature(:pulpcore_database)
-          @katello_online_files << 'foreman.dump'
-          @fpc_online_files = ['pulpcore.dump']
-          @fpc_offline_files = ['pgsql_data.tar.gz']
-        end
+        @fpc_online_files = ['pulpcore.dump']
+        @fpc_offline_files = ['pgsql_data.tar.gz']
       end
-      # rubocop:enable Metrics/MethodLength
 
       def file_map
         @file_map ||= {
-          :mongo_data => map_file(@backup_dir, 'mongo_data.tar.gz'),
           :pgsql_data => map_file(@backup_dir, 'pgsql_data.tar.gz'),
           :pulp_data => map_file(@backup_dir, 'pulp_data.tar'),
           :foreman_dump => map_file(@backup_dir, 'foreman.dump'),
           :candlepin_dump => map_file(@backup_dir, 'candlepin.dump'),
-          :mongo_dump => map_file(@backup_dir, 'mongo_dump'),
           :config_files => map_file(@backup_dir, 'config_files.tar.gz'),
           :metadata => map_file(@backup_dir, 'metadata.yml'),
-          :pulpcore_dump => map_file(@backup_dir, 'pulpcore.dump')
+          :pulpcore_dump => map_file(@backup_dir, 'pulpcore.dump'),
         }
       end
 
@@ -52,7 +40,7 @@ module ForemanMaintain
         present = File.exist?(file_path)
         {
           :present => present,
-          :path => file_path
+          :path => file_path,
         }
       end
 
@@ -77,7 +65,6 @@ module ForemanMaintain
 
       def valid_fpc_backup?
         fpc_online_backup? || fpc_standard_backup? || fpc_logical_backup? || \
-          # fpc can have setup where mongo or pulpcore db is external but not both
           fpc_hybrid_db_backup?
       end
 
@@ -109,118 +96,52 @@ module ForemanMaintain
 
       def katello_standard_backup?
         present = [:pgsql_data]
-        absent = [:candlepin_dump, :foreman_dump, :pulpcore_dump, :mongo_dump]
-        if feature(:pulpcore_database) && !feature(:pulp2)
-          absent.concat [:mongo_data]
-        elsif feature(:pulp2)
-          present.concat [:mongo_data]
-        else
-          return false
-        end
+        absent = [:candlepin_dump, :foreman_dump, :pulpcore_dump]
         check_file_existence(:present => present,
-                             :absent => absent)
+          :absent => absent)
       end
 
       def katello_online_backup?
-        present = [:candlepin_dump, :foreman_dump]
-        absent = [:mongo_data, :pgsql_data]
-        if feature(:pulpcore_database) && !feature(:pulp2)
-          present.concat [:pulpcore_dump]
-          absent.concat [:mongo_dump]
-        elsif feature(:pulp2) && feature(:pulpcore_database)
-          present.concat [:mongo_dump, :pulpcore_dump]
-        elsif feature(:pulp2)
-          present.concat [:mongo_dump]
-          absent.concat [:pulpcore_dump]
-        else
-          return false
-        end
+        present = [:candlepin_dump, :foreman_dump, :pulpcore_dump]
+        absent = [:pgsql_data]
         check_file_existence(:present => present,
-                             :absent => absent)
+          :absent => absent)
       end
 
       def katello_logical_backup?
-        present = [:pgsql_data, :candlepin_dump, :foreman_dump]
+        present = [:pgsql_data, :candlepin_dump, :foreman_dump, :pulpcore_dump]
         absent = []
-        if feature(:pulpcore_database) && !feature(:pulp2)
-          present.concat [:pulpcore_dump]
-          absent.concat [:mongo_dump, :mongo_data]
-        elsif feature(:pulp2) && feature(:pulpcore_database)
-          present.concat [:mongo_dump, :mongo_data, :pulpcore_dump]
-        elsif feature(:pulp2)
-          present.concat [:mongo_dump, :mongo_data]
-          absent.concat [:pulpcore_dump]
-        else
-          return false
-        end
         check_file_existence(:present => present,
-                             :absent => absent)
+          :absent => absent)
       end
 
       def katello_hybrid_db_backup?
-        all_dbs = { :pgsql_data => %w[candlepin foreman], :mongo_data => [] }
-        all_dbs[:pgsql_data] << 'pulpcore' if feature(:pulpcore_database)
-        all_dbs[:mongo_data] << 'mongo' if feature(:mongo)
+        all_dbs = { :pgsql_data => %w[candlepin foreman pulpcore] }
         present, absent = dumps_for_hybrid_db_setup(all_dbs)
         check_file_existence(:present => present, :absent => absent)
       end
 
       def fpc_standard_backup?
-        present = []
-        absent = [:candlepin_dump, :foreman_dump, :pulpcore_dump, :mongo_dump]
-        if feature(:pulpcore_database) && !feature(:pulp2)
-          present.concat [:pgsql_data]
-          absent.concat [:mongo_data]
-        elsif feature(:pulp2) && feature(:pulpcore_database)
-          present.concat [:mongo_data, :pgsql_data]
-        elsif feature(:pulp2)
-          present.concat [:mongo_data]
-          absent.concat [:pgsql_data]
-        else
-          return false
-        end
+        present = [:pgsql_data]
+        absent = [:candlepin_dump, :foreman_dump, :pulpcore_dump]
         check_file_existence(:present => present,
-                             :absent => absent)
+          :absent => absent)
       end
 
       def fpc_online_backup?
-        present = []
-        absent = [:mongo_data, :pgsql_data, :candlepin_dump, :foreman_dump]
-        if feature(:pulpcore_database) && !feature(:pulp2)
-          present.concat [:pulpcore_dump]
-          absent.concat [:mongo_dump]
-        elsif feature(:pulp2) && feature(:pulpcore_database)
-          present.concat [:mongo_dump, :pulpcore_dump]
-        elsif feature(:pulp2)
-          present.concat [:mongo_dump]
-          absent.concat [:pulpcore_dump]
-        else
-          return false
-        end
+        present = [:pulpcore_dump]
+        absent = [:pgsql_data, :candlepin_dump, :foreman_dump]
         check_file_existence(:present => present, :absent => absent)
       end
 
       def fpc_logical_backup?
-        present = []
+        present = [:pulpcore_dump, :pgsql_data]
         absent = [:candlepin_dump, :foreman_dump]
-        if feature(:pulpcore_database) && !feature(:pulp2)
-          present.concat [:pulpcore_dump, :pgsql_data]
-          absent.concat [:mongo_dump, :mongo_data]
-        elsif feature(:pulp2) && feature(:pulpcore_database)
-          present.concat [:mongo_dump, :mongo_data, :pulpcore_dump, :pgsql_data]
-        elsif feature(:pulp2)
-          present.concat [:mongo_dump, :mongo_data]
-          absent.concat [:pulpcore_dump, :pgsql_data]
-        else
-          return false
-        end
         check_file_existence(:present => present, :absent => absent)
       end
 
       def fpc_hybrid_db_backup?
-        all_dbs = { :pgsql_data => [], :mongo_data => [] }
-        all_dbs[:pgsql_data] << 'pulpcore' if feature(:pulpcore_database)
-        all_dbs[:mongo_data] << 'mongo' if feature(:mongo)
+        all_dbs = { :pgsql_data => ['pulpcore'] }
         present, absent = dumps_for_hybrid_db_setup(all_dbs)
         absent.concat [:candlepin_dump, :foreman_dump]
         check_file_existence(:present => present, :absent => absent)
@@ -228,28 +149,25 @@ module ForemanMaintain
 
       def foreman_standard_backup?
         check_file_existence(:present => [:pgsql_data],
-                             :absent => [:candlepin_dump, :foreman_dump, :pulpcore_dump,
-                                         :mongo_data, :mongo_dump])
+          :absent => [:candlepin_dump, :foreman_dump, :pulpcore_dump])
       end
 
       def foreman_online_backup?
         check_file_existence(:present => [:foreman_dump],
-                             :absent => [:candlepin_dump, :pgsql_data,
-                                         :mongo_data, :mongo_dump, :pulpcore_dump])
+          :absent => [:candlepin_dump, :pgsql_data, :pulpcore_dump])
       end
 
       def foreman_logical_backup?
         check_file_existence(:present => [:pgsql_data, :foreman_dump],
-                             :absent => [:candlepin_dump, :mongo_data, :mongo_dump, :pulpcore_dump])
+          :absent => [:candlepin_dump, :pulpcore_dump])
       end
 
-      # rubocop:disable Metrics/MethodLength
       def dumps_for_hybrid_db_setup(dbs_hash)
         present = []
         absent = []
         dbs_hash.each do |data_file, dbs|
           dbs.each do |db|
-            feature_label = db == 'mongo' ? db : "#{db}_database"
+            feature_label = "#{db}_database"
             dump_file = "#{db}_dump"
             if feature(feature_label.to_sym).local?
               present |= [data_file]
@@ -262,7 +180,6 @@ module ForemanMaintain
         end
         [present, absent]
       end
-      # rubocop:enable Metrics/MethodLength
 
       def validate_hostname?
         # make sure that the system hostname is the same as the backup
@@ -319,8 +236,7 @@ module ForemanMaintain
       end
 
       def tar_backups_exist?
-        file_map[:mongo_data][:present] ||
-          file_map[:pulp_data][:present] ||
+        file_map[:pulp_data][:present] ||
           file_map[:pgsql_data][:present]
       end