foreman_puppet 0.0.1

data/app/models/foreman_puppet/puppetclass.rb

@@ -0,0 +1,132 @@
+module ForemanPuppet
+  class Puppetclass < ApplicationRecord
+    self.table_name = 'puppetclasses'
+
+    audited
+    include Authorizable
+    include ScopedSearchExtensions
+    extend FriendlyId
+    friendly_id :name
+    include Parameterizable::ByIdName
+
+    validates_lengths_from_database
+    before_destroy EnsureNotUsedBy.new(:hosts, :hostgroups)
+    has_many :environment_classes, dependent: :destroy, inverse_of: :puppetclass
+    has_many :environments, -> { distinct }, through: :environment_classes
+    has_many :organizations, -> { distinct.reorder(nil) }, through: :environments
+    has_many :locations, -> { distinct.reorder(nil) }, through: :environments
+
+    # rubocop:disable Rails/HasAndBelongsToMany
+    has_and_belongs_to_many :operatingsystems
+    # rubocop:enable Rails/HasAndBelongsToMany
+    has_many :hostgroup_classes, dependent: :destroy
+    has_many :hostgroup_puppet_facets, through: :hostgroup_classes
+    has_many :hostgroups, through: :hostgroup_puppet_facets
+    has_many :host_classes, dependent: :destroy
+    has_many :host_puppet_facets, through: :host_classes
+    has_many_hosts through: :host_puppet_facets
+    has_many :config_group_classes, dependent: :destroy
+    has_many :config_groups, through: :config_group_classes
+
+    has_many :class_params, -> { distinct }, through: :environment_classes, source: :puppetclass_lookup_key
+    accepts_nested_attributes_for :class_params, reject_if: ->(a) { a[:key].blank? }, allow_destroy: true
+
+    validates :name, uniqueness: true, presence: true, no_whitespace: true
+
+    alias_attribute :smart_class_parameters, :class_params
+    alias_attribute :smart_class_parameter_ids, :class_param_ids
+
+    default_scope -> { order(:name) }
+
+    scoped_search on: :name, complete_value: true
+    scoped_search relation: :environments, on: :name, complete_value: true, rename: 'environment'
+    scoped_search relation: :organizations, on: :name, complete_value: true, rename: 'organization', only_explicit: true
+    scoped_search relation: :locations, on: :name, complete_value: true, rename: 'location', only_explicit: true
+    scoped_search relation: :hostgroups, on: :name, complete_value: true, rename: 'hostgroup', only_explicit: true
+    scoped_search relation: :config_groups, on: :name, complete_value: true, rename: 'config_group', only_explicit: true
+    scoped_search relation: :hosts, on: :name, complete_value: true, rename: 'host', ext_method: :search_by_host, only_explicit: true
+    scoped_search relation: :class_params, on: :key, complete_value: true, only_explicit: true
+
+    scope :not_in_any_environment, -> { left_outer_joins(:environment_classes).where(environment_classes: { environment_id: nil }) }
+
+    # returns a hash containing modules and associated classes
+    def self.classes2hash(classes)
+      hash = {}
+      classes.each do |klass|
+        next unless (mod = klass.module_name)
+        hash[mod] ||= []
+        hash[mod] << klass
+      end
+      hash
+    end
+
+    # For API v2 - eliminate node :puppetclass for each object. returns a hash containing modules and associated classes
+    def self.classes2hash_v2(classes)
+      hash = {}
+      classes.each do |klass|
+        if (mod = klass.module_name)
+          hash[mod] ||= []
+          hash[mod] << { id: klass.id, name: klass.name, created_at: klass.created_at, updated_at: klass.updated_at }
+        end
+      end
+      hash
+    end
+
+    # returns module name (excluding of the class name)
+    # if class separator does not exists (the "::" chars), then returns the whole class name
+    def module_name
+      (i = name.index('::')) ? name[0..i - 1] : name
+    end
+
+    # returns class name (excluding of the module name)
+    def klass
+      name.gsub("#{module_name}::", '')
+    end
+
+    def all_hostgroups(with_descendants: true, unsorted: false)
+      hgs = Hostgroup.authorized
+                     .left_outer_joins(puppet: [:hostgroup_classes, { config_groups: [:config_group_classes] }])
+                     .where("#{id} IN (hostgroup_classes.puppetclass_id, config_group_classes.puppetclass_id)")
+                     .distinct
+      hgs = hgs.reorder('') if unsorted
+      hgs = hgs.flat_map(&:subtree).uniq if with_descendants
+      hgs
+    end
+
+    def hosts_count
+      hostgroup_ids = all_hostgroups(unsorted: true).map(&:id)
+      Host::Managed.authorized
+                   .reorder(nil)
+                   .left_outer_joins(puppet: [:host_classes, { config_groups: [:config_group_classes] }])
+                   .where('(? IN (host_classes.puppetclass_id, config_group_classes.puppetclass_id)) OR (hosts.hostgroup_id IN (?))', id, hostgroup_ids)
+                   .distinct
+                   .count
+    end
+
+    # We are going through two associations, so we are on our own to define modifiers
+    def hostgroup_ids=(hg_ids)
+      hg_ids = Array(hg_ids).reject(&:blank?)
+      hg_to_facets_ids = Hash[HostgroupPuppetFacet.where(hostgroup_id: hg_ids).pluck(:hostgroup_id, :id)]
+      missing_facet_ids = hg_ids.map(&:to_i) - hg_to_facets_ids.keys
+      new_facet_ids = missing_facet_ids.map { |hg_id| HostgroupPuppetFacet.create(hostgroup_id: hg_id).id }
+      self.hostgroup_puppet_facet_ids = hg_to_facets_ids.values + new_facet_ids
+    end
+
+    def self.search_by_host(_key, operator, value)
+      conditions = sanitize_sql_for_conditions(["hosts.name #{operator} ?", value_to_sql(operator, value)])
+      direct     = Puppetclass.joins(host_puppet_facets: :host).where(conditions).pluck(:id).uniq
+      hostgroup  = Hostgroup.joins(:hosts).find_by(conditions)
+      indirect   = if hostgroup.blank?
+                     []
+                   else
+                     HostgroupClass.joins(hostgroup_puppet_facet: :hostgroup)
+                                   .where(Hostgroup.arel_table[:id].in(hostgroup.path_ids))
+                                   .pluck(:puppetclass_id).uniq
+                   end
+      return { conditions: '1=0' } if direct.blank? && indirect.blank?
+
+      puppet_classes = (direct + indirect).uniq
+      { conditions: "puppetclasses.id IN(#{puppet_classes.join(',')})" }
+    end
+  end
+end

