foreman_resource_quota 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acb27059a0b8ca259bce3aeb9c43044fc50f2766d6a9619e5dae66ff2cc4766b
-  data.tar.gz: d50841a42fbc287725a5612b1e7004187c331a8ca82c74ead75511b64dae8c5b
+  metadata.gz: e5ae7058a06490ad3f9c4b8a299834a4c5cf013cabfd0a6123bf9ba4d26c3c47
+  data.tar.gz: ddc85109fc571d9d723181765dcb81b8302acfb721556fcd1fd9739af234baf9
 SHA512:
-  metadata.gz: 6b6dcae25dba0d534f807184573b54df1faebc010f23bde6134cd8a428f34c12c6103f528667ccbfbb42289eadc9a57c965e04927bed929339bc06f95dc431b8
-  data.tar.gz: 03b6d8bb2153880689169d7c73ca36fca03772734a7f086aaed0dd66ae48f9c8d92da53d971fd33bd081b2368f2df3d51f18bb39ca8c3b929bcaed14fdc86301
+  metadata.gz: 88f0f162d137fe245f38733a9f361624d81f36d889d114877fe70654b67d0de8f31daf3916aa029da9d9cf5f30ebc19b8152f565f24709e565fe74edd6ed98a1
+  data.tar.gz: 1bef610395fd2a5901623c9370d70339b8b12f53bd7d7f96aefe80d70607daa73c1b731b88ca2a73578219ee2cf59786fa8d3147ff0b092e9cc7e6209faa9230

data/app/controllers/foreman_resource_quota/api/v2/resource_quotas_controller.rb

@@ -64,7 +64,6 @@ module ForemanResourceQuota
         def_param_group :resource_quota do
           param :resource_quota, Hash, required: true, action_aware: true do
             param :name, String, required: true
-            # param :operatingsystem_ids, Array, :desc => N_("Operating system IDs")
           end
         end
 

data/app/helpers/foreman_resource_quota/resource_quota_helper.rb

@@ -52,20 +52,29 @@ module ForemanResourceQuota
       format(format_text, unit_applied_value, symbol)
     end
 
+    # Use different resource origins to determine host resource utilization.
+    #  - iterates all given hosts and tries do determine their resources utilization
+    # Returns:
+    #   [ <hosts_resources>, <missing_hosts_resources> ]
+    #   for example:
+    #     [
+    #       { "host_a": { cpu_cores: 20, memory_mb: 8196 }, "host_b": { cpu_cores: 15, memory_mb: nil } },
+    #       { "host_c": [ :memory_mb ] },
+    #     ]
     def utilization_from_resource_origins(resources, hosts, custom_resource_origins: nil)
-      utilization_sum = resources.each.with_object({}) { |key, hash| hash[key] = 0 }
+      hosts_resources = create_hosts_resources_hash(hosts, resources)
       missing_hosts_resources = create_missing_hosts_resources_hash(hosts, resources)
       hosts_hash = hosts.index_by(&:name)
       resource_classes = custom_resource_origins || default_resource_origin_classes
       resource_classes.each do |origin_class|
         origin_class.new.collect_resources!(
-          utilization_sum,
+          hosts_resources,
           missing_hosts_resources,
           hosts_hash
         )
       end
 
-      [utilization_sum, missing_hosts_resources]
+      [hosts_resources, missing_hosts_resources]
     end
 
     private
@@ -89,6 +98,25 @@ module ForemanResourceQuota
       hosts.map(&:name).index_with { resources_to_determine.clone }
     end
 
+    # Create a Hash that maps resources and a value to host names.
+    # { <host name>: {<hash of resource values>} }
+    #     for example:
+    #     {
+    #       "host_a": { cpu_cores: nil, disk_gb: nil },
+    #       "host_b": { cpu_cores: nil, disk_gb: nil },
+    #     }
+    # Parameters:
+    #   - hosts: Array of host objects.
+    #   - resources: Array of resources (as symbol, e.g. [:cpu_cores, :disk_gb]).
+    # Returns: Hash with host names as keys and resource-hashs as values.
+    def create_hosts_resources_hash(hosts, resources)
+      return {} if hosts.empty? || resources.empty?
+
+      # Create a hash template with resources mapped to nil
+      resources_to_determine = resources.index_with { |_resource| nil }
+      hosts.map(&:name).index_with { resources_to_determine.dup }
+    end
+
     # Default classes that are used to determine host resources. Determines
     # resources in the order of this list.
     def default_resource_origin_classes

data/app/models/concerns/foreman_resource_quota/host_managed_extensions.rb

@@ -7,16 +7,23 @@ module ForemanResourceQuota
     include ForemanResourceQuota::Exceptions
 
     included do
