foreman_maintain 1.3.0 → 1.3.1

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
 

data/lib/foreman_maintain/utils/bash.rb

@@ -68,37 +68,36 @@ module ForemanMaintain
 
         def traverse_tree(dict, path)
           return [dict, []] if path.nil? || path.empty?
-          result = if dict.key?(path.first)
-                     if path.first.start_with?('-')
-                       parse_option(dict, path)
-                     else
-                       parse_subcommand(dict, path)
-                     end
-                   elsif dict[:params]
-                     # traverse params one by one
-                     parse_params(dict, path)
-                   else
-                     # not found
-                     [{}, path]
-                   end
-          result
+          if dict.key?(path.first)
+            if path.first.start_with?('-')
+              parse_option(dict, path)
+            else
+              parse_subcommand(dict, path)
+            end
+          elsif dict[:params]
+            # traverse params one by one
+            parse_params(dict, path)
+          else
+            # not found
+            [{}, path]
+          end
         end
 
         def parse_params(dict, path)
-          traverse_tree({ :params => dict[:params][1..-1] }, path[1..-1])
+          traverse_tree({ :params => dict[:params][1..] }, path[1..])
         end
 
         def parse_subcommand(dict, path)
-          traverse_tree(dict[path.first], path[1..-1])
+          traverse_tree(dict[path.first], path[1..])
         end
 
         def parse_option(dict, path)
           if dict[path.first][:type] == :flag # flag
-            traverse_tree(dict, path[1..-1])
+            traverse_tree(dict, path[1..])
           elsif path.length >= 2 # option with value
-            traverse_tree(dict, path[2..-1])
+            traverse_tree(dict, path[2..])
           else # option with value missing
-            [dict[path.first], path[1..-1]]
+            [dict[path.first], path[1..]]
           end
         end
 

data/lib/foreman_maintain/utils/command_runner.rb

@@ -21,15 +21,13 @@ module ForemanMaintain
       end
 
       def run
-        if logger
-          logger.debug(hide_strings("Running command #{@command} with stdin #{@stdin.inspect}"))
-        end
+        logger&.debug(hide_strings("Running command #{@command} with stdin #{@stdin.inspect}"))
         if @interactive
           run_interactively
         else
           run_non_interactively
         end
-        logger.debug("output of the command:\n #{hide_strings(output)}") if logger
+        logger&.debug("output of the command:\n #{hide_strings(output)}")
       end
 
       def interactive?
@@ -52,14 +50,13 @@ module ForemanMaintain
 
       def execution_error
         raise Error::ExecutionError.new(hide_strings(@command),
-                                        exit_status,
-                                        hide_strings(@stdin),
-                                        @interactive ? nil : hide_strings(@output))
+          exit_status,
+          hide_strings(@stdin),
+          @interactive ? nil : hide_strings(@output))
       end
 
       private
 
-      # rubocop:disable Metrics/MethodLength
       def run_interactively
         # use tmp files to capture output and exit status of the command when
         # running interactively
@@ -82,7 +79,6 @@ module ForemanMaintain
         log_file.close
         exit_file.close
       end
-      # rubocop:enable Metrics/MethodLength
 
       def run_non_interactively
         IO.popen(full_command, 'r+') do |f|

data/lib/foreman_maintain/utils/hash_tools.rb

@@ -1,9 +1,9 @@
 module ForemanMaintain::Utils
   module HashTools
-    def self.deep_merge!(h, other_h)
-      other_h = symbolize_hash(other_h)
+    def self.deep_merge!(hash, other_hash)
+      other_hash = symbolize_hash(other_hash)
 
-      h.merge!(other_h) do |_key, old_val, new_val|
+      hash.merge!(other_hash) do |_key, old_val, new_val|
         if old_val.is_a?(Hash) && new_val.is_a?(Hash)
           deep_merge!(old_val, new_val)
         elsif old_val.is_a?(Array) && new_val.is_a?(Array)
@@ -14,8 +14,8 @@ module ForemanMaintain::Utils
       end
     end
 
-    def self.symbolize_hash(h)
-      h.inject({}) { |sym_hash, (k, v)| sym_hash.update(k.to_sym => v) }
+    def self.symbolize_hash(hash)
+      hash.inject({}) { |sym_hash, (key, value)| sym_hash.update(key.to_sym => value) }
     end
   end
 end

