foreman_puppet 0.0.1

data/app/models/concerns/foreman_puppet/puppet_lookup_value_extensions.rb

@@ -0,0 +1,13 @@
+module ForemanPuppet
+  module PuppetLookupValueExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      validate :value_present?, if: ->(v) { v.lookup_key.is_a?(ForemanPuppet::PuppetclassLookupKey) }
+    end
+
+    def value_present?
+      errors.add(:value, :blank) if value.to_s.empty? && !omit
+    end
+  end
+end

data/app/models/foreman_puppet/config_group.rb

@@ -0,0 +1,45 @@
+module ForemanPuppet
+  class ConfigGroup < ApplicationRecord
+    self.table_name = 'config_groups'
+
+    audited
+    include Authorizable
+    include Parameterizable::ByIdName
+
+    validates_lengths_from_database
+
+    has_many :config_group_classes, dependent: :destroy
+    has_many :puppetclasses, through: :config_group_classes
+    has_many :host_config_groups, dependent: :destroy
+    has_many_hosts through: :host_config_groups, source: :host, source_type: 'Host::Managed'
+    has_many :hostgroups, through: :host_config_groups, source: :host, source_type: 'Hostgroup'
+
+    validates :name, presence: true, uniqueness: true
+
+    scoped_search on: :name, complete_value: true
+    scoped_search relation: :puppetclasses, on: :name, complete_value: true, rename: :class, only_explicit: true, operators: ['= ', '~ ']
+
+    default_scope -> { order('config_groups.name') }
+
+    # the following methods are required for app/views/puppetclasses/_class_selection.html.erb
+    alias_method :classes, :puppetclasses
+    alias_method :individual_puppetclasses, :puppetclasses
+
+    def available_puppetclasses
+      Puppetclass.where(nil)
+    end
+
+    # for auditing
+    def to_label
+      name
+    end
+
+    def hosts_count
+      ::Host::Managed.authorized.search_for(%(config_group="#{name}")).size
+    end
+
+    def hostgroups_count
+      ::Hostgroup.authorized.search_for(%(config_group="#{name}")).size
+    end
+  end
+end

data/app/models/foreman_puppet/config_group_class.rb

@@ -0,0 +1,19 @@
+module ForemanPuppet
+  class ConfigGroupClass < ApplicationRecord
+    self.table_name = 'config_group_classes'
+    audited associated_with: :config_group
+
+    include Authorizable
+
+    belongs_to :puppetclass
+    belongs_to :config_group
+
+    validates :puppetclass, presence: true
+    validates :config_group, presence: true,
+                             uniqueness: { scope: :puppetclass_id }
+
+    def check_permissions_after_save
+      true
+    end
+  end
+end

data/app/models/foreman_puppet/environment.rb

@@ -0,0 +1,63 @@
+module ForemanPuppet
+  class Environment < ApplicationRecord
+    self.table_name = 'environments'
+
+    audited
+    extend FriendlyId
+    friendly_id :name, reserved_words: []
+    include Taxonomix
+    include Authorizable
+    include Parameterizable::ByName
+
+    validates_lengths_from_database
+    before_destroy EnsureNotUsedBy.new(:hosts, :hostgroups)
+
+    has_many :environment_classes, dependent: :destroy
+    has_many :puppetclasses, -> { distinct }, through: :environment_classes
+    has_many :host_puppet_facets, dependent: :destroy
+    has_many :hostgroup_puppet_facets, dependent: :destroy
+    has_many_hosts through: :host_puppet_facets
+    has_many :hostgroups, through: :hostgroup_puppet_facets
+
+    validates :name, uniqueness: true, presence: true, alphanumeric: true
+    has_many :template_combinations, dependent: :destroy
+    has_many :provisioning_templates, through: :template_combinations
+
+    # with proc support, default_scope can no longer be chained
+    # include all default scoping here
+    default_scope lambda {
+      with_taxonomy_scope do
+        order('environments.name')
+      end
+    }
+
+    scoped_search on: :name, complete_value: true
+
+    class << self
+      # TODO: this needs to be removed, as PuppetDOC generation no longer works
+      # if the manifests are not on the foreman host
+      # returns an hash of all puppet environments and their relative paths
+      def puppetEnvs(proxy = nil)
+        url = (proxy || SmartProxy.with_features('Puppet').first).try(:url)
+        raise ::Foreman::Exception, N_("Can't find a valid Foreman Proxy with a Puppet feature") if url.blank?
+        proxy = ProxyAPI::Puppet.new url: url
+        HashWithIndifferentAccess[proxy.environments.map do |e|
+          [e, HashWithIndifferentAccess[proxy.classes(e).map do |k|
+            klass = k.keys.first
+            [klass, k[klass]['params']]
+          end]]
+        end]
+      end
+    end
+
+    private
+
+    def taxonomy_foreign_conditions
+      HostPuppetFacet.arel_table[:environment_id].eq(id)
+    end
+
+    def used_taxonomy_ids(type)
+      Host::Managed.joins(:puppet).where(taxonomy_foreign_conditions).distinct.pluck(type).compact
+    end
+  end
+end