-      validate :check_resource_quota_capacity
-
-      belongs_to :resource_quota, class_name: '::ForemanResourceQuota::ResourceQuota'
-      has_one :resource_quota_missing_resources, class_name: '::ForemanResourceQuota::ResourceQuotaMissingHost',
-        inverse_of: :missing_host, foreign_key: :missing_host_id, dependent: :destroy
+      validate :verify_resource_quota
+
+      has_one :host_resources, class_name: '::ForemanResourceQuota::HostResources',
+        inverse_of: :host, foreign_key: :host_id, dependent: :destroy
+      has_one :resource_quota_host, class_name: '::ForemanResourceQuota::ResourceQuotaHost',
+        inverse_of: :host, foreign_key: :host_id, dependent: :destroy
+      has_one :resource_quota, class_name: '::ForemanResourceQuota::ResourceQuota',
+        through: :resource_quota_host
       scoped_search relation: :resource_quota, on: :name, complete_value: true, rename: :resource_quota
+
+      # A host shall always have a .host_resources attribute
+      before_validation :build_host_resources, unless: -> { host_resources.present? }
+      after_save :save_host_resources, if: -> { host_resources.changed? }
     end
 
-    def check_resource_quota_capacity
-      handle_quota_check
+    def verify_resource_quota
+      handle_quota_check(resource_quota)
       true
     rescue ResourceQuotaException => e
       handle_error('resource_quota_id',
@@ -32,13 +39,27 @@ module ForemanResourceQuota
         format('An unknown error occured while checking the resource quota capacity: %s', e))
     end
 
+    def resource_quota_id
+      resource_quota&.id
+    end
+
+    def resource_quota_id=(val)
+      if val.blank?
+        resource_quota_host&.destroy
+      else
+        quota = ForemanResourceQuota::ResourceQuota.find_by(id: val)
+        raise ActiveRecord::RecordNotFound, "ResourceQuota with ID \"#{val}\" not found" unless quota
+        self.resource_quota = quota
+      end
+    end
+
     private
 
-    def handle_quota_check
-      return if early_return?
-      quota_utilization = determine_quota_utilization
-      host_resources = determine_host_resources
-      verify_resource_quota_limits(quota_utilization, host_resources)
+    def handle_quota_check(quota)
+      return if early_return?(quota)
+      quota_utilization = determine_quota_utilization(quota)
+      current_host_resources = determine_host_resources(quota.active_resources)
+      check_resource_quota_limits(quota, quota_utilization, current_host_resources)
     end
 
     def handle_error(error_module, error_message, log_message)
@@ -47,60 +68,72 @@ module ForemanResourceQuota
       false
     end
 
-    def determine_quota_utilization
-      resource_quota.determine_utilization
-      missing_hosts = resource_quota.missing_hosts
+    def determine_quota_utilization(quota)
+      missing_hosts = quota.missing_hosts(exclude: [name])
       unless missing_hosts.empty?
         raise ResourceQuotaUtilizationException,
-          "Resource Quota '#{resource_quota.name}' cannot determine resources for #{missing_hosts.size} hosts."
+          "Resource Quota '#{quota.name}' cannot determine resources for #{missing_hosts.size} hosts."
       end
-      resource_quota.utilization
+      quota.utilization(exclude: [name])
     end
 
-    def determine_host_resources
-      (host_resources, missing_hosts) = call_utilization_helper(resource_quota.active_resources, [self])
-      unless missing_hosts.empty?
+    def determine_host_resources(active_resources)
+      new_host_resources, missing_hosts = call_utilization_helper(active_resources, [self])
+      if missing_hosts.key?(name) || missing_hosts.key?(name.to_sym)
         raise HostResourcesException,
-          "Cannot determine host resources for #{name}"
+          "Cannot determine host resources for #{name}: #{missing_hosts[name]}"
       end
-      host_resources
+      host_resources.resources = new_host_resources
+      host_resources.resources
     end
 
-    def verify_resource_quota_limits(quota_utilization, host_resources)
+    def check_resource_quota_limits(quota, quota_utilization, current_host_resources)
       quota_utilization.each do |resource_type, resource_utilization|
         next if resource_utilization.nil?
 
-        max_quota = resource_quota[resource_type]
-        all_hosts_utilization = resource_utilization + host_resources[resource_type.to_sym]
+        max_quota = quota[resource_type]
+        all_hosts_utilization = resource_utilization + current_host_resources[resource_type.to_sym]
         next if all_hosts_utilization <= max_quota
 