data/app/models/foreman_puppet/puppetclass_lookup_key.rb

@@ -0,0 +1,58 @@
+module ForemanPuppet
+  class PuppetclassLookupKey < LookupKey
+    has_many :environment_classes, dependent: :destroy, inverse_of: :puppetclass_lookup_key
+    has_many :environments, -> { distinct }, through: :environment_classes
+    has_many :param_classes, through: :environment_classes, source: :puppetclass
+
+    before_validation :check_override_selected, if: -> { persisted? && @validation_context != :importer }
+
+    scoped_search relation: :param_classes, on: :name, rename: :puppetclass, aliases: [:puppetclass_name], complete_value: true
+    scoped_search relation: :environments, on: :name, rename: :environment, complete_value: true, only_explicit: true
+
+    scope :smart_class_parameters_for_class, lambda { |puppetclass_ids, environment_id|
+                                               joins(:environment_classes).where(environment_classes: { puppetclass_id: puppetclass_ids, environment_id: environment_id })
+                                             }
+
+    scope :parameters_for_class, lambda { |puppetclass_ids, environment_id|
+                                   override.smart_class_parameters_for_class(puppetclass_ids, environment_id)
+                                 }
+
+    scope :smart_class_parameters, -> { joins(:environment_classes).readonly(false) }
+
+    def editable_by_user?
+      PuppetclassLookupKey.authorized(:edit_external_parameters).exists?(id: id)
+    end
+
+    def param_class
+      param_classes.first
+    end
+
+    def audit_class
+      param_class
+    end
+
+    def cast_default_value
+      super unless omit
+      true
+    end
+
+    def validate_default_value
+      super unless omit
+      true
+    end
+
+    def puppet?
+      true
+    end
+
+    def check_override_selected
+      return if (changed - %w[description override]).empty?
+      return if override?
+      errors.add(:override, _('must be true to edit the parameter'))
+    end
+
+    def self.humanize_class_name
+      'Smart class parameter'
+    end
+  end
+end