data/app/models/foreman_puppet/environment_class.rb

@@ -0,0 +1,40 @@
+module ForemanPuppet
+  class EnvironmentClass < ApplicationRecord
+    self.table_name = 'environment_classes'
+
+    belongs_to :environment
+    belongs_to :puppetclass, inverse_of: :environment_classes
+    belongs_to :puppetclass_lookup_key, inverse_of: :environment_classes, class_name: 'ForemanPuppet::PuppetclassLookupKey'
+    validates :puppetclass_lookup_key_id, uniqueness: { scope: %i[environment_id puppetclass_id] }
+    validates :puppetclass_id, :environment_id, presence: true
+    after_destroy :delete_orphaned_lookup_keys
+
+    scope :parameters_for_class, lambda { |puppetclasses_ids, environment_id|
+      all_parameters_for_class(puppetclasses_ids, environment_id).where(puppetclass_lookup_keys: { override: true })
+    }
+
+    scope :all_parameters_for_class, lambda { |puppetclasses_ids, environment_id|
+      where(puppetclass_id: puppetclasses_ids, environment_id: environment_id)
+        .where.not(puppetclass_lookup_key_id: nil)
+        .includes(:puppetclass_lookup_key)
+    }
+
+    scope :used_by_other_environment_classes, lambda { |puppetclass_lookup_key_id, this_environment_class_id|
+      where(puppetclass_lookup_key_id: puppetclass_lookup_key_id)
+        .where("id != #{this_environment_class_id}")
+    }
+
+    # TODO: move these into scopes?
+    def self.is_in_any_environment(puppetclass, puppetclass_lookup_key)
+      EnvironmentClass.where(puppetclass_id: puppetclass, puppetclass_lookup_key_id: puppetclass_lookup_key).any?
+    end
+
+    def self.key_in_environment(env, puppetclass, puppetclass_lookup_key)
+      EnvironmentClass.find_by(environment_id: env, puppetclass_id: puppetclass, puppetclass_lookup_key_id: puppetclass_lookup_key)
+    end
+
+    def delete_orphaned_lookup_keys
+      puppetclass_lookup_key.destroy if puppetclass_lookup_key.present? && puppetclass_lookup_key.environment_classes.empty?
+    end
+  end
+end

data/app/models/foreman_puppet/host_class.rb

@@ -0,0 +1,23 @@
+module ForemanPuppet
+  class HostClass < ApplicationRecord
+    self.table_name = 'host_classes'
+
+    audited associated_with: :host
+    include Authorizable
+
+    validates_lengths_from_database
+    belongs_to :puppetclass
+    belongs_to :host_puppet_facet
+    has_one :host, through: :host_puppet_facet
+
+    validates :puppetclass_id, presence: true, uniqueness: { scope: :host_puppet_facet_id }
+
+    def name
+      "#{host_puppet_facet.host} - #{puppetclass}"
+    end
+
+    def check_permissions_after_save
+      true
+    end
+  end
+end

data/app/models/foreman_puppet/host_config_group.rb

@@ -0,0 +1,15 @@
+module ForemanPuppet
+  class HostConfigGroup < ApplicationRecord
+    self.table_name = 'host_config_groups'
+    include Authorizable
+    audited associated_with: :host
+    belongs_to :host, polymorphic: true
+    belongs_to :config_group
+
+    validates :host_id, uniqueness: { scope: %i[config_group_id host_type] }
+
+    def check_permissions_after_save
+      true
+    end
+  end
+end

data/app/models/foreman_puppet/host_puppet_facet.rb