-        raise ResourceLimitException, formulate_limit_error(resource_utilization,
+        raise ResourceLimitException, formulate_limit_error(quota.name, resource_utilization,
           all_hosts_utilization, max_quota, resource_type)
       end
     end
 
-    def formulate_limit_error(resource_utilization, all_hosts_utilization, max_quota, resource_type)
-      if resource_utilization < max_quota
+    def formulate_limit_error(quota_name, resource_utilization, all_hosts_utilization, max_quota, resource_type)
+      if resource_utilization <= max_quota
         N_(format("Host exceeds %s limit of '%s'-quota by %s (max. %s)",
           natural_resource_name_by_type(resource_type),
-          resource_quota.name,
+          quota_name,
           resource_value_to_string(all_hosts_utilization - max_quota, resource_type),
           resource_value_to_string(max_quota, resource_type)))
       else
         N_(format("%s limit of '%s'-quota is already exceeded by %s without adding the new host (max. %s)",
           natural_resource_name_by_type(resource_type),
-          resource_quota.name,
+          quota_name,
           resource_value_to_string(resource_utilization - max_quota, resource_type),
           resource_value_to_string(max_quota, resource_type)))
       end
     end
 
-    def early_return?
-      if resource_quota.nil?
+    def formulate_resource_inconsistency_error(quota_name, resource_type, quota_utilization_value, resource_value)
+      N_("Resource Quota '#{quota_name}' inconsistency detected while destroying host '#{name}':\n" \
+         "Resource Quota #{resource_type} current utilization: #{quota_utilization_value}.\n" \
+         "Host resource value: #{resource_value}.\n" \
+         'Skipping.')
+    end
+
+    def formulate_quota_inconsistency_error(quota_name)
+      N_("An error occured adapting the resource quota utilization of '#{quota_name}' " \
+         "while processing host '#{name}'. The resource quota utilization values might be inconsistent.")
+    end
+
+    def early_return?(quota)
+      if quota.nil?
         return true if quota_assigment_optional?
         raise HostResourceQuotaEmptyException, 'must be given.'
       end
-      return true if resource_quota.active_resources.empty?
+      return true if quota.active_resources.empty?
       return true if Setting[:resource_quota_global_no_action] # quota is assigned, but not supposed to be checked
       false
     end
@@ -109,9 +142,19 @@ module ForemanResourceQuota
       owner.resource_quota_is_optional || Setting[:resource_quota_optional_assignment]
     end
 
+    def save_host_resources
+      host_resources.save
+    end
+
     # Wrap into a function for easier testing
     def call_utilization_helper(resources, hosts)
-      utilization_from_resource_origins(resources, hosts)
+      all_host_resources, missing_hosts = utilization_from_resource_origins(resources, hosts)
+      unless all_host_resources.key?(name)
+        raise HostResourcesException,
+          "Host #{name} was not included when determining host resources."
+      end
+      current_host_resources = all_host_resources[name]
+      [current_host_resources, missing_hosts]
     end
   end
 end

data/app/models/foreman_resource_quota/host_resources.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  class HostResources < ApplicationRecord
+    self.table_name = 'hosts_resources'
+
+    belongs_to :host, class_name: '::Host::Managed'
+    validates :host, { presence: true, uniqueness: true }
+
+    def resources
+      {
+        cpu_cores: cpu_cores,
+        memory_mb: memory_mb,
+        disk_gb: disk_gb,
+      }
+    end
+
+    def resources=(val)
+      allowed_attributes = val.slice(:cpu_cores, :memory_mb, :disk_gb)
+      assign_attributes(allowed_attributes) # Set multiple attributes at once (given a hash)
+    end
+
+    # Returns an array of unknown host resources (returns an empty array if all are known)
+    # For example, completely unknown host resources returns:
+    #   [
+    #     :cpu_cores,
+    #     :memory_mb,
+    #     :disk_gb,
+    #   ]
+    # Consider only the resource_quota's active resources by default.
+    def missing_resources(only_active_resources: true)
+      empty_resources = []
+      resources_to_check = %i[cpu_cores memory_mb disk_gb]
+      resources_to_check = host.resource_quota.active_resources if only_active_resources && host.resource_quota.present?
+
+      resources_to_check.each do |single_resource|
+        empty_resources << single_resource if send(single_resource).nil?
+      end
+
+      empty_resources
+    end
+  end
+end

data/app/models/foreman_resource_quota/resource_quota.rb

@@ -12,12 +12,12 @@ module ForemanResourceQuota
 
     self.table_name = 'resource_quotas'
 
+    has_many :resource_quotas_hosts, class_name: 'ResourceQuotaHost', inverse_of: :resource_quota, dependent: :destroy
     has_many :resource_quotas_users, class_name: 'ResourceQuotaUser', inverse_of: :resource_quota, dependent: :destroy
     has_many :resource_quotas_usergroups, class_name: 'ResourceQuotaUsergroup', inverse_of: :resource_quota,
       dependent: :destroy
-    has_many :resource_quotas_missing_hosts, class_name: 'ResourceQuotaMissingHost', inverse_of: :resource_quota,
-      dependent: :destroy
-    has_many :hosts, class_name: '::Host::Managed', dependent: :nullify
+    has_many :hosts, -> { distinct }, class_name: '::Host::Managed', through: :resource_quotas_hosts
+    has_many :hosts_resources, class_name: 'HostResources', through: :hosts
     has_many :users, class_name: '::User', through: :resource_quotas_users
     has_many :usergroups, class_name: '::Usergroup', through: :resource_quotas_usergroups
 
@@ -26,8 +26,12 @@ module ForemanResourceQuota
     scoped_search on: :name, complete_value: true
     scoped_search on: :id, complete_enabled: false, only_explicit: true, validator: ScopedSearch::Validators::INTEGER
 
+    def self.permission_name
+      'resource_quotas'
+    end
+
     def number_of_hosts
-      hosts.size
+      hosts_resources.size
     end
 
     def number_of_users
@@ -49,54 +53,84 @@ module ForemanResourceQuota
     #       "host_a": [ :cpu_cores, :disk_gb ],
     #       "host_b": [ :memory_mb ],
     #     }
-    def missing_hosts
-      # Initialize default value as an empty array
-      missing_hosts_list = Hash.new { |hash, key| hash[key] = [] }
-      resource_quotas_missing_hosts.each do |missing_host_rel|
-        host_name = missing_host_rel.missing_host.name
-        missing_hosts_list[host_name] << :cpu_cores if missing_host_rel.no_cpu_cores
-        missing_hosts_list[host_name] << :memory_mb if missing_host_rel.no_memory_mb
-        missing_hosts_list[host_name] << :disk_gb if missing_host_rel.no_disk_gb
+    # Parameters:
+    #   - exclude: an Array of host names to exclude from the utilization
+    def missing_hosts(exclude: [])
+      missing_hosts = {}
+      active_resources.each do |single_resource|
+        hosts_resources.where(single_resource => nil).includes([:host]).find_each do |host_resources_item|
+          host_name = host_resources_item.host.name
+          next if exclude.include?(host_name)
+          missing_hosts[host_name] ||= []
+          missing_hosts[host_name] << single_resource
+        end
       end
-      missing_hosts_list
+      missing_hosts
     end
 
-    # Set the hosts that are listed in resource_quotas_missing_hosts
+    # Returns a Hash with the quota resources and their utilization as key-value pair
+    # It returns always all resources, even if they are not used (nil in that case).
+    # For example:
+    #   {
+    #     cpu_cores: 10,
+    #     memory_mb: nil,
+    #     disk_gb: 20,
+    #   }
     # Parameters:
-    #   - val: Hash of host names and list of missing resources
-    #     { <host name>: [<list of missing resources>] }
-    #     for example:
-    #     {
-    #       "host_a": [ :cpu_cores, :disk_gb ],
-    #       "host_b": [ :memory_mb ],
-    #     }
-    def missing_hosts=(val)
-      # Delete all entries and write new ones
-      resource_quotas_missing_hosts.delete_all
-      val.each do |host_name, missing_resources|
-        add_missing_host(host_name, missing_resources)
+    #   - exclude: an Array of host names to exclude from the utilization
+    def utilization(exclude: [])
+      current_utilization = {
+        cpu_cores: nil,
+        memory_mb: nil,
+        disk_gb: nil,
+      }
+
+      active_resources.each do |resource|
+        current_utilization[resource] = 0
+      end
+
+      hosts_resources.each do |host_resources_item|
+        next if exclude.include?(host_resources_item.host.name)
+
+        active_resources.each do |resource|
+          current_utilization[resource] += host_resources_item.send(resource).to_i
+        end
       end
+
+      current_utilization
     end
 
-    def utilization
-      {
-        cpu_cores: utilization_cpu_cores,
-        memory_mb: utilization_memory_mb,
-        disk_gb: utilization_disk_gb,
-      }
+    def hosts_resources_as_hash
+      resources_hash = hosts.map(&:name).index_with { {} }
+      hosts_resources.each do |host_resources_item|
+        active_resources do |resource_name|
+          resources_hash[host_resources_item.host.name][resource_name] = host_resources_item.send(resource_name)
+        end
+      end
+      resources_hash
     end
 
-    def utilization=(val)
-      update_single_utilization(:cpu_cores, val)
-      update_single_utilization(:memory_mb, val)
-      update_single_utilization(:disk_gb, val)
+    def update_hosts_resources(hosts_resources_hash)
+      # Only update hosts that are associated with this quota
+      update_hosts = hosts.where(name: hosts_resources_hash.keys)
+      update_hosts_ids = update_hosts.pluck(:name, :id).to_h
+      hosts_resources_hash.each do |host_name, resources|
+        # Update the host_resources without loading the whole host object
+        host_resources_item = hosts_resources.find_by(host_id: update_hosts_ids[host_name])
+        if host_resources_item
+          host_resources_item.resources = resources
+          host_resources_item.save
+        else
+          Rails.logger.warn "HostResources not found for host_name: #{host_name}"
+        end
+      end
     end
 
     def determine_utilization(additional_hosts = [])
       quota_hosts = (hosts | (additional_hosts))
-      quota_utilization, missing_hosts_resources = call_utilization_helper(quota_hosts)
-      update(utilization: quota_utilization)
-      update(missing_hosts: missing_hosts_resources)
+      all_host_resources, missing_hosts_resources = call_utilization_helper(quota_hosts)
+      update_hosts_resources(all_host_resources)
+
       Rails.logger.warn create_hosts_resources_warning(missing_hosts_resources) unless missing_hosts.empty?
     rescue StandardError => e
       Rails.logger.error("An error occured while determining resources for quota '#{name}': #{e}")
@@ -128,25 +162,5 @@ module ForemanResourceQuota
         warn_text << "  '#{host_name}': '#{missing_resources}'\n" unless missing_resources.empty?
       end
     end
-
-    def update_single_utilization(attribute, val)
-      return unless val.key?(attribute.to_sym) || val.key?(attribute.to_s)
-      update("utilization_#{attribute}": val[attribute.to_sym] || val[attribute.to_s])
-    end
-
-    def add_missing_host(host_name, missing_resources)
-      return if missing_resources.empty?
-
-      host = Host::Managed.find_by(name: host_name)
-      raise HostNotFoundException if host.nil?
-
-      resource_quotas_missing_hosts << ResourceQuotaMissingHost.new(
-        missing_host: host,
-        resource_quota: self,
-        no_cpu_cores: missing_resources.include?(:cpu_cores),
-        no_memory_mb: missing_resources.include?(:memory_mb),
-        no_disk_gb: missing_resources.include?(:disk_gb)
-      )
-    end
   end
 end

data/app/models/foreman_resource_quota/resource_quota_host.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  class ResourceQuotaHost < ApplicationRecord
+    self.table_name = 'resource_quotas_hosts'
+
+    belongs_to :resource_quota, class_name: 'ResourceQuota'
+    belongs_to :host, class_name: '::Host::Managed'
+  end
+end

data/app/services/foreman_resource_quota/resource_origin.rb

@@ -8,12 +8,12 @@ module ForemanResourceQuota
       disk_gb: :extract_disk_gb,
     }.freeze
 
