foreman_resource_quota 0.1.0

data/Rakefile

@@ -0,0 +1,49 @@
+#!/usr/bin/env rake
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ForemanResourceQuota'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue StandardError => _e
+  puts 'Rubocop not loaded.'
+end
+
+task :default do
+  Rake::Task['rubocop'].execute
+end

data/app/controllers/concerns/foreman/controller/parameters/resource_quota.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Foreman
+  module Controller
+    module Parameters
+      module ResourceQuota
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def resource_quota_params_filter
+            Foreman::ParameterFilter.new(::ForemanResourceQuota::ResourceQuota).tap do |filter|
+              filter.permit :name
+              filter.permit :description
+              filter.permit :cpu_cores
+              filter.permit :memory_mb
+              filter.permit :disk_gb
+            end
+          end
+        end
+
+        def resource_quota_params
+          param_name = parameter_filter_context.api? ? 'resource_quota' : 'foreman_resource_quota_resource_quota'
+          self.class.resource_quota_params_filter.filter_params(params, parameter_filter_context, param_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  module Api
+    module V2
+      class ResourceQuotasController < ::Api::V2::BaseController
+        include ::Api::Version2
+        include Foreman::Controller::Parameters::ResourceQuota
+
+        resource_description do
+          resource_id 'resource_quota'
+          api_version 'v2'
+          api_base_url '/foreman_resource_quota/api'
+        end
+
+        before_action :find_resource, only: %i[show update destroy]
+        before_action :custom_find_resource, only: %i[utilization hosts users usergroups]
+
+        api :GET, '/resource_quotas', N_('List all resource quotas')
+        param_group :search_and_pagination, ::Api::V2::BaseController
+        add_scoped_search_description_for(ForemanResourceQuota::ResourceQuota)
+        def index
+          @resource_quotas = resource_scope_for_index
+        end
+
+        api :GET, '/resource_quotas/:id/', N_('Show resource quota')
+        param :id, :identifier, required: true
+        def show
+        end
+
+        api :GET, '/resource_quotas/:id/utilization', N_('Show used resources of assigned hosts')
+        param :id, :identifier, required: true
+        def utilization
+          @resource_quota.determine_utilization
+          process_response @resource_quota
+        end
+
+        api :GET, '/resource_quotas/:id/hosts', N_('Show hosts of a resource quota')
+        param :id, :identifier, required: true
+        def hosts
+          process_response @resource_quota.hosts
+        end
+
+        api :GET, '/resource_quotas/:id/users', N_('Show users of a resource quota')
+        param :id, :identifier, required: true
+        def users
+          process_response @resource_quota.users
+        end
+
+        api :GET, '/resource_quotas/:id/usergroups', N_('Show usergroups of a resource quota')
+        param :id, :identifier, required: true
+        def usergroups
+          process_response @resource_quota.usergroups
+        end
+
+        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
+
+        api :POST, '/resource_quotas/', N_('Create a resource quota')
+        param_group :resource_quota, as: :create
+        def create
+          @resource_quota = ForemanResourceQuota::ResourceQuota.new(resource_quota_params)
+          process_response @resource_quota.save
+        end
+
+        api :PUT, '/resource_quotas/:id/', N_('Update a resource quota')
+        param :id, :identifier, required: true
+        param_group :resource_quota
+        def update
+          process_response @resource_quota.update(resource_quota_params)
+        end
+
+        api :DELETE, '/resource_quotas/:id/', N_('Delete a resource quota')
+        param :id, :identifier, required: true
+        def destroy
+          process_response @resource_quota.destroy
+        end
+
+        def resource_class
+          ForemanResourceQuota::ResourceQuota
+        end
+
+        private
+
+        def custom_find_resource
+          @resource_quota = ForemanResourceQuota::ResourceQuota.find_by(id: params[:resource_quota_id])
+          not_found unless @resource_quota
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_resource_quota/application_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  class ApplicationController < ::ApplicationController
+    def resource_class
+      "ForemanResourceQuota::#{controller_name.singularize.classify}".constantize
+    end
+  end
+end

data/app/controllers/foreman_resource_quota/resource_quotas_controller.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  class ResourceQuotasController < ::ForemanResourceQuota::ApplicationController
+    include Foreman::Controller::AutoCompleteSearch
+    include Foreman::Controller::Parameters::ResourceQuota
+
+    before_action :find_resource, only: %i[edit update destroy]
+
+    def index
+      @resource_quotas = resource_base.search_for(params[:search], order: params[:order]).paginate(page: params[:page],
+        per_page: params[:per_page])
+      # TODO: Check necessitiy/purpose of authorizer
+      # AuthorizerHelper#authorizer uses controller_name as variable name, but it fails with namespaces
+      # @authorizer = Authorizer.new(User.current, collection: @resource_quotas)
+    end
+
+    def new
+      @resource_quota = ResourceQuota.new
+    end
+
+    def create
+      @resource_quota = ResourceQuota.new(resource_quota_params)
+      if @resource_quota.save
+        process_success
+      else
+        process_error
+      end
+    end
+
+    def edit
+    end
+
+    def update
+      if @resource_quota.update(resource_quota_params)
+        process_success
+      else
+        process_error
+      end
+    end
+
+    def destroy
+      if @resource_quota.destroy
+        process_success
+      else
+        process_error
+      end
+    end
+  end
+end

data/app/helpers/foreman_resource_quota/hosts_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  module HostsHelper
+    def resource_quota_select(form, user_quotas)
+      blank_opt = { include_blank: true }
+      select_items = user_quotas.order(:name)
+      select_f form,
+        :resource_quota_id,
+        select_items,
+        :id,
+        :to_label,
+        blank_opt,
+        label: _('Resource Quota'),
+        help_inline: _('Define the Resource Quota this host counts to.')
+    end
+  end
+end

data/app/helpers/foreman_resource_quota/resource_quota_helper.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  module ResourceQuotaHelper
+    FACTOR_B_TO_KB = 1024
+    FACTOR_B_TO_MB = 1024 * 1024
+    FACTOR_B_TO_GB = 1024 * FACTOR_B_TO_MB
+
+    def natural_resource_name_by_type(resource_type)
+      type_names = { cpu_cores: 'CPU cores', memory_mb: 'Memory', disk_gb: 'Disk space' }
+      key = resource_type.is_a?(String) ? resource_type.to_sym : resource_type
+      raise "No natural name for unknown resource type '#{resource_type}'" unless type_names.key?(key)
+      type_names[key]
+    end
+
+    def units_by_type(resource_type)
+      type_units = {
+        cpu_cores: [
+          { symbol: 'cores', factor: 1 },
+        ],
+        memory_mb: [
+          { symbol: 'MB', factor: 1 },
+          { symbol: 'GB', factor: FACTOR_B_TO_KB },
+          { symbol: 'TB', factor: FACTOR_B_TO_MB },
+        ],
+        disk_gb: [
+          { symbol: 'GB', factor: 1 },
+          { symbol: 'TB', factor: FACTOR_B_TO_KB },
+          { symbol: 'PB', factor: FACTOR_B_TO_MB },
+        ],
+      }
+      key = resource_type.to_sym
+      raise "No units for unknown resource type '#{resource_type}'" unless type_units.key?(key)
+      type_units[key]
+    end
+
+    def find_largest_unit(resource_value, units)
+      units.reverse_each do |unit|
+        return unit.values_at(:symbol, :factor) if resource_value >= unit[:factor]
+      end
+      units[0].values_at(:symbol, :factor)
+    end
+
+    def resource_value_to_string(resource_value, resource_type)
+      (symbol, factor) = find_largest_unit(resource_value, units_by_type(resource_type))
+      unit_applied_value = (resource_value / factor).round(1)
+      format_text = if (unit_applied_value % 1).zero?
+                      '%.0f %s'
+                    else
+                      '%.1f %s'
+                    end
+      format(format_text, unit_applied_value, symbol)
+    end
+
+    def utilization_from_resource_origins(resources, hosts, custom_resource_origins: nil)
+      utilization_sum = resources.each.with_object({}) { |key, hash| hash[key] = 0 }
+      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,
+          missing_hosts_resources,
+          hosts_hash
+        )
+      end
+
+      [utilization_sum, missing_hosts_resources]
+    end
+
+    private
+
+    # Create a Hash that maps resources to host names.
+    # { <host name>: [<list of to be determined resources>] }
+    #     for example:
+    #     {
+    #       "host_a": {
+    #         [ :cpu_cores, :disk_gb ]
+    #       },
+    #       "host_b": {
+    #         [ :cpu_cores, :disk_gb ]
+    #       },
+    # 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 resources as values.
+    def create_missing_hosts_resources_hash(hosts, resources)
+      return {} if hosts.empty? || resources.empty?
+
+      resources_to_determine = resources.compact
+      return {} if resources_to_determine.empty?
+
+      hosts.map(&:name).index_with { resources_to_determine.clone }
+    end
+
+    # Default classes that are used to determine host resources. Determines
+    # resources in the order of this list.
+    def default_resource_origin_classes
+      [
+        ResourceOrigins::ComputeResourceOrigin,
+        ResourceOrigins::VMAttributesOrigin,
+        ResourceOrigins::ComputeAttributesOrigin,
+        ResourceOrigins::FactsOrigin,
+      ]
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  module HostManagedExtensions
+    extend ActiveSupport::Concern
+    include ForemanResourceQuota::ResourceQuotaHelper
+    include ForemanResourceQuota::Exceptions
+
+    included do
+      validate :check_resource_quota_capacity
+
+      belongs_to :resource_quota, class_name: '::ForemanResourceQuota::ResourceQuota'
+      scoped_search relation: :resource_quota, on: :name, complete_value: true, rename: :resource_quota
+    end
+
+    def check_resource_quota_capacity
+      handle_quota_check
+      true
+    rescue ResourceQuotaException => e
+      handle_error('resource_quota_id',
+        e.bare_message,
+        format('An error occured while checking the resource quota capacity: %s', e))
+    rescue Foreman::Exception => e
+      handle_error(:base,
+        e.bare_message,
+        format('An unexpected Foreman error occured while checking the resource quota capacity: %s', e))
+    rescue StandardError => e
+      handle_error(:base,
+        e.message,
+        format('An unknown error occured while checking the resource quota capacity: %s', e))
+    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)
+    end
+
+    def handle_error(error_module, error_message, log_message)
+      errors.add(error_module, error_message)
+      Rails.logger.error(N_(log_message))
+      false
+    end
+
+    def determine_quota_utilization
+      resource_quota.determine_utilization
+      missing_hosts = resource_quota.missing_hosts
+      unless missing_hosts.empty?
+        raise ResourceQuotaUtilizationException,
+          "Resource Quota '#{resource_quota.name}' cannot determine resources for #{missing_hosts.size} hosts."
+      end
+      resource_quota.utilization
+    end
+
+    def determine_host_resources
+      (host_resources, missing_hosts) = call_utilization_helper(resource_quota.active_resources, [self])
+      unless missing_hosts.empty?
+        raise HostResourcesException,
+          "Cannot determine host resources for #{name}"
+      end
+      host_resources
+    end
+
+    def verify_resource_quota_limits(quota_utilization, 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]
+        next if all_hosts_utilization <= max_quota
+
+        raise ResourceLimitException, formulate_limit_error(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
+        N_(format("Host exceeds %s limit of '%s'-quota by %s (max. %s)",
+          natural_resource_name_by_type(resource_type),
+          resource_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,
+          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?
+        return true if quota_assigment_optional?
+        raise HostResourceQuotaEmptyException, 'must be given.'
+      end
+      return true if resource_quota.active_resources.empty?
+      return true if Setting[:resource_quota_global_no_action] # quota is assigned, but not supposed to be checked
+      false
+    end
+
+    def quota_assigment_optional?
+      owner.resource_quota_is_optional || Setting[:resource_quota_optional_assignment]
+    end
+
+    # Wrap into a function for easier testing
+    def call_utilization_helper(resources, hosts)
+      utilization_from_resource_origins(resources, hosts)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  module UserExtensions
+    extend ActiveSupport::Concern
+    included do
+      has_many :resource_quota_users, class_name: 'ForemanResourceQuota::ResourceQuotaUser', dependent: :destroy,
+        inverse_of: :user
+      has_many :resource_quotas, class_name: 'ForemanResourceQuota::ResourceQuota', through: :resource_quota_users
+      attribute :resource_quota_is_optional, :boolean, default: false
+
+      scoped_search relation: :resource_quotas, on: :name, complete_value: true, rename: :resource_quota
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  module UsergroupExtensions
+    extend ActiveSupport::Concern
+    included do
+      has_many :resource_quota_usergroups, class_name: 'ForemanResourceQuota::ResourceQuotaUsergroup',
+        dependent: :destroy, inverse_of: :usergroup
+      has_many :resource_quotas, class_name: 'ForemanResourceQuota::ResourceQuota', through: :resource_quota_usergroups
+
+      scoped_search relation: :resource_quotas, on: :name, complete_value: true, rename: :resource_quota
+    end
+  end
+end

data/app/models/foreman_resource_quota/resource_quota.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  class ResourceQuota < ApplicationRecord
+    include ResourceQuotaHelper
+    include Authorizable
+    include Parameterizable::ByIdName
+    extend FriendlyId
+    friendly_id :name
+    audited
+
+    self.table_name = 'resource_quotas'
+
+    has_many :resource_quota_users, class_name: 'ResourceQuotaUser', inverse_of: :resource_quota, dependent: :destroy
+    has_many :users, class_name: '::User', through: :resource_quota_users
+    has_many :resource_quota_usergroups, class_name: 'ResourceQuotaUsergroup', inverse_of: :resource_quota,
+      dependent: :destroy
+    has_many :usergroups, class_name: '::Usergroup', through: :resource_quota_usergroups
+    has_many :hosts, class_name: '::Host::Managed', dependent: :nullify
+
+    validates :name, presence: true, uniqueness: true
+
+    scoped_search on: :name, complete_value: true
+    scoped_search on: :id, complete_enabled: false, only_explicit: true, validator: ScopedSearch::Validators::INTEGER
+
+    attribute :utilization, :jsonb, default: {}
+    attribute :missing_hosts, :jsonb, default: {}
+
+    def number_of_hosts
+      hosts.size
+    end
+
+    def number_of_users
+      users.size
+    end
+
+    def number_of_usergroups
+      usergroups.size
+    end
+
+    def determine_utilization(additional_hosts = [])
+      quota_hosts = (hosts | (additional_hosts))
+      self.utilization, self.missing_hosts = call_utilization_helper(quota_hosts)
+
+      print_warning(missing_hosts, quota_hosts) unless missing_hosts.empty?
+    rescue StandardError => e
+      print_error(e) # print error log here and forward error
+      raise e
+    end
+
+    def to_label
+      name
+    end
+
+    def active_resources
+      resources = []
+      %i[cpu_cores memory_mb disk_gb].each do |res|
+        resources << res unless self[res].nil?
+      end
+      resources
+    end
+
+    private
+
+    # Wrap into a function for easier testing
+    def call_utilization_helper(quota_hosts)
+      utilization_from_resource_origins(active_resources, quota_hosts)
+    end
+
+    def print_warning(missing_hosts, hosts)
+      warn_text = "Could not determines resources for #{missing_hosts.size} hosts:"
+      missing_hosts.each do |host_id, missing_resources|
+        missing_host = hosts.find { |obj| obj.id == host_id }
+        warn_text << "  '#{missing_host.name}': '#{missing_resources}'\n" unless missing_host.nil?
+      end
+      Rails.logger.warn warn_text
+    end
+
+    def print_error(err)
+      Rails.logger.error("An error occured while determining resources for quota '#{name}': #{err}")
+    end
+  end
+end

data/app/models/foreman_resource_quota/resource_quota_user.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  class ResourceQuotaUser < ApplicationRecord
+    self.table_name = 'resource_quotas_users'
+
+    belongs_to :resource_quota, inverse_of: :resource_quota_users
+    belongs_to :user, class_name: '::User', inverse_of: :resource_quota_users
+  end
+end

data/app/models/foreman_resource_quota/resource_quota_usergroup.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ForemanResourceQuota
+  class ResourceQuotaUsergroup < ApplicationRecord
+    self.table_name = 'resource_quotas_usergroups'
+
+    belongs_to :resource_quota, inverse_of: :resource_quota_usergroups
+    belongs_to :usergroup, class_name: '::Usergroup', inverse_of: :resource_quota_usergroups
+  end
+end