@@ -0,0 +1,130 @@
+module ForemanPuppet
+  class HostPuppetFacet < ApplicationRecord
+    self.table_name = 'host_puppet_facets'
+    audited associated_with: :host
+
+    include Facets::Base
+    include ForemanPuppet::HostCommon
+
+    has_many :host_classes, dependent: :destroy
+    has_many :puppetclasses, through: :host_classes
+
+    validates :environment_id, presence: true, unless: ->(facet) { facet.host.puppet_proxy_id.blank? }
+
+    after_validation :ensure_puppet_associations
+    before_save :clear_puppetinfo, if: :environment_id_changed?
+
+    def self.populate_fields_from_facts(host, parser, type, source_proxy)
+      type ||= 'puppet'
+      return unless type == 'puppet'
+
+      if Setting[:update_environment_from_facts]
+        host.set_non_empty_values parser, [:environment]
+      elsif parser.environment.present?
+        self.environment ||= parser.environment
+      end
+
+      # if proxy authentication is enabled and we have no puppet proxy set and the upload came from puppet,
+      # use it as puppet proxy.
+      host.puppet_proxy ||= source_proxy
+    end
+
+    def self.inherited_attributes(new_hostgroup, attributes)
+      { 'environment_id' => new_hostgroup.puppet&.inherited_environment_id }.merge(attributes)
+    end
+
+    def clear_puppetinfo
+      return if environment
+      self.puppetclasses = []
+      self.config_groups = []
+    end
+
+    # the environment used by #clases nees to be self.environment and not self.parent.environment
+    def parent_classes
+      return [] unless host.hostgroup
+      host.hostgroup.puppet&.classes(environment)
+    end
+
+    def parent_config_groups
+      return [] unless host.hostgroup
+      host.hostgroup.puppet&.all_config_groups
+    end
+
+    def ensure_puppet_associations
+      status = validate_association_taxonomy(:environment)
+      return status unless environment
+
+      puppetclasses.where.not(id: environment.puppetclasses.reorder(nil)).find_each do |puppetclass|
+        errors.add(
+          :puppetclasses,
+          format(_('%{puppetclass} does not belong to the %{environment} environment'), puppetclass: puppetclass, environment: environment)
+        )
+        status = false
+      end
+      status
+    end
+
+    # this method accepts a puppets external node yaml output and generate a node in our setup
+    # it is assumed that you already have the node (e.g. imported by one of the rack tasks)
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
+    def import_puppet_node(nodeinfo)
+      myklasses = []
+      # puppet classes
+      classes = nodeinfo['classes']
+      classes = classes.keys if classes.is_a?(Hash)
+      classes.each do |klass|
+        if (pc = ForemanPuppet::Puppetclass.find_by(name: klass.to_s))
+          myklasses << pc
+        else
+          error = format(_("Failed to import %{klass} for %{name}: doesn't exists in our database - ignoring"), klass: klass, name: name)
+          logger.warn error
+          $stdout.puts error
+        end
+        self.puppetclasses = myklasses
+      end
+
+      # parameters are a bit more tricky, as some classifiers provide the facts as parameters as well
+      # not sure what is puppet priority about it, but we ignore it if has a fact with the same name.
+      # additionally, we don't import any non strings values, as puppet don't know what to do with those as well.
+
+      myparams = host.info['parameters']
+      nodeinfo['parameters'].each_pair do |param, value|
+        next if host.fact_names.exists? name: param
+        next unless value.is_a?(String)
+
+        # we already have this parameter
+        next if myparams.key?(param) && myparams[param] == value
+
+        unless (hp = host.host_parameters.create(name: param, value: value))
+          logger.warn "Failed to import #{param}/#{value} for #{name}: #{hp.errors.full_messages.join(', ')}"
+          $stdout.puts $ERROR_INFO
+        end
+      end
+
+      host.clear_host_parameters_cache!
+      save
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+
+    private
+
+    # Copy of method with same name, but for facet associations
+    def validate_association_taxonomy(association_name)
+      association = self.class.reflect_on_association(association_name)
+      raise ArgumentError, "Association #{association_name} not found" unless association
+      associated_object_id = public_send(association.foreign_key)
+      if associated_object_id.present? &&
+         association.klass.with_taxonomy_scope(host.organization, host.location).find_by(id: associated_object_id).blank?
+        errors.add(
+          association.foreign_key,
+          format(_("with id %{object_id} doesn't exist or is not assigned to proper organization and/or location"), object_id: associated_object_id)
+        )
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/app/models/foreman_puppet/hostgroup_class.rb

