foreman_wreckingball 4.0.0 → 6.0.0

data/app/models/foreman_wreckingball/operatingsystem_status.rb

@@ -63,6 +63,7 @@ module ForemanWreckingball
       host&.vmware_facet
     end
 
+    # rubocop:todo Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def os_matches_identifier?
       guest_id = host.vmware_facet.guest_id
       vsphere_os = VsphereOsIdentifiers.lookup(guest_id)
@@ -75,5 +76,6 @@ module ForemanWreckingball
       return false if vsphere_os.release && ![vsphere_os.release].flatten.include?(host.facts['os::release::full'])
       true
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
   end
 end

data/app/models/foreman_wreckingball/spectre_v2_status.rb

@@ -14,7 +14,7 @@ module ForemanWreckingball
     end
 
     def self.description
-      N_('In order to use hardware based branch target injection mitigation within virtual machines, Hypervisor-Assisted Guest Mitigation must be enabled.')
+      N_('In order to use hardware based branch target injection mitigation within virtual machines, Hypervisor-Assisted Guest Mitigation must be enabled.') # rubocop:disable Layout/LineLength
     end
 
     def self.supports_remediate?
@@ -60,7 +60,7 @@ module ForemanWreckingball
     end
 
     def relevant?(_options = {})
-      host && host&.vmware_facet && host.vmware_facet.hardware_version.present? && host.vmware_facet.cpu_features.any?
+      host&.vmware_facet && host.vmware_facet.hardware_version.present? && host.vmware_facet.cpu_features.any?
     end
 
     def guest_mitigation_enabled?

data/app/models/foreman_wreckingball/vmware_cluster.rb

@@ -3,23 +3,24 @@
 module ForemanWreckingball
   class VmwareCluster < ApplicationRecord
     has_many :vmware_hypervisor_facets,
-             :class_name => '::ForemanWreckingball::VmwareHypervisorFacet',
-             :inverse_of => :vmware_cluster,
-             :dependent => :nullify
-    has_many :hosts, :class_name => '::Host::Managed',
-                     :through => :vmware_hypervisor_facets,
-                     :inverse_of => :vmware_cluster,
-                     :dependent => :nullify
+      class_name: '::ForemanWreckingball::VmwareHypervisorFacet',
+      inverse_of: :vmware_cluster,
+      dependent: :nullify
+    has_many :hosts,
+      class_name: '::Host::Managed',
+      through: :vmware_hypervisor_facets,
+      inverse_of: :vmware_cluster,
+      dependent: :nullify
     belongs_to :compute_resource,
-               :inverse_of => :vmware_clusters
+      inverse_of: :vmware_clusters
     has_many :vmware_facets,
-             :class_name => '::ForemanWreckingball::VmwareFacet',
-             :inverse_of => :vmware_cluster,
-             :dependent => :nullify
+      class_name: '::ForemanWreckingball::VmwareFacet',
+      inverse_of: :vmware_cluster,
+      dependent: :nullify
 
     validates_lengths_from_database
 
-    validates :compute_resource, :presence => true, :allow_blank => false
-    validates :name, :presence => true, :allow_blank => false, :uniqueness => { scope: :compute_resource }
+    validates :compute_resource, presence: true, allow_blank: false
+    validates :name, presence: true, allow_blank: false, uniqueness: { scope: :compute_resource }
   end
 end

data/app/models/foreman_wreckingball/vmware_facet.rb

@@ -4,23 +4,25 @@ module ForemanWreckingball
   class VmwareFacet < ApplicationRecord
     include Facets::Base
 
-    VALID_GUEST_STATUSES = [:toolsNotInstalled, :toolsNotRunning, :toolsOk, :toolsOld].freeze
+    VALID_GUEST_STATUSES = %i[toolsNotInstalled toolsNotRunning toolsOk toolsOld].freeze
 