data/lib/foreman_maintain/utils/response.rb

@@ -2,6 +2,7 @@ module ForemanMaintain
   module Utils
     class Response
       attr_reader :data, :message
+
       def initialize(success, message, data: {})
         @success = success
         @message = message

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

@@ -2,6 +2,7 @@ module ForemanMaintain::Utils
   module Service
     class RemoteDB < Abstract
       attr_reader :component, :db_feature
+
       def initialize(name, priority, options = {})
         super
         @db_feature = options.fetch(:db_feature)

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

@@ -2,6 +2,7 @@ module ForemanMaintain::Utils
   module Service
     class Systemd < Abstract
       attr_reader :instance_parent_unit
+
       def initialize(name, priority, options = {})
         super
         @sys = SystemHelpers.new
@@ -46,8 +47,7 @@ module ForemanMaintain::Utils
 
       def exist?
         if @sys.systemd_installed?
-          systemd = service_enabled_status
-          systemd == 'enabled' || systemd == 'disabled'
+          ['enabled', 'disabled'].include?(service_enabled_status)
         else
           File.exist?("/etc/init.d/#{@name}")
         end
@@ -73,14 +73,12 @@ module ForemanMaintain::Utils
         # Enable and disable does not work well with globs since they treat them literally.
         # We are skipping the pulpcore-workers@* for these actions until they are configured in
         # a more managable way with systemd
-        # rubocop:disable Layout/IndentAssignment
         msg =
-"
+          "
 \nWARNING: Skipping #{action} for #{name} as there are a variable amount of services to manage
 and this command will not respond to glob operators. These services have been configured by
 the installer and it is recommended to keep them enabled to prevent misconfiguration.\n
 "
-        # rubocop:enable Layout/IndentAssignment
         puts msg
       end
     end

data/lib/foreman_maintain/utils/service.rb

@@ -5,7 +5,7 @@ require 'foreman_maintain/utils/service/remote_db'
 module ForemanMaintain::Utils
   def self.system_service(name, priority, options = {})
     db_feature = options.fetch(:db_feature, nil)
-    if db_feature && db_feature.respond_to?(:local?) && !db_feature.local?
+    if db_feature.respond_to?(:local?) && !db_feature.local?
       Service::RemoteDB.new(name, priority, options)
     else
       Service::Systemd.new(name, priority, options)

data/lib/foreman_maintain/utils.rb

@@ -4,6 +4,5 @@ require 'foreman_maintain/utils/disk'
 require 'foreman_maintain/utils/bash'
 require 'foreman_maintain/utils/hash_tools'
 require 'foreman_maintain/utils/curl_response'
-require 'foreman_maintain/utils/mongo_core'
 require 'foreman_maintain/utils/service'
 require 'foreman_maintain/utils/system_helpers'

data/lib/foreman_maintain/version.rb

@@ -1,3 +1,3 @@
 module ForemanMaintain
-  VERSION = '1.3.0'.freeze
+  VERSION = '1.3.1'.freeze
 end

data/lib/foreman_maintain/yaml_storage.rb

@@ -2,6 +2,7 @@ module ForemanMaintain
   class YamlStorage
     extend Forwardable
     attr_reader :sub_key, :data
+
     def_delegators :data, :[], :[]=, :delete
 
     def initialize(sub_key, data = {})

data/lib/foreman_maintain.rb

@@ -60,7 +60,7 @@ module ForemanMaintain
       'warn' => ::Logger::WARN,
       'error' => ::Logger::ERROR,
       'fatal' => ::Logger::FATAL,
-      'unknown' => ::Logger::UNKNOWN
+      'unknown' => ::Logger::UNKNOWN,
     }.freeze
 
     def setup(options = {})
@@ -98,7 +98,7 @@ module ForemanMaintain
       $LOAD_PATH.concat(config.definitions_dirs)
       config.definitions_dirs.each do |definitions_dir|
         file_paths = File.expand_path(File.join(definitions_dir, '**', '*.rb'))
-        Dir.glob(file_paths).each { |f| require f }
+        Dir.glob(file_paths).sort.each { |f| require f }
       end
     end
 
@@ -192,7 +192,7 @@ module ForemanMaintain
     end
 
     def enable_maintenance_module
-      return unless el? && !el7?
+      return unless el?
 
       maintenance_module = 'satellite-maintenance:el8'
       package_manager = ForemanMaintain.package_manager