-    def collect_resources!(resources_sum, missing_hosts_resources, host_objects)
+    def collect_resources!(hosts_resources, missing_hosts_resources, host_objects)
       return if missing_hosts_resources.empty?
 
       relevant_hosts = load_hosts_eagerly(missing_hosts_resources, host_objects, host_attribute_eager_name)
       host_values = collect_attribute_from_hosts(relevant_hosts, host_attribute_name)
-      sum_resources_and_delete_missing_hosts!(resources_sum, missing_hosts_resources, host_values)
+      process_resources_and_delete_missing_hosts!(hosts_resources, missing_hosts_resources, host_values)
     end
 
     def host_attribute_eager_name
@@ -65,12 +65,12 @@ module ForemanResourceQuota
       host_values
     end
 
-    def sum_resources_and_delete_missing_hosts!(resources_sum, missing_hosts_resources, host_values)
+    def process_resources_and_delete_missing_hosts!(hosts_resources, missing_hosts_resources, host_values)
       host_values.each do |host_name, attribute_content|
         missing_hosts_resources[host_name].reverse_each do |resource_name|
           resource_value = process_resource(resource_name, attribute_content)
           next unless resource_value
-          resources_sum[resource_name] += resource_value
+          hosts_resources[host_name][resource_name] = resource_value
           missing_hosts_resources[host_name].delete(resource_name)
         end
         missing_hosts_resources.delete(host_name) if missing_hosts_resources[host_name].empty?