-    enum :tools_state => VALID_GUEST_STATUSES
+    enum tools_state: VALID_GUEST_STATUSES
 
-    VALID_POWER_STATES = [:poweredOff, :poweredOn, :suspended].freeze
-    enum :power_state => VALID_POWER_STATES
+    VALID_POWER_STATES = %i[poweredOff poweredOn suspended].freeze
+    enum power_state: VALID_POWER_STATES
 
-    belongs_to :vmware_cluster, :class_name => '::ForemanWreckingball::VmwareCluster',
-                                :inverse_of => :vmware_facets
+    belongs_to :vmware_cluster,
+      class_name: '::ForemanWreckingball::VmwareCluster',
+      inverse_of: :vmware_facets
 
-    has_many :vmware_hypervisor_facets, :class_name => '::ForemanWreckingball::VmwareHypervisorFacet',
-                                        :through => :vmware_cluster,
-                                        :inverse_of => :vmware_facets
+    has_many :vmware_hypervisor_facets,
+      class_name: '::ForemanWreckingball::VmwareHypervisorFacet',
+      through: :vmware_cluster,
+      inverse_of: :vmware_facets
 
     validates_lengths_from_database
 
-    validates :host, :presence => true, :allow_blank => false
+    validates :host, presence: true, allow_blank: false
 
     serialize :cpu_features, JSON
 
@@ -37,11 +39,14 @@ module ForemanWreckingball
       end
     end
 
+    # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
     def refresh!
       vm = host.compute_object
       return unless vm
       data_for_update = {
-        vmware_cluster: ::ForemanWreckingball::VmwareCluster.find_by(name: vm.cluster, compute_resource: host.compute_resource),
+        vmware_cluster: ::ForemanWreckingball::VmwareCluster.find_by(
+          name: vm.cluster, compute_resource: host.compute_resource
+        ),
         cpus: vm.cpus,
         corespersocket: vm.corespersocket,
         memory_mb: vm.memory_mb,
@@ -50,11 +55,12 @@ module ForemanWreckingball
         guest_id: vm.guest_id,
         cpu_hot_add: vm.cpuHotAddEnabled,
         hardware_version: vm.hardware_version,
-        cpu_features: []
+        cpu_features: [],
       }
       data_for_update[:cpu_features] = raw_vm_object.runtime.featureRequirement.map(&:key) if vm.ready?
       update(data_for_update)
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def refresh_statuses
       ::HostStatus.wreckingball_statuses.each { |status| host.get_status(status).refresh! }

data/app/models/foreman_wreckingball/vmware_hypervisor_facet.rb

@@ -8,7 +8,9 @@ module ForemanWreckingball
 
     validates :host, presence: true, allow_blank: false
 
-    belongs_to :vmware_cluster, inverse_of: :vmware_hypervisor_facets, class_name: '::ForemanWreckingball::VmwareCluster'
+    belongs_to :vmware_cluster,
+      inverse_of: :vmware_hypervisor_facets,
+      class_name: '::ForemanWreckingball::VmwareCluster'
     has_one :compute_resource, inverse_of: :vmware_hypervisor_facets, through: :vmware_cluster
     has_many :vmware_facets, inverse_of: :vmware_hypervisor_facets, through: :vmware_cluster
 

data/app/services/foreman_wreckingball/vmware_cluster_importer.rb

@@ -14,18 +14,21 @@ module ForemanWreckingball
         delete_removed_clusters
         create_new_clusters
       end
-      logger.info("Import clusters for '#{compute_resource}' completed. Added: #{counters[:added] || 0}, Updated: #{counters[:updated] || 0}, Deleted: #{counters[:deleted] || 0} clusters")
+      logger.info("Import clusters for '#{compute_resource}' completed. Added: #{counters[:added] || 0}, Updated: #{counters[:updated] || 0}, Deleted: #{counters[:deleted] || 0} clusters") # rubocop:disable Layout/LineLength
     end
 
     def delete_removed_clusters