data/app/services/foreman_puppet/host_info_providers/config_groups_info.rb

@@ -0,0 +1,10 @@
+module ForemanPuppet
+  module HostInfoProviders
+    class ConfigGroupsInfo < HostInfo::Provider
+      def host_info
+        config_groups = (host.puppet.config_groups + host.puppet.parent_config_groups).uniq.map(&:name)
+        { 'parameters' => { 'foreman_config_groups' => config_groups } }
+      end
+    end
+  end
+end

data/app/services/foreman_puppet/host_info_providers/puppet_info.rb

@@ -0,0 +1,92 @@
+module ForemanPuppet
+  module HostInfoProviders
+    class PuppetInfo < HostInfo::Provider
+      def host_info
+        # Static parameters
+        param = puppet_static_info
+        info_hash = {}
+        info_hash['classes'] = classes_info_hash
+        info_hash['parameters'] = param
+        info_hash['environment'] = param['foreman_env'] if Setting['enc_environment'] && param['foreman_env'].present?
+
+        info_hash
+      end
+
+      def puppetclass_parameters
+        keys = ForemanPuppet::PuppetclassLookupKey.includes(:environment_classes).parameters_for_class(host.puppet&.puppetclass_ids, host.puppet&.environment_id)
+        key_hash = hashed_class_keys(keys)
+        values = keys.values_hash(host)
+
+        klasses = {}
+        host.puppet.classes.each do |klass|
+          klasses[klass.name] = smart_class_params_for(klass, key_hash, values)
+        end
+        klasses
+      end
+
+      def inherited_puppetclass_parameters
+        keys = ForemanPuppet::PuppetclassLookupKey.includes(:environment_classes).parameters_for_class(host.puppet&.puppetclass_ids, host.puppet&.environment_id)
+
+        keys.inherited_values(host).raw
+      end
+
+      private
+
+      def puppet_static_info
+        params = {}
+        # maybe these should be moved to the common parameters, leaving them in for now
+        params['puppetmaster'] = host.puppetmaster
+        params['puppet_ca']    = host.puppet_ca_server if ca_defined?
+        params['foreman_env']  = host.puppet&.environment.to_s if has_environment?
+
+        params.merge! networking_params if Setting[:ignore_puppet_facts_for_provisioning]
+
+        params
+      end
+
+      def ca_defined?
+        SETTINGS[:unattended] && host.puppetca_exists?
+      end
+
+      def has_environment?
+        host.puppet&.environment&.name
+      end
+
+      def networking_params
+        {
+          'ip' => host.ip,
+          'ip6' => host.ip6,
+          'mac' => host.mac,
+        }
+      end
+
+      def classes_info_hash
+        return [] unless has_environment?
+        puppetclass_parameters
+      end
+
+      def smart_class_params_for(klass, key_hash, values)
+        return nil unless key_hash[klass.id]
+
+        class_values = {}
+        key_hash[klass.id].each do |key|
+          key_value = values[key]
+          class_values[key.to_s] = key_value unless key_value.nil?
+        end
+
+        return nil if class_values == {}
+        class_values
+      end
+
+      def hashed_class_keys(keys)
+        h = {}
+        keys.each do |key|
+          klass_id = key.environment_classes.first.puppetclass_id
+          h[klass_id] ||= []
+          h[klass_id] << key
+        end
+        h
+      end
+    end
+  end
+end