data/app/services/foreman_resource_quota/resource_origins/compute_resource_origin.rb

@@ -20,7 +20,7 @@ module ForemanResourceQuota
         nil
       end
 
-      def collect_resources!(resources_sum, missing_hosts_resources, _host_objects)
+      def collect_resources!(hosts_resources, missing_hosts_resources, _host_objects)
         compute_resource_to_hosts = group_hosts_by_compute_resource(missing_hosts_resources.keys)
 
         compute_resource_to_hosts.each do |compute_resource_id, hosts|
@@ -32,7 +32,7 @@ module ForemanResourceQuota
           hosts.each do |host|
             vm = host_vms.find { |obj| obj.send(vm_id_attr) == host.uuid }
             next unless vm
-            process_host_vm!(resources_sum, missing_hosts_resources, host.name, vm)
+            process_host_vm!(hosts_resources, missing_hosts_resources, host.name, vm)
           end
         end
       end
@@ -63,16 +63,16 @@ module ForemanResourceQuota
 
       # Processes a host's virtual machines and updates resource allocation.
       # Parameters:
-      #   - resources_sum: Hash containing total resources sum.
+      #   - hosts_resources: Hash containing successfully determined resources per host.
       #   - missing_hosts_resources: Hash containing missing resources per host.
-      #   - host_name: Name of the host.
+      #   - host: Host object
       #   - vm: Compute resource VM object of given host.
       # Returns: None.