-      counters[:deleted] = ::ForemanWreckingball::VmwareCluster.where(compute_resource: compute_resource).where.not(name: cluster_names).destroy_all
+      counters[:deleted] =
+        ::ForemanWreckingball::VmwareCluster.where(compute_resource: compute_resource)
+                                            .where.not(name: cluster_names)
+                                            .destroy_all
     end
 
     def create_new_clusters
-      existing_clusters = ::ForemanWreckingball::VmwareCluster.where(:compute_resource => compute_resource).pluck(:name)
+      existing_clusters = ::ForemanWreckingball::VmwareCluster.where(compute_resource: compute_resource).pluck(:name)
       clusters_to_create = cluster_names - existing_clusters
       clusters_to_create.each do |cluster_name|
-        ::ForemanWreckingball::VmwareCluster.create(:name => cluster_name, :compute_resource => compute_resource)
+        ::ForemanWreckingball::VmwareCluster.create(name: cluster_name, compute_resource: compute_resource)
       end
       counters[:added] = clusters_to_create.size
     end

data/app/services/foreman_wreckingball/vmware_hypervisor_importer.rb

@@ -11,13 +11,12 @@ module ForemanWreckingball
     end
 
     def import!
-      logger.info "Can not determine organization for compute resource #{compute_resource}."
       compute_resource.refresh_cache
       compute_resource.vmware_clusters.each do |cluster|
         import_hypervisors(cluster)
         delete_removed_hypervisors(cluster)
       end
-      logger.info("Import hypervisors for '#{compute_resource}' completed. Added: #{counters[:added] || 0}, Updated: #{counters[:updated] || 0}, Deleted: #{counters[:deleted] || 0} hypervisors") # rubocop:disable Metrics/LineLength
+      logger.info("Import hypervisors for '#{compute_resource}' completed. Added: #{counters[:added] || 0}, Updated: #{counters[:updated] || 0}, Deleted: #{counters[:deleted] || 0} hypervisors") # rubocop:disable Layout/LineLength
     end
 
     def import_hypervisors(cluster)
@@ -26,6 +25,7 @@ module ForemanWreckingball
       end
     end
 
+    # rubocop:todo Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def import_hypervisor(cluster, hypervisor)
       host = find_host_for_hypervisor(hypervisor)
 
@@ -33,10 +33,10 @@ module ForemanWreckingball
 
       ipaddress6 = hypervisor.ipaddress6
       ipaddress6 = nil if begin
-                             IPAddr.new('fe80::/10').include?(ipaddress6)
-                           rescue StandardError
-                             false
-                           end
+        IPAddr.new('fe80::/10').include?(ipaddress6)
+      rescue StandardError
+        false
+      end
 
       hostname = hypervisor.hostname
       domainname = hypervisor.domainname