data/app/services/foreman_puppet/input_type/puppet_parameter_input.rb

@@ -0,0 +1,35 @@
+module ForemanPuppet
+  module InputType
+    class PuppetParameterInput < ::InputType::Base
+      class Resolver < ::InputType::Base::Resolver
+        def ready?
+          @scope.host &&
+            enc_parameters.key?(@input.puppet_class_name) &&
+            enc_parameters[@input.puppet_class_name].is_a?(Hash) &&
+            enc_parameters[@input.puppet_class_name].key?(@input.puppet_parameter_name)
+        end
+
+        def resolved_value
+          enc_parameters[@input.puppet_class_name][@input.puppet_parameter_name]
+        end
+
+        private
+
+        def enc_parameters
+          @enc_parameters ||= ForemanPuppet::HostInfoProviders::PuppetInfo.new(@scope.host).puppetclass_parameters
+        end
+      end
+
+      def self.humanized_name
+        _('Puppet parameter')
+      end
+
+      attributes :puppet_class_name, :puppet_parameter_name
+
+      def validate(input)
+        input.errors.add(:puppet_class_name, :blank) if input.puppet_class_name.blank?
+        input.errors.add(:puppet_parameter_name, :blank) if input.puppet_parameter_name.blank?
+      end
+    end
+  end
+end

data/app/services/foreman_puppet/proxy_status/puppet.rb

@@ -0,0 +1,17 @@
+module ForemanPuppet
+  module ProxyStatus
+    class Puppet < ::ProxyStatus::Base
+      def environment_stats
+        fetch_proxy_data do
+          env_counts = {}
+          api.environments.each { |env| env_counts[env] = api.class_count(env) }
+          env_counts
+        end
+      end
+
+      def self.humanized_name
+        'Puppet'
+      end
+    end
+  end
+end

data/app/services/foreman_puppet/puppet_class_importer.rb