-      def process_host_vm!(resources_sum, missing_hosts_resources, host_name, host_vm)
+      def process_host_vm!(hosts_resources, missing_hosts_resources, host_name, host_vm)
         missing_hosts_resources[host_name].reverse_each do |resource_name|
           resource_value = process_resource(resource_name, host_vm)
           next unless resource_value
-          resources_sum[resource_name] += resource_value
+          hosts_resources[host_name][resource_name] = resource_value
           missing_hosts_resources[host_name].delete(resource_name)
         end
         missing_hosts_resources.delete(host_name) if missing_hosts_resources[host_name].empty?

data/config/initializers/inflections.rb

@@ -2,4 +2,6 @@
 
 ActiveSupport::Inflector.inflections do |inflect|
   inflect.irregular 'resource_quota', 'resource_quotas'
+  inflect.irregular 'host_resources', 'hosts_resources'
+  inflect.irregular 'HostResources', 'HostsResources'
 end

data/db/migrate/20240611141744_remove_utilization_from_resource_quotas.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class RemoveUtilizationFromResourceQuotas < ActiveRecord::Migration[6.1]
+  def change
+    remove_column :resource_quotas, :utilization_cpu_cores, :integer
+    remove_column :resource_quotas, :utilization_memory_mb, :integer
+    remove_column :resource_quotas, :utilization_disk_gb, :integer
+  end
+end

data/db/migrate/20240611141939_drop_missing_hosts.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class DropMissingHosts < ActiveRecord::Migration[6.1]
+  def up
+    drop_table :resource_quotas_missing_hosts
+  end
+end

data/db/migrate/20240611142813_create_hosts_resources.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class CreateHostsResources < ActiveRecord::Migration[6.1]
+  def change
+    create_table :hosts_resources do |t|
+      t.belongs_to :host, index: { unique: true }, foreign_key: true, null: false
+      t.integer :cpu_cores, default: nil
+      t.integer :memory_mb, default: nil
+      t.integer :disk_gb, default: nil
+
+      t.timestamps
+    end
+
+    create_table :resource_quotas_hosts do |t|
+      t.belongs_to :host, index: { unique: true }, foreign_key: true, null: false
+      t.belongs_to :resource_quota, foreign_key: true, null: false
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20240618163434_remove_resource_quota_from_hosts.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class RemoveResourceQuotaFromHosts < ActiveRecord::Migration[6.1]
+  def change
+    remove_reference :hosts, :resource_quota, foreign_key: true
+  end
+end

data/lib/foreman_resource_quota/async/refresh_resource_quota_utilization.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  module Async
+    class RefreshResourceQuotaUtilization < ::Actions::EntryAction
+      include ::Actions::RecurringAction
+
+      def run
+        ResourceQuota.all.each do |quota|
+          quota.determine_utilization
+        rescue e
+          logger.error N_(format("An error occured determining the utilization of '%s'-quota: %s", quota.name, e))
+        end
+      end
+
+      def logger
+        action_logger
+      end
+
+      def rescue_strategy_for_self
+        Dynflow::Action::Rescue::Fail
+      end
+    end
+  end
+end

data/lib/foreman_resource_quota/engine.rb

@@ -1,16 +1,11 @@
 # frozen_string_literal: true
 
+require 'foreman_tasks'
+
 module ForemanResourceQuota
   class Engine < ::Rails::Engine
     engine_name 'foreman_resource_quota'
 
-    config.autoload_paths += Dir["#{config.root}/app/models/"]
-    config.autoload_paths += Dir["#{config.root}/app/controllers/"]
-    config.autoload_paths += Dir["#{config.root}/app/views/"]
-    config.autoload_paths += Dir["#{config.root}/app/services/foreman_resource_quota/"]
-    config.autoload_paths += Dir["#{config.root}/app/helpers/foreman_resource_quota/"]
-    config.autoload_paths += Dir["#{config.root}/lib/"]
-
     # Add db migrations
     initializer 'foreman_resource_quota.load_app_instance_data' do |app|
       ForemanResourceQuota::Engine.paths['db/migrate'].existent.each do |path|
@@ -34,8 +29,10 @@ module ForemanResourceQuota
     end
 
     # Plugin extensions