@@ -52,65 +52,73 @@ module ForemanWreckingball
       end
 
       result = host.update(
-        :name => hostname,
-        :domain => ::Domain.where(:name => domainname).first_or_create,
-        :model => ::Model.where(:name => hypervisor.model.strip).first_or_create,
-        :ip => hypervisor.ipaddress,
-        :ip6 => ipaddress6,
-        :vmware_hypervisor_facet_attributes => {
-          :vmware_cluster => cluster,
-          :cpu_cores => hypervisor.cpu_cores,
-          :cpu_sockets => hypervisor.cpu_sockets,
-          :cpu_threads => hypervisor.cpu_threads,
-          :memory => hypervisor.memory,
-          :uuid => hypervisor.uuid,
-          :feature_capabilities => hypervisor.feature_capabilities
+        name: hostname,
+        domain: ::Domain.where(name: domainname).first_or_create,
+        model: ::Model.where(name: hypervisor.model.strip).first_or_create,
+        ip: hypervisor.ipaddress,
+        ip6: ipaddress6,
+        vmware_hypervisor_facet_attributes: {
+          vmware_cluster: cluster,
+          cpu_cores: hypervisor.cpu_cores,
+          cpu_sockets: hypervisor.cpu_sockets,
+          cpu_threads: hypervisor.cpu_threads,
+          memory: hypervisor.memory,
+          uuid: hypervisor.uuid,
+          feature_capabilities: hypervisor.feature_capabilities,
         }
       )
       if result
-        increment_counter(counter)
+        increment(counter)
       else
         logger.error "Failed to save host #{host}. Reason: #{host.errors.full_messages.to_sentence}"
       end
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
     def hypervisors(cluster)
-      @hypervisors[cluster.name.to_sym] ||= compute_resource.hypervisors(:cluster_id => cluster.name)
+      @hypervisors[cluster.name.to_sym] ||= compute_resource.hypervisors(cluster_id: cluster.name)
     end
 
-    def find_host_for_hypervisor(hypervisor)
+    def find_host_for_hypervisor(hypervisor) # rubocop:disable Metrics/AbcSize
       name = ::ForemanWreckingball::VmwareHypervisorFacet.sanitize_name(hypervisor.name)
-      hostname = ::ForemanWreckingball::VmwareHypervisorFacet.sanitize_name([hypervisor.hostname, hypervisor.domainname].join('.'))
+      hostname = ::ForemanWreckingball::VmwareHypervisorFacet.sanitize_name([hypervisor.hostname,
+                                                                             hypervisor.domainname].join('.'))
       hostname = nil if hostname.blank?
-      katello_name = katello_hypervisor_hostname(hostname || name)
-      katello_uuid = katello_hypervisor_hostname(hypervisor.uuid)
-
-      host = ::ForemanWreckingball::VmwareHypervisorFacet.find_by(:uuid => hypervisor.uuid).try(:host)
-      host ||= ::Host.find_by(:name => hostname) if hostname
-      host ||= ::Host.find_by(:name => name)
-      host ||= ::Host.find_by(:name => katello_name) if katello_name
-      host ||= ::Host.find_by(:name => katello_uuid) if katello_uuid
+
+      host = ::ForemanWreckingball::VmwareHypervisorFacet.find_by(uuid: hypervisor.uuid).try(:host)
+      host ||= ::Host.find_by(name: hostname) if hostname
+      host ||= ::Host.find_by(name: name)
       host ||= create_host_for_hypervisor(hostname || name)
       host
     end
 
     def create_host_for_hypervisor(name)
-      host = ::Host::Managed.new(:name => name, :organization => organization,
-                                 :location => location, :managed => false, :enabled => false)
+      host = ::Host::Managed.new(
+        name: name,
+        organization: organization,
+        location: location,
+        managed: false,
+        enabled: false
+      )
       host.save!
       host
     end
 
+    # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
     def delete_removed_hypervisors(cluster)
       hypervisor_names = hypervisors(cluster).map(&:name)
       hypervisor_uuids = hypervisors(cluster).map(&:uuid)
-      delete_query = ::ForemanWreckingball::VmwareHypervisorFacet.joins(:host).where(vmware_cluster: cluster).where.not('hosts.name': hypervisor_names).where.not(uuid: hypervisor_uuids)
+      delete_query = ::ForemanWreckingball::VmwareHypervisorFacet.joins(:host)
+                                                                 .where(vmware_cluster: cluster)
+                                                                 .where.not('hosts.name': hypervisor_names)
+                                                                 .where.not(uuid: hypervisor_uuids)
       counters[:deleted] = if ActiveRecord::Base.connection.adapter_name.downcase.starts_with?('mysql')
-                             ::ForemanWreckingball::VmwareHypervisorFacet.where(:id => delete_query.pluck(:id)).delete_all
+                             ::ForemanWreckingball::VmwareHypervisorFacet.where(id: delete_query.pluck(:id)).delete_all
                            else
                              delete_query.delete_all
                            end
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def organization
       compute_resource.organizations.first
@@ -120,14 +128,9 @@ module ForemanWreckingball
       compute_resource.locations.first
     end
 
-    def katello_hypervisor_hostname(hostname)
-      return unless organization
-      "virt-who-#{hostname}-#{organization.id}"
-    end
-
     private
 
-    def increment_counter(id)
+    def increment(id)
       counters[id] ||= 0
       counters[id] += 1
     end

data/app/views/foreman_wreckingball/hosts/_hosts.json.rabl

@@ -22,7 +22,7 @@ node(:status) do |host|
     id: status.id,
     label: status.to_label,
     icon_class: host_global_status_icon_class(status.to_global),
-    status_class: host_global_status_class(status.to_global)
+    status_class: host_global_status_class(status.to_global),
   }
 end
 