@@ -0,0 +1,23 @@
+module ForemanPuppet
+  class HostgroupClass < ApplicationRecord
+    self.table_name = 'hostgroup_classes'
+
+    audited associated_with: :hostgroup
+    include Authorizable
+
+    belongs_to :puppetclass
+    belongs_to :hostgroup_puppet_facet
+    has_one :hostgroup, through: :hostgroup_puppet_facet
+
+    validates :hostgroup_puppet_facet, presence: true
+    validates :puppetclass_id, presence: true, uniqueness: { scope: :hostgroup_puppet_facet_id }
+
+    def name
+      "#{hostgroup} - #{puppetclass}"
+    end
+
+    def check_permissions_after_save
+      true
+    end
+  end
+end

data/app/models/foreman_puppet/hostgroup_puppet_facet.rb

@@ -0,0 +1,98 @@
+module ForemanPuppet
+  class HostgroupPuppetFacet < ApplicationRecord
+    # ------ ANCESTRY ATTRIBUTES -------
+    # This mimic nested attributes, that should probably be provided by Facets::HostgroupFacet
+
+    class << self
+      attr_reader :nested_attribute_fields
+
+      def nested_attribute_for(*fields)
+        @nested_attribute_fields ||= []
+        @nested_attribute_fields |= fields
+        @nested_attribute_fields.each do |field|
+          # Example method
+          # def inherited_compute_profile_id
+          #   read_attribute(:compute_profile_id) || nested_compute_profile_id
+          # end
+          define_method "inherited_#{field}" do
+            self[field] || nested(field)
+          end
+
+          # Example method - only override method generated by assocation if there is ancestry.
+          # if ancestry.present?
+          #   def compute_profile
+          #    ComputeProfile.find_by_id(inherited_compute_profile_id)
+          #  end
+          # end
+          next unless (md = field.to_s.match(/(\w+)_id$/))
+          define_method md[1] do
+            if hostgroup.ancestry.present?
+              klass = "ForemanPuppet::#{md[1].classify}"
+              klass = 'SmartProxy' if md[1] == 'puppet_proxy' || md[1] == 'puppet_ca_proxy'
+              klass = 'Subnet::Ipv4' if md[1] == 'subnet'
+              klass = 'Subnet::Ipv6' if md[1] == 'subnet6'
+              klass.constantize.find_by(id: send("inherited_#{field}"))
+            else
+              # () is required.
+              # Otherwise, get RuntimeError: implicit argument passing of super from method defined by define_method() is not supported.
+              #                              Specify all arguments explicitly.
+              super()
+            end
+          end
+        end
+      end
+    end
+
+    def nested(attr)
+      return nil if hostgroup.ancestry.blank?
+      Hostgroup.sort_by_ancestry(hostgroup.ancestors.joins(:puppet).where(HostgroupPuppetFacet.arel_table[attr.to_sym].not_eq(nil))).last&.puppet.try(attr)
+    end
+
+    # and helpers
+    def parent_facet_id
+      parent_facet&.id
+    end
+
+    def parent_facet
+      @parent_facet ||= hostgroup.parent_id && HostgroupPuppetFacet.find_by(hostgroup_id: hostgroup.parent_id)
+    end
+    # ------ END ANCESTRY -------
+
+    audited associated_with: :hostgroup
+    self.table_name = 'hostgroup_puppet_facets'
+
+    include ForemanPuppet::HostCommon
+    include Facets::HostgroupFacet
+
+    has_many :hostgroup_classes, dependent: :destroy
+    has_many :puppetclasses, through: :hostgroup_classes
+
+    before_save :remove_duplicated_nested_class
+
+    nested_attribute_for :environment_id
+
+    def all_config_groups
+      (config_groups + parent_config_groups).uniq
+    end
+
+    def parent_config_groups
+      return [] unless hostgroup.parent
+      groups = []
+      hostgroup.ancestors.each do |hostgroup|
+        groups += hostgroup.puppet&.config_groups || []
+      end
+      groups.uniq
+    end
+
+    # the environment used by #clases nees to be self.environment and not self.parent.environment
+    def parent_classes
+      return [] unless parent_facet
+      parent_facet.classes(environment)
+    end
+
+    def remove_duplicated_nested_class
+      ancestor_hgs = hostgroup.ancestors.preload(puppet: :puppetclasses)
+      self.puppetclasses -= ancestor_hgs.map { |ancestor| ancestor.puppet&.puppetclasses }.compact.flatten
+    end
+  end
+end