-    initializer 'foreman_resource_quota.register_plugin', before: :finisher_hook do |_app|
-      require 'foreman_resource_quota/register'
+    initializer 'foreman_resource_quota.register_plugin', before: :finisher_hook do |app|
+      app.reloader.to_prepare do
+        require 'foreman_resource_quota/register'
+      end
     end
 
     # Include concerns in this config.to_prepare block
@@ -47,10 +44,47 @@ module ForemanResourceQuota
       Rails.logger.warn "ForemanResourceQuota: skipping engine hook (#{e})"
     end
 
+    # Register ForemanTasks-based recurring logic/scheduled tasks
+    initializer 'foreman_resource_quota.register_scheduled_tasks', before: :finisher_hook do |_app|
+      action_paths = [ForemanResourceQuota::Engine.root.join('lib/foreman_resource_quota/async')]
+      ::ForemanTasks.dynflow.config.eager_load_paths.concat(action_paths)
+
+      # Skip object creation if the admin user is not present
+      # skip database manipulations while tables do not exist, like in migrations
+      if ActiveRecord::Base.connection.data_source_exists?(::ForemanTasks::Task.table_name) &&
+         User.unscoped.find_by_login(User::ANONYMOUS_ADMIN).present?
+        # Register the scheduled tasks
+        ::ForemanTasks.dynflow.config.on_init(false) do |_world|
+          ForemanResourceQuota::Engine.register_scheduled_task(
+            ForemanResourceQuota::Async::RefreshResourceQuotaUtilization,
+            '0 1 * * *'
+          )
+        end
+      end
+    rescue ActiveRecord::NoDatabaseError => e
+      Rails.logger.warn "ForemanResourceQuota: skipping ForemanTasks registration hook (#{e})"
+    end
+
     initializer 'foreman_resource_quota.register_gettext', after: :load_config_initializers do |_app|
       locale_dir = File.join(File.expand_path('../..', __dir__), 'locale')
       locale_domain = 'foreman_resource_quota'
       Foreman::Gettext::Support.add_text_domain locale_domain, locale_dir
     end
+
+    # Helper to register ForemanTasks
+    def self.register_scheduled_task(task_class, cronline)
+      return if ::ForemanTasks::RecurringLogic.joins(:tasks)
+                                              .merge(::ForemanTasks::Task.where(label: task_class.name))
+                                              .exists?
+      ::ForemanTasks::RecurringLogic.transaction(isolation: :serializable) do
+        User.as_anonymous_admin do
+          recurring_logic = ::ForemanTasks::RecurringLogic.new_from_cronline(cronline)
+          recurring_logic.save!
+          recurring_logic.start(task_class)
+        end
+      end
+    rescue ActiveRecord::TransactionIsolationError => e
+      Rails.logger.warn "ForemanResourceQuota: skipping RecurringLogic registration hook (#{e})"
+    end
   end
 end

data/lib/foreman_resource_quota/register.rb

@@ -2,29 +2,29 @@
 
 # rubocop: disable Metrics/BlockLength
 Foreman::Plugin.register :foreman_resource_quota do
-  requires_foreman '>= 3.5.0'
+  requires_foreman '>= 3.13'
   # Apipie
   apipie_documented_controllers ["#{ForemanResourceQuota::Engine.root}" \
                                  '/app/controllers/foreman_resource_quot/api/v2/*.rb']
 
   # Add permissions
   security_block :foreman_resource_quota do
-    permission 'view_foreman_resource_quota/resource_quotas',
+    permission :view_resource_quotas,
       { 'foreman_resource_quota/resource_quotas': %i[index welcome auto_complete_search],
         'foreman_resource_quota/api/v2/resource_quotas': %i[index show utilization missing_hosts hosts users usergroups
                                                             auto_complete_search],
         'foreman_resource_quota/api/v2/resource_quotas/:resource_quota_id/': %i[utilization missing_hosts hosts users
                                                                                 usergroups] },
       resource_type: 'ForemanResourceQuota::ResourceQuota'
-    permission 'create_foreman_resource_quota/resource_quotas',
+    permission :create_resource_quotas,
       { 'foreman_resource_quota/resource_quotas': %i[new create],
         'foreman_resource_quota/api/v2/resource_quotas': %i[create] },
       resource_type: 'ForemanResourceQuota::ResourceQuota'
-    permission 'edit_foreman_resource_quota/resource_quotas',
+    permission :edit_resource_quotas,
       { 'foreman_resource_quota/resource_quotas': %i[edit update],
         'foreman_resource_quota/api/v2/resource_quotas': %i[update] },
       resource_type: 'ForemanResourceQuota::ResourceQuota'
-    permission 'destroy_foreman_resource_quota/resource_quotas',
+    permission :destroy_resource_quotas,
       { 'foreman_resource_quota/resource_quotas': %i[destroy],
         'foreman_resource_quota/api/v2/resource_quotas': %i[destroy] },
       resource_type: 'ForemanResourceQuota::ResourceQuota'