@@ -32,6 +32,6 @@ end) do
   {
     label: _('Remediate'),
     title: _('Remediate Host OS'),
-    path: schedule_remediate_hosts_path
+    path: schedule_remediate_hosts_path,
   }
 end

data/app/views/foreman_wreckingball/hosts/status_hosts.json.rabl

@@ -6,8 +6,8 @@ node(:recordsTotal) { @count }
 node(:recordsFiltered) { @count }
 node(:data) do
   partial 'foreman_wreckingball/hosts/_hosts', object: @hosts,
-                                               locals: {
-                                                 host_association: @status.host_association,
-                                                 supports_remediate: @status.supports_remediate?
-                                               }
+    locals: {
+      host_association: @status.host_association,
+      supports_remediate: @status.supports_remediate?,
+    }
 end

data/config/environments/production.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require Rails.root.join('config', 'environments', 'production.rb')
+require Rails.root.join('config/environments/production.rb')
 
 Foreman::Application.configure do
   config.assets.js_compressor = Uglifier.new(harmony: true) if defined?(Uglifier)

data/config/routes.rb

@@ -2,12 +2,13 @@
 
 Rails.application.routes.draw do
   scope '/wreckingball' do
-    constraints(:id => /[^\/]+/) do
+    constraints(id: %r{[^/]+}) do
       resources :hosts, controller: 'foreman_wreckingball/hosts', only: [] do
         collection do
           get :status_dashboard
           get :status_managed_hosts_dashboard
-          get 'status_dashboard/hosts(/:status)', as: :ajax_status_dashboard, action: :status_hosts, defaults: { format: :json }
+          get 'status_dashboard/hosts(/:status)', as: :ajax_status_dashboard, action: :status_hosts,
+defaults: { format: :json }
           put :refresh_status_dashboard
           get :schedule_remediate
           post :submit_remediate

data/db/migrate/20181021111543_add_indexes_to_vmware_hypervisor_facets.rb

@@ -3,6 +3,6 @@
 class AddIndexesToVmwareHypervisorFacets < ActiveRecord::Migration[5.1]
   def change
     add_index :vmware_hypervisor_facets, :uuid
-    add_index :vmware_hypervisor_facets, [:vmware_cluster_id, :uuid]
+    add_index :vmware_hypervisor_facets, %i[vmware_cluster_id uuid]
   end
 end

data/db/migrate/20240201094513_fix_wreckingball_settings_category_to_dsl.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class FixWreckingballSettingsCategoryToDsl < ActiveRecord::Migration[6.0]
+  class MigrationSettings < ActiveRecord::Base
+    self.table_name = :settings
+  end
+
+  def up
+    MigrationSettings.where(category: 'Setting::Wreckingball').update_all(category: 'Setting') if column_exists?(
+      :settings, :category
+    )
+  end
+end

data/lib/foreman_wreckingball/engine.rb

@@ -12,14 +12,9 @@ module ForemanWreckingball
       'ForemanWreckingball::OperatingsystemStatus',
       'ForemanWreckingball::CpuHotAddStatus',
       'ForemanWreckingball::SpectreV2Status',