@@ -0,0 +1,355 @@
+module ForemanPuppet
+  class PuppetClassImporter
+    CHANGE_KINDS = %w[new obsolete updated ignored].freeze
+
+    def initialize(args = {})
+      @foreman_classes = {}
+      @proxy_classes   = {}
+      @environment = args[:env]
+
+      if args[:proxy]
+        @proxy = args[:proxy]
+      elsif args[:url]
+        @proxy = ProxyAPI::Puppet.new(url: args[:url])
+      else
+        url = SmartProxy.with_features('Puppet').first.try(:url)
+        raise ::Foreman::Exception, N_("Can't find a valid Proxy with a Puppet feature") if url.blank?
+        @proxy = ProxyAPI::Puppet.new(url: url)
+      end
+    end
+
+    # return changes hash, currently exists to keep compatibility with importer html
+    def changes
+      changes = CHANGE_KINDS.index_with { |_kind| {} }
+
+      if @environment.nil?
+        actual_environments.each do |env|
+          changes_for_environment(env, changes)
+        end
+
+        old_environments.each do |env|
+          changes['obsolete'][env] ||= []
+          changes['obsolete'][env] << '_destroy_' unless actual_environments.include?(env)
+        end
+
+        ignored_environments.each do |env|
+          changes['ignored'][env] ||= []
+          changes['ignored'][env] << '_ignored_'
+        end
+      else
+        changes_for_environment(@environment, changes)
+      end
+
+      changes
+    end
+
+    # Adds class changes of an environment to a changes hash in new, obsolete and updated
+    #
+    # Params:
+    #  * +environment+: {String} of environments name
+    #  * +changes+: {Hash} to add changes to
+    #
+    def changes_for_environment(environment, changes)
+      new_classes     = new_classes_for(environment)
+      old_classes     = removed_classes_for(environment)
+      updated_classes = updated_classes_for(environment)
+      ignored_classes = ignored_classes_for(environment)
+      changes['new'][environment] = new_classes if new_classes.any?
+      changes['obsolete'][environment] = old_classes if old_classes.any?
+      changes['updated'][environment] = updated_classes if updated_classes.any?
+      changes['ignored'][environment] = ignored_classes if ignored_classes.any?
+    end
+
+    # Update the environments and puppetclasses based upon the user's selection
+    # It does a best attempt and can fail to perform all operations due to the
+    # user requesting impossible selections. Repeat the operation if errors are
+    # shown, after fixing the request.
+    # +changed+ : Hash with two keys: :new and :obsolete.
+    #               changed[:/new|obsolete/] is and Array of Strings
+    # Returns   : Array of Strings containing all record errors
+    def obsolete_and_new(changes = {})
+      return if changes.empty?
+      changes.values.map(&:keys).flatten.uniq.each do |env_name|
+        add_classes_to_foreman(env_name, JSON.parse(changes['new'][env_name])) if changes['new'] && changes['new'][env_name].try(:>, '') # we got new classes
+        remove_classes_from_foreman(env_name, JSON.parse(changes['obsolete'][env_name])) if changes['obsolete'] && changes['obsolete'][env_name].try(:>, '') # we need to remove classes
+        update_classes_in_foreman(env_name, JSON.parse(changes['updated'][env_name])) if changes['updated'] && changes['updated'][env_name].try(:>, '') # we need to update classes
+      end
+      []
+    rescue StandardError => e
+      Foreman::Logging.exception('Failed to calculate obsolete and new', e)
+      [e.to_s]
+    end
+
+    # Returns all classes for a given environment
+    #
+    # Params:
+    #  * +environment+: {String} containing the name of the environment
+    #
+    def proxy_classes_for(environment)
+      @proxy_classes[environment] ||= proxy.classes(environment)
+    end
+
+    def new_classes_for(environment)
+      old_classes = db_classes_name(environment)
+      HashWithIndifferentAccess[
+        actual_classes(environment).values.map do |actual_class|
+          [actual_class.to_s, { 'new' => actual_class.parameters }] unless old_classes.include?(actual_class.to_s)
+        end.compact
+      ]
+    end
+
+    def removed_classes_for(environment)
+      db_classes_name(environment) - actual_classes_name(environment)
+    end
+
+    def updated_classes_for(environment)
+      return [] unless db_environments.include?(environment) && actual_environments.include?(environment)
+      HashWithIndifferentAccess[
+        db_classes(environment).map do |db_class|
+          params = EnvironmentClass.all_parameters_for_class(db_class.id, find_or_create_env(environment).id).map(&:puppetclass_lookup_key)
+          compare_classes(environment, db_class.name, params)
+        end.compact
+      ]
+    end
+
+    # Gives back the classes ignored for a given environment
+    #
+    # Params:
+    #  * +environment+: {String} name of the environment
+    #
+    def ignored_classes_for(environment)
+      proxy_classes_for(environment).keys.select do |class_name|
+        ignored_class?(class_name)
+      end
+    end
+
+    # Returns true when the class name matches any pattern in ignored_classes
+    #
+    # Params:
+    #  * +class_name+: {String} containing the class to be checked
+    #
+    def ignored_class?(class_name)
+      ignored_classes.any? do |filter|
+        filter.is_a?(Regexp) && filter =~ class_name
+      end
+    end
+
+    # This method check if the puppet class exists in this environment, and compare the class params.
+    # Changes in the params are categorized to new parameters, removed parameters and parameters with a new
+    # default value.
+    def compare_classes(environment, klass, db_params)
+      return nil unless (actual_class = actual_classes(environment)[klass])
+      actual_params = actual_class.parameters
+      db_param_names = db_params.map(&:to_s)
+
+      param_changes = {}
+      old           = db_param_names - actual_params.keys
+      param_changes['obsolete'] = old if old.any?
+      new = actual_params.reject { |key, _value| db_param_names.include?(key) }
+      param_changes['new'] = new if new.any?
+      updated = updated_classes(actual_params, db_params)
+      param_changes['updated'] = updated if updated.any?
+      [klass, param_changes] if param_changes.keys.any?
+    end
+
+    def updated_classes(actual_params, db_params)
+      updated = {}
+      db_params.map do |p|
+        param_name = p.to_s
+        updated[param_name] = actual_params[param_name] if !p.override && actual_params.key?(param_name) && actual_params[param_name] != p.default_value
+      end
+      updated
+    end
+
+    def db_environments
+      @db_environments ||= (Environment.pluck('environments.name') - ignored_environments)
+    end
+
+    def actual_environments
+      (proxy_environments & (User.current.visible_environments + to_be_created_environments)) - ignored_environments
+    end
+
+    def proxy_environments
+      proxy.environments.map(&:to_s)
+    end
+
+    def to_be_created_environments
+      proxy_environments - Environment.unscoped.where(name: proxy_environments).pluck(:name)
+    end
+
+    def new_environments
+      actual_environments - db_environments
+    end
+
+    def old_environments
+      db_environments - actual_environments
+    end
+
+    def db_classes(environment)
+      return @foreman_classes[environment] if @foreman_classes[environment]
+      return [] unless (env = Environment.find_by(name: environment))
+      @foreman_classes[environment] = env.puppetclasses.includes(:class_params)
+    end
+
+    def db_classes_name(environment)
+      db_classes(environment).map(&:name)
+    end
+
+    # Returns an {Hash} of puppet class names without ignored classes
+    #
+    # Params:
+    #  * +environment+: {String} containing the environment name
+    #
+    def actual_classes(environment)
+      proxy_classes_for(environment).reject { |key, _| ignored_class? key }
+    end
+
+    def actual_classes_name(environment)
+      actual_classes(environment).keys
+    end
+
+    def ignored_boolean_environment_names?
+      ignored_environments.any? { |item| item.is_a?(TrueClass) || item.is_a?(FalseClass) }
+    end
+
+    private
+
+    attr_reader :proxy
+
+    def ignored_environments
+      ignored_file[:ignored] || []
+    end
+
+    def ignored_classes
+      ignored_file[:filters] || []
+    end
+
+    def ignored_file_path
+      Rails.root.join('config/ignored_environments.yml')
+    end
+
+    def load_ignored_file
+      File.exist?(ignored_file_path) ? YAML.load_file(ignored_file_path) : {}
+    end
+
+    def ignored_file
+      @ignored_file ||= load_ignored_file
+    rescue StandardError => e
+      Foreman::Logging.exception('Failed to parse environment ignore file', e)
+      @ignored_file = {}
+    end
+
+    def logger
+      @logger ||= Rails.logger
+    end
+
+    def load_classes_from_json(blob)
+      ActiveSupport::JSON.decode blob
+    end
+
+    def add_classes_to_foreman(env_name, klasses)
+      env         = find_or_create_env env_name
+      # look for Puppet class in all scopes to make sure we do not try to create a new record
+      # with a name that already exists and hit the uniqueness constraint on name
+      new_classes = klasses.map { |k| find_or_create_puppetclass(name: k[0]) }
+
+      new_classes.each do |new_class|
+        EnvironmentClass.find_or_create_by! puppetclass_id: new_class.id, environment_id: env.id
+        class_params = klasses[new_class.to_s]
+        add_new_parameter(env, new_class, class_params) if class_params.any?
+      end
+    end
+
+    def update_classes_in_foreman(environment, klasses)
+      env        = find_or_create_env(environment)
+      db_classes = env.puppetclasses.where(name: klasses.keys)
+      db_classes.each do |db_class|
+        changed_params = klasses[db_class.to_s]
+        # Add new parameters
+        add_new_parameter(env, db_class, changed_params) if changed_params['new']
+        # Unbind old parameters
+        remove_parameter(env, db_class, changed_params) if changed_params['obsolete']
+        # Update parameters (affects solely the default value)
+        update_parameter(db_class, changed_params) if changed_params['updated']
+      end
+    end
+
+    def update_parameter(db_class, changed_params)
+      changed_params['updated'].each do |param_name, value|
+        key = db_class.class_params.find_by key: param_name
+        next unless key.override == false
+        key.default_value = value
+        key.key_type = nil
+        key.validator_type = nil
+        key.save!(context: :importer)
+      end
+    end
+
+    def remove_parameter(env, db_class, changed_params)
+      changed_params['obsolete'].each do |param_name, _value|
+        key        = db_class.class_params.find_by key: param_name
+        key_in_env = EnvironmentClass.key_in_environment(env, db_class, key)
+
+        next unless key && key_in_env
+        # detach
+        key_in_env.destroy
+        # destroy if the key is not in any environment.
+        key.destroy unless EnvironmentClass.is_in_any_environment(db_class, key)
+      end
+    end
+
+    def add_new_parameter(env, klass, changed_params)
+      changed_params['new'].map do |param_name, value|
+        param = find_or_create_puppet_class_param klass, param_name, value
+        EnvironmentClass.find_or_create_by! puppetclass_id: klass.id, environment_id: env.id,
+                                            puppetclass_lookup_key_id: param.id
+      end
+    end
+
+    def remove_classes_from_foreman(env_name, klasses)
+      env     = find_or_create_env(env_name)
+      classes = find_existing_foreman_classes(klasses)
+      env.puppetclasses.destroy classes
+      # remove all old classes from hosts
+      HostClass.joins(host: :puppet).where(HostPuppetFacet.arel_table[:environment_id].eq(env.id)).where(puppetclass_id: classes).destroy_all
+      unless ForemanPuppet.extracted_from_core?
+        # rubocop:disable Rails/SkipsModelValidations
+        Host.where(environment_id: env).update_all(environment_id: nil)
+        Hostgroup.where(environment_id: env).update_all(environment_id: nil)
+        # rubocop:enable Rails/SkipsModelValidations
+
+        # we can't guaranty that the env would be removed as it might have hosts attached to it.
+        env.destroy if klasses.include? '_destroy_'
+      end
+      # remove all klasses that have no environment now
+      classes.not_in_any_environment.destroy_all
+    end
+
+    def find_existing_foreman_classes(klasses = [])
+      Puppetclass.where(name: klasses)
+    end
+
+    def find_or_create_env(env)
+      user_visible_environment(env) || Environment.create!(name: env,
+                                                           organizations: User.current.my_organizations,
+                                                           locations: User.current.my_locations)
+    end
+
+    def user_visible_environment(env)
+      return unless User.current.visible_environments.include? env
+      Environment.unscoped.find_by name: env
+    end
+
+    def find_or_create_puppet_class_param(klass, param_name, value)
+      klass.class_params.where(key: param_name).first ||
+        PuppetclassLookupKey.create!(key: param_name, default_value: value,
+                                     key_type: Foreman::ImporterPuppetclass.suggest_key_type(value))
+    end
+
+    def find_or_create_puppetclass(name:)
+      puppetclass = Puppetclass.unscoped.find_or_create_by!(name: name)
+      raise Foreman::Exception.new('Failed to create Puppetclass: %s', puppetclass.errors.full_messages.to_sentence) unless puppetclass.errors.empty?
+      puppetclass
+    end
+  end
+end