@@ -33,18 +33,18 @@ Foreman::Plugin.register :foreman_resource_quota do
   end
 
   # Add a permissions to default roles (Viewer and Manager)
-  role 'Resource Quota Manager', ['view_foreman_resource_quota/resource_quotas',
-                                  'create_foreman_resource_quota/resource_quotas',
-                                  'edit_foreman_resource_quota/resource_quotas',
-                                  'destroy_foreman_resource_quota/resource_quotas',
-                                  'view_hosts',
-                                  'edit_hosts',
-                                  'view_users',
-                                  'edit_users']
-  role 'Resource Quota User', ['view_foreman_resource_quota/resource_quotas',
-                               'view_hosts',
-                               'view_users',
-                               'view_usergroups']
+  role 'Resource Quota Manager', %i[view_resource_quotas
+                                    create_resource_quotas
+                                    edit_resource_quotas
+                                    destroy_resource_quotas
+                                    view_hosts
+                                    edit_hosts
+                                    view_users
+                                    edit_users]
+  role 'Resource Quota User', %i[view_resource_quotas
+                                 view_hosts
+                                 view_users
+                                 view_usergroups]
   add_all_permissions_to_default_roles
 
   # add controller parameter extension

data/lib/foreman_resource_quota/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ForemanResourceQuota
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
 end

data/package.json

@@ -25,7 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@babel/core": "^7.7.0",
+    "@babel/core": "^7.26.0",
     "@sheerun/mutationobserver-shim": "^0.3.3",
     "@testing-library/react": "^10.4.9",
     "@theforeman/builder": ">=12.0.1",
@@ -37,7 +37,7 @@
     "eslint": "^6.7.2",
     "prettier": "^1.19.1",
     "react-redux-test-utils": "^0.2.0",
-    "stylelint": "^16.4.0",
+    "stylelint": "^16.10.0",
     "stylelint-config-standard": "^36.0.0"
   }
 }

metadata

@@ -1,15 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: foreman_resource_quota
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Bastian Schmidt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-09 00:00:00.000000000 Z
-dependencies: []
+date: 2024-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: foreman-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '11'
+- !ruby/object:Gem::Dependency
+  name: theforeman-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 description: Foreman Plug-in to manage resource usage among users.
 email:
 - schmidt@atix.de
@@ -26,11 +60,13 @@ files:
 - app/controllers/foreman_resource_quota/resource_quotas_controller.rb
 - app/helpers/foreman_resource_quota/hosts_helper.rb
 - app/helpers/foreman_resource_quota/resource_quota_helper.rb
+- app/lib/foreman_resource_quota/exceptions.rb
 - app/models/concerns/foreman_resource_quota/host_managed_extensions.rb
 - app/models/concerns/foreman_resource_quota/user_extensions.rb
 - app/models/concerns/foreman_resource_quota/usergroup_extensions.rb
+- app/models/foreman_resource_quota/host_resources.rb
 - app/models/foreman_resource_quota/resource_quota.rb
-- app/models/foreman_resource_quota/resource_quota_missing_host.rb
+- app/models/foreman_resource_quota/resource_quota_host.rb
 - app/models/foreman_resource_quota/resource_quota_user.rb
 - app/models/foreman_resource_quota/resource_quota_usergroup.rb
 - app/services/foreman_resource_quota/resource_origin.rb
@@ -62,9 +98,13 @@ files:
 - config/initializers/inflections.rb
 - config/routes.rb
 - db/migrate/20230306120001_create_resource_quotas.rb
+- db/migrate/20240611141744_remove_utilization_from_resource_quotas.rb
+- db/migrate/20240611141939_drop_missing_hosts.rb
+- db/migrate/20240611142813_create_hosts_resources.rb
+- db/migrate/20240618163434_remove_resource_quota_from_hosts.rb
 - lib/foreman_resource_quota.rb
+- lib/foreman_resource_quota/async/refresh_resource_quota_utilization.rb
 - lib/foreman_resource_quota/engine.rb
-- lib/foreman_resource_quota/exceptions.rb
 - lib/foreman_resource_quota/register.rb
 - lib/foreman_resource_quota/version.rb
 - lib/tasks/foreman_resource_quota_tasks.rake

data/app/models/foreman_resource_quota/resource_quota_missing_host.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module ForemanResourceQuota
-  class ResourceQuotaMissingHost < ApplicationRecord
-    self.table_name = 'resource_quotas_missing_hosts'
-
-    belongs_to :resource_quota, inverse_of: :resource_quotas_missing_hosts
-    belongs_to :missing_host, class_name: '::Host::Managed', inverse_of: :resource_quota_missing_resources
-  end
-end