-      'ForemanWreckingball::HardwareVersionStatus'
+      'ForemanWreckingball::HardwareVersionStatus',
     ].freeze
 
-    config.autoload_paths += Dir["#{config.root}/app/lib"]
-    config.autoload_paths += Dir["#{config.root}/app/services"]
-    config.autoload_paths += Dir["#{config.root}/app/models/concerns"]
-    config.autoload_paths += Dir["#{config.root}/app/helpers/concerns"]
-
     initializer 'foreman_wreckingball.register_paths' do |_app|
       ::ForemanTasks.dynflow.config.eager_load_paths.concat(%W[#{ForemanWreckingball::Engine.root}/app/lib/actions])
     end
@@ -31,79 +26,85 @@ module ForemanWreckingball
       end
     end
 
-    initializer 'foreman_wreckingball.load_default_settings', before: :load_config_initializers do
-      table_exists = begin
-                       Setting.table_exists?
-                     rescue StandardError
-                       false
-                     end
-      require_dependency File.expand_path('../../app/models/setting/wreckingball.rb', __dir__) if table_exists
-    end
-
-    initializer 'foreman_wreckingball.register_plugin', :before => :finisher_hook do |_app|
-      Foreman::Plugin.register :foreman_wreckingball do
-        requires_foreman '>= 2.3'
-
-        automatic_assets(false)
-        precompile_assets(
-          [
-            'foreman_wreckingball/modal.js',
-            'foreman_wreckingball/status_hosts_table.js',
-            'foreman_wreckingball/status_managed_hosts_dashboard.js',
-            'foreman_wreckingball/status_row.js',
-            'foreman_wreckingball/status_hosts_table.css',
-            'foreman_wreckingball/status_managed_hosts_dashboard.css'
+    initializer 'foreman_wreckingball.register_plugin', before: :finisher_hook do |app|
+      app.reloader.to_prepare do
+        Foreman::Plugin.register :foreman_wreckingball do
+          requires_foreman '>= 3.13'
+
+          settings do
+            category :wreckingball, N_('Wreckingball') do
+              setting :min_vsphere_hardware_version,
+                type: :integer,
+                default: 13,
+                description: _('Minimum required Hardware version for vSphere VMs')
+            end
+          end
+
+          automatic_assets(false)
+          precompile_assets(
+            [
+              'foreman_wreckingball/modal.js',
+              'foreman_wreckingball/status_hosts_table.js',
+              'foreman_wreckingball/status_managed_hosts_dashboard.js',
+              'foreman_wreckingball/status_row.js',
+              'foreman_wreckingball/status_hosts_table.css',
+              'foreman_wreckingball/status_managed_hosts_dashboard.css',
+            ]
+          )
+
+          security_block :foreman_wreckingball do
+            permission :refresh_vmware_status_hosts, {
+              'foreman_wreckingball/hosts': %i[refresh_status_dashboard],
+            }, resource_type: 'Host'
+            permission :remediate_vmware_status_hosts, {
+              'foreman_wreckingball/hosts': %i[schedule_remediate submit_remediate],
+            }, resource_type: 'Host'
+          end
+
+          # Extend built in permissions
+          Foreman::AccessControl.permission(:view_hosts).actions.concat [
+            'foreman_wreckingball/hosts/status_dashboard',
+            'foreman_wreckingball/hosts/status_managed_hosts_dashboard',
+            'foreman_wreckingball/hosts/status_hosts',
           ]
-        )
-
-        security_block :foreman_wreckingball do
-          permission :refresh_vmware_status_hosts, {
-            :'foreman_wreckingball/hosts' => [:refresh_status_dashboard]
-          }, :resource_type => 'Host'
-          permission :remediate_vmware_status_hosts, {
-            :'foreman_wreckingball/hosts' => [:schedule_remediate, :submit_remediate]
-          }, :resource_type => 'Host'
-        end
 
-        # Extend built in permissions
-        Foreman::AccessControl.permission(:view_hosts).actions.concat [
-          'foreman_wreckingball/hosts/status_dashboard',
-          'foreman_wreckingball/hosts/status_managed_hosts_dashboard',
-          'foreman_wreckingball/hosts/status_hosts'
-        ]
+          menu :top_menu,
+            :wreckingball_status_dashboard,
+            url_hash: { controller: :'foreman_wreckingball/hosts', action: :status_dashboard },
+            caption: N_('VMware Status'),
+            parent: :hosts_menu,
+            after: :hosts
 
-        menu :top_menu, :wreckingball_status_dashboard, :url_hash => { :controller => :'foreman_wreckingball/hosts', :action => :status_dashboard },
-                                                        :caption => N_('VMware Status'),
-                                                        :parent => :hosts_menu,
-                                                        :after => :hosts
+          WRECKINGBALL_STATUSES.each { |status| register_custom_status(status.constantize) }
 
-        WRECKINGBALL_STATUSES.each { |status| register_custom_status(status.constantize) }
+          menu :top_menu,
+            :wreckingball_status_managed_hosts_dashboard,
+            url_hash: { controller: :'foreman_wreckingball/hosts', action: :status_managed_hosts_dashboard },
+            caption: N_('VMware Managed Status'),
+            parent: :monitor_menu,
+            after: :audits
 
-        menu :top_menu, :wreckingball_status_managed_hosts_dashboard, url_hash: { :controller => :'foreman_wreckingball/hosts', :action => :status_managed_hosts_dashboard },
-                                                                      caption: N_('VMware Managed Status'),
-                                                                      parent: :monitor_menu,
-                                                                      after: :audits
+          register_facet(ForemanWreckingball::VmwareFacet, :vmware_facet)
 
-        register_facet(ForemanWreckingball::VmwareFacet, :vmware_facet)
+          register_facet(ForemanWreckingball::VmwareHypervisorFacet, :vmware_hypervisor_facet)
 
-        register_facet(ForemanWreckingball::VmwareHypervisorFacet, :vmware_hypervisor_facet)
+          add_controller_action_scope('HostsController', :index) { |base_scope| base_scope.includes(:vmware_facet) }
 
-        add_controller_action_scope('HostsController', :index) { |base_scope| base_scope.includes(:vmware_facet) }
+          # extend host show page
+          extend_page('compute_resources/show') do |context|
+            context.add_pagelet :main_tabs,
+              name: N_('Hypervisors'),
+              partial: 'compute_resources/hypervisors_tab',
+              onlyif: proc { |cr| cr.provider_friendly_name == 'VMware' && cr.vmware_hypervisor_facets.any? }
+          end
 
-        # extend host show page
-        extend_page('compute_resources/show') do |context|
-          context.add_pagelet :main_tabs,
-                              :name => N_('Hypervisors'),
-                              :partial => 'compute_resources/hypervisors_tab',
-                              :onlyif => proc { |cr| cr.provider_friendly_name == 'VMware' && cr.vmware_hypervisor_facets.any? }
+          # add custom logger
+          logger :import, enabled: true
         end
-
-        # add custom logger
-        logger :import, enabled: true
       end
     end
 
-    initializer 'foreman_wreckingball.dynflow_world', :before => 'foreman_tasks.initialize_dynflow' do |_app|
+    initializer 'foreman_wreckingball.dynflow_world', before: 'foreman_tasks.initialize_dynflow' do |_app|
       ::ForemanTasks.dynflow.require!
     end
 
@@ -111,20 +112,19 @@ module ForemanWreckingball
     config.to_prepare do
       ::HostStatus.extend(ForemanWreckingball::HostStatusExtensions)
 
-      ::ComputeResource.send(:include, ForemanWreckingball::ComputeResourceExtensions)
-      ::Foreman::Model::Vmware.send(:include, ForemanWreckingball::VmwareExtensions)
-      ::Host::Managed.send(:include, ForemanWreckingball::HostExtensions)
-      ::Host::Managed.send(:include, ForemanWreckingball::VmwareFacetHostExtensions)
-      ::Host::Managed.send(:include, ForemanWreckingball::VmwareHypervisorFacetHostExtensions)
-      ::HostsHelper.send(:include, ForemanWreckingball::HostsHelperExtensions)
-      ::User.send(:include, ForemanWreckingball::UserExtensions)
-      ::Usergroup.send(:include, ForemanWreckingball::UsergroupExtensions)
+      ::ComputeResource.include(ForemanWreckingball::ComputeResourceExtensions)
+      ::Foreman::Model::Vmware.include(ForemanWreckingball::VmwareExtensions)
+      ::Host::Managed.include(ForemanWreckingball::HostExtensions)
+      ::Host::Managed.include(ForemanWreckingball::VmwareFacetHostExtensions)
+      ::Host::Managed.include(ForemanWreckingball::VmwareHypervisorFacetHostExtensions)
+      ::User.include(ForemanWreckingball::UserExtensions)
+      ::Usergroup.include(ForemanWreckingball::UsergroupExtensions)
 
       if ForemanWreckingball.fog_patches_required?
-        ForemanWreckingball.fog_vsphere_namespace::Host.send(:include, FogExtensions::ForemanWreckingball::Vsphere::Host)
-        ForemanWreckingball.fog_vsphere_namespace::Server.send(:include, FogExtensions::ForemanWreckingball::Vsphere::Server)
-        ForemanWreckingball.fog_vsphere_namespace::Real.send(:include, FogExtensions::ForemanWreckingball::Vsphere::Real)
-        ForemanWreckingball.fog_vsphere_namespace::Mock.send(:include, FogExtensions::ForemanWreckingball::Vsphere::Mock)
+        Fog::Vsphere::Compute::Host.include(FogExtensions::ForemanWreckingball::Vsphere::Host)
+        Fog::Vsphere::Compute::Server.include(FogExtensions::ForemanWreckingball::Vsphere::Server)
+        Fog::Vsphere::Compute::Real.include(FogExtensions::ForemanWreckingball::Vsphere::Real)
+        Fog::Vsphere::Compute::Mock.include(FogExtensions::ForemanWreckingball::Vsphere::Mock)
       end
     rescue StandardError => e
       Rails.logger.warn "ForemanWreckingball: skipping engine hook (#{e})\n#{e.backtrace.join("\n")}"
@@ -142,17 +142,9 @@ module ForemanWreckingball
     require 'fog/vsphere'
     require 'fog/vsphere/compute'
     require 'fog/vsphere/models/compute/host'
+    require 'fog/vsphere/models/compute/server'
     true
   rescue LoadError
     false
   end
-
-  def self.fog_vsphere_namespace
-    require 'fog/vsphere/version'
-    @fog_vsphere_namespace ||= if Gem::Version.new(Fog::Vsphere::VERSION) >= Gem::Version.new('3.0.0')
-                                 Fog::Vsphere::Compute
-                               else
-                                 Fog::Compute::Vsphere
-                               end
-  end
 end

data/lib/foreman_wreckingball/scheduled_jobs.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # First, we check if there's a job already enqueued
-pending_jobs = ::Foreman::Application.dynflow.world.persistence.find_execution_plans(filters: { :state => 'scheduled' })
+pending_jobs = ::Foreman::Application.dynflow.world.persistence.find_execution_plans(filters: { state: 'scheduled' })
 scheduled_job = pending_jobs.select do |job|
   delayed_plan = ::Foreman::Application.dynflow.world.persistence.load_delayed_plan(job.id)
   next if delayed_plan.blank?