foreman_puppet 0.0.1

data/app/controllers/concerns/foreman_puppet/extensions/api_v2_hosts_controller.rb

@@ -0,0 +1,48 @@
+module ForemanPuppet
+  module Extensions
+    module ApiV2HostsController
+      extend ActiveSupport::Concern
+
+      included do
+        prepend PatchMethods
+
+        if ForemanPuppet.extracted_from_core?
+          method_desc = Apipie.get_method_description(self, :index)
+          method_desc.apis << Apipie::MethodDescription::Api.new(:GET, '/environments/:environment_id/hosts', N_('List hosts per environment'), {})
+
+          apipie_update_methods([:index]) do
+            param :environment_id, String, desc: N_('ID of puppet environment')
+          end
+
+          apipie_update_methods(%i[create update]) do
+            param :host, Hash do
+              param :environment_id, String, desc: N_('Deprecated in favor of host/puppet_attributes/environment_id')
+              param :puppetclass_ids, Array, desc: N_('Deprecated in favor of host/puppet_attributes/puppetclass_ids')
+              param :config_group_ids, Array, desc: N_('Deprecated in favor of host/puppet_attributes/config_group_ids')
+
+              param :puppet_attributes, Hash do
+                param :environment_id, String, desc: N_('ID of associated puppet Environment')
+                param :puppetclass_ids, Array, desc: N_('IDs of associated Puppetclasses')
+                param :config_group_ids, Array, desc: N_('IDs of associated ConfigGroups')
+              end
+            end
+          end
+        end
+      end
+
+      module PatchMethods
+        def resource_name(*attrs)
+          return 'foreman_puppet/environment' if attrs.first.is_a?(String) &&
+                                                 attrs.first.start_with?('environment')
+          super(*attrs)
+        end
+
+        def allowed_nested_id
+          ids = super
+          ids << 'environment_id' if ForemanPuppet.extracted_from_core?
+          ids.uniq
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_puppet/extensions/hostgroups_controller_extensions.rb

@@ -0,0 +1,58 @@
+module ForemanPuppet
+  module Extensions
+    module HostgroupsControllerExtensions
+      extend ActiveSupport::Concern
+
+      PUPPET_AJAX_REQUESTS = %w[environment_selected puppetclass_parameters].freeze
+
+      included do
+        alias_method :ajax_request_for_puppet_hostgroup_extensions, :ajax_request
+        alias_method :taxonomy_scope_for_puppet_hostgroup_extensions, :taxonomy_scope
+
+        before_action :ajax_request_for_puppet_hostgroup_extensions, only: PUPPET_AJAX_REQUESTS
+        before_action :taxonomy_scope_for_puppet_hostgroup_extensions, only: PUPPET_AJAX_REQUESTS
+
+        helper ForemanPuppet::HostsAndHostgroupsHelper
+        helper ForemanPuppet::PuppetclassesHelper
+        helper ForemanPuppet::PuppetclassLookupKeysHelper
+
+        # So we override the core actions, once Puppet is extracted, we can use module methods directly
+        prepend Actions
+      end
+
+      module Actions
+        def nest
+          super
+          @hostgroup.puppetclasses = @parent.puppetclasses
+        end
+
+        def environment_selected
+          env_id = params[:environment_id] || params[:hostgroup][:environment_id] || params.dig(:hostgroup, :puppet_attributes, :environment_id)
+          return not_found if env_id.to_i.positive? && !(@environment = ForemanPuppet::Environment.find(env_id))
+
+          refresh_hostgroup
+          puppet = @hostgroup.puppet || @hostgroup.build_puppet
+          puppet.environment = @environment if @environment
+
+          puppet.puppetclasses = ForemanPuppet::Puppetclass.where(id: params[:hostgroup][:puppetclass_ids])
+          puppet.config_groups = ForemanPuppet::ConfigGroup.where(id: params[:hostgroup][:config_group_ids])
+          render partial: 'hosts/form_puppet_enc_tab', locals: { host_or_hostgroup: @hostgroup, resource_type: :hostgroup }
+        end
+
+        def puppetclass_parameters
+          ::Taxonomy.as_taxonomy @organization, @location do
+            render partial: 'foreman_puppet/puppetclasses/classes_parameters',
+                   locals: { obj: refresh_hostgroup }
+          end
+        end
+
+        # params facets fix:
+        def hostgroup_params(top_level_hash = controller_name.singularize)
+          filter = self.class.hostgroup_params_filter
+          filter.permit(puppet_attributes: {})
+          filter.filter_params(params, parameter_filter_context, top_level_hash)
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_puppet/extensions/hosts_controller_extensions.rb

@@ -0,0 +1,228 @@
+module ForemanPuppet
+  module Extensions
+    module HostsControllerExtensions
+      extend ActiveSupport::Concern
+
+      PUPPETMASTER_ACTIONS = %i[externalNodes lookup].freeze
+      PUPPET_AJAX_REQUESTS = %w[hostgroup_or_environment_selected puppetclass_parameters].freeze
+
+      MULTIPLE_EDIT_ACTIONS = %w[select_multiple_environment update_multiple_environment
+                                 select_multiple_puppet_proxy update_multiple_puppet_proxy
+                                 select_multiple_puppet_ca_proxy update_multiple_puppet_ca_proxy].freeze
+
+      included do
+        add_smart_proxy_filters PUPPETMASTER_ACTIONS, features: ['Puppet']
+        alias_method :ajax_request_for_puppet_host_extensions, :ajax_request
+
+        before_action :ajax_request_for_puppet_host_extensions, only: PUPPET_AJAX_REQUESTS
+        before_action :taxonomy_scope_for_puppet_host_extensions, only: PUPPET_AJAX_REQUESTS
+        before_action :find_multiple_for_puppet_host_extensions, only: MULTIPLE_EDIT_ACTIONS
+        before_action :validate_multiple_puppet_proxy, only: :update_multiple_puppet_proxy
+        before_action :validate_multiple_puppet_ca_proxy, only: :update_multiple_puppet_ca_proxy
+
+        define_action_permission %w[externalNodes], :view
+        define_action_permission MULTIPLE_EDIT_ACTIONS, :edit
+
+        set_callback :set_class_variables, :after, :set_puppet_class_variables
+
+        helper ForemanPuppet::HostsHelper
+        helper ForemanPuppet::HostsAndHostgroupsHelper
+        helper ForemanPuppet::PuppetclassesHelper
+        helper ForemanPuppet::PuppetclassLookupKeysHelper
+      end
+
+      # TODO: unless ForemanPuppet.extracted_from_core?
+      def select_multiple_puppet_proxy_hosts_path(*args)
+        foreman_puppet.select_multiple_puppet_proxy_hosts_path(*args)
+      end
+
+      def hostgroup_or_environment_selected
+        refresh_host
+        set_class_variables(@host)
+        ::Taxonomy.as_taxonomy @organization, @location do
+          if @environment || @hostgroup
+            render partial: 'hosts/form_puppet_enc_tab', locals: { host_or_hostgroup: @host, resource_type: :host }
+          else
+            logger.info 'environment_id or hostgroup_id is required to render puppetclasses'
+          end
+        end
+      end
+
+      def puppetclass_parameters
+        ::Taxonomy.as_taxonomy @organization, @location do
+          render partial: 'foreman_puppet/puppetclasses/classes_parameters', locals: { obj: refresh_host }
+        end
+      end
+
+      def select_multiple_environment
+      end
+
+      def update_multiple_environment
+        # simple validations
+        if params[:environment].nil? || (id = params['environment']['id']).nil?
+          error _('No environment selected!')
+          redirect_to(foreman_puppet.select_multiple_environment_hosts_path)
+          return
+        end
+
+        ev = ForemanPuppet::Environment.find_by(id: id)
+
+        # update the hosts
+        @hosts.each do |host|
+          puppet = host.puppet || host.build_puppet
+          puppet.environment = id == 'inherit' && host.hostgroup.present? ? host.hostgroup.puppet&.environment : ev
+          host.save(validate: false)
+        end
+
+        success _('Updated hosts: changed environment')
+        redirect_back_or_to hosts_path
+      end
+
+      # returns a yaml file ready to use for puppet external nodes script
+      # expected a fqdn parameter to provide hostname to lookup
+      # see example script in extras directory
+      # will return HTML error codes upon failure
+      # rubocop:disable Naming/MethodName
+      def externalNodes
+        certname = params[:name].to_s
+        @host ||= resource_base.find_by certname: certname
+        @host ||= resource_base.friendly.find certname
+        unless @host
+          not_found
+          return
+        end
+
+        begin
+          respond_to do |format|
+            # don't break lines in yaml to support Ruby < 1.9.3
+            # Remove the HashesWithIndifferentAccess using 'deep_stringify_keys',
+            # then we turn it into YAML
+            host_info_yaml = @host.info.deep_stringify_keys.to_yaml(line_width: -1)
+            format.html { render html: ActionController::Base.helpers.tag.pre(ERB::Util.html_escape(host_info_yaml)) }
+            format.yml { render plain: host_info_yaml }
+          end
+        rescue StandardError => e
+          Foreman::Logging.exception("Failed to generate external nodes for #{@host}", e)
+          render plain: _('Unable to generate output, Check log files'),
+                 status: :precondition_failed
+        end
+      end
+      # rubocop:enable Naming/MethodName
+
+      # TODO: seems to be useless
+      def environment_from_param
+        # simple validations
+        if params[:environment].nil? || (id = params['environment']['id']).nil?
+          error _('No environment selected!')
+          redirect_to(foreman_puppet.select_multiple_environment_hosts_path)
+          return
+        end
+
+        id
+      end
+
+      def get_environment_id(env_params)
+        env_params['id'] if env_params
+      end
+
+      def get_environment_for(host, id)
+        if id == 'inherit' && host.hostgroup.present?
+          host.hostgroup.environment
+        else
+          ForemanPuppet::Environment.find_by(id: id)
+        end
+      end
+
+      def validate_multiple_puppet_proxy
+        validate_multiple_proxy(foreman_puppet.select_multiple_puppet_proxy_hosts_path)
+      end
+
+      def validate_multiple_puppet_ca_proxy
+        validate_multiple_proxy(select_multiple_puppet_ca_proxy_hosts_path)
+      end
+
+      def validate_multiple_proxy(redirect_path)
+        if params[:proxy].nil? || (proxy_id = params[:proxy][:proxy_id]).nil?
+          error _('No proxy selected!')
+          redirect_to(redirect_path)
+          return false
+        end
+
+        if proxy_id.present? && !::SmartProxy.find_by(id: proxy_id)
+          error _('Invalid proxy selected!')
+          redirect_to(redirect_path)
+          false
+        end
+      end
+
+      def update_multiple_proxy(proxy_type, host_update_method)
+        proxy_id = params[:proxy][:proxy_id]
+        proxy = (SmartProxy.find_by(id: proxy_id) if proxy_id)
+
+        failed_hosts = {}
+
+        @hosts.each do |host|
+          host.send(host_update_method, proxy)
+          host.save!
+        rescue StandardError => e
+          failed_hosts[host.name] = e
+          message = format(_('Failed to set %{proxy_type} proxy for %{host}.'), host: host, proxy_type: proxy_type)
+          Foreman::Logging.exception(message, e)
+        end
+
+        if failed_hosts.empty?
+          if proxy
+            success format(_('The %{proxy_type} proxy of the selected hosts was set to %{proxy_name}'), proxy_name: proxy.name, proxy_type: proxy_type)
+          else
+            success format(_('The %{proxy_type} proxy of the selected hosts was cleared.'), proxy_type: proxy_type)
+          end
+        else
+          error format(n_('The %{proxy_type} proxy could not be set for host: %{host_names}.',
+            'The %{proxy_type} puppet ca proxy could not be set for hosts: %{host_names}',
+            failed_hosts.count), proxy_type: proxy_type, host_names: failed_hosts.map { |h, err| "#{h} (#{err})" }.to_sentence)
+        end
+        redirect_back_or_to hosts_path
+      end
+
+      def handle_proxy_messages(errors, proxy, proxy_type)
+        if errors.empty?
+          if proxy
+            success format(_('The %{proxy_type} proxy of the selected hosts was set to %{proxy_name}.'), proxy_name: proxy.name, proxy_type: proxy_type)
+          else
+            success format(_('The %{proxy_type} proxy of the selected hosts was cleared.'), proxy_type: proxy_type)
+          end
+        else
+          error format(n_('The %{proxy_type} proxy could not be set for host: %{host_names}.',
+            'The %{proxy_type} puppet ca proxy could not be set for hosts: %{host_names}',
+            errors.count), proxy_type: proxy_type, host_names: errors.map { |h, err| "#{h} (#{err})" }.to_sentence)
+        end
+      end
+
+      def select_multiple_puppet_proxy
+      end
+
+      def update_multiple_puppet_proxy
+        update_multiple_proxy(_('Puppet'), :puppet_proxy=)
+      end
+
+      def select_multiple_puppet_ca_proxy
+      end
+
+      def update_multiple_puppet_ca_proxy
+        update_multiple_proxy(_('Puppet CA'), :puppet_ca_proxy=)
+      end
+
+      def set_puppet_class_variables
+        @environment = @host.puppet&.environment
+      end
+
+      def taxonomy_scope_for_puppet_host_extensions
+        taxonomy_scope
+      end
+
+      def find_multiple_for_puppet_host_extensions
+        find_multiple
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_puppet/extensions/operatingsystems_controller.rb

@@ -0,0 +1,11 @@
+module ForemanPuppet
+  module Extensions
+    module OperatingsystemsController
+      extend ActiveSupport::Concern
+
+      def clone
+        @operatingsystem = @operatingsystem.deep_clone include: %i[media ptables architectures puppetclasses os_parameters], except: [:title]
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_puppet/extensions/parameters_host.rb

@@ -0,0 +1,75 @@
+module ForemanPuppet
+  module Extensions
+    module ParametersHost
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          prepend PatchedClassMethods
+        end
+
+        prepend PatchedMethods
+      end
+
+      module PatchedClassMethods
+        def host_params_filter
+          super.tap do |filter|
+            filter.permit :environment_id, :environment_name, :environment,
+              config_groups: [], config_group_ids: [], config_group_names: [],
+              puppetclasses: [], puppetclass_ids: [], puppetclass_names: []
+
+            # TODO: bring to core - this is what facets should do, but does not
+            filter.permit(puppet_attributes: {})
+          end
+        end
+      end
+
+      module PatchedMethods
+        def host_params(*attrs)
+          params = super(*attrs)
+
+          process_deprecated_environment_params!(params)
+          process_deprecated_attributes!(params)
+          params
+        end
+
+        def process_deprecated_environment_params!(params)
+          env_id = env_name = env = nil
+          if ForemanPuppet.extracted_from_core?
+            env_id = params.delete(:environment_id)
+            env_name = params.delete(:environment_name)
+            env = params.delete(:environment)
+          else
+            env_id = params[:environment_id]
+            env_name = params[:environment_name]
+            env = params[:environment]
+          end
+
+          return unless env_id || env_name || env
+          ::Foreman::Deprecation.api_deprecation_warning('param host[environment_*] has been deprecated in favor of host[puppet_attributes][environment_*]')
+
+          params[:puppet_attributes] ||= {}
+          params[:puppet_attributes][:environment_id] ||= env_id if env_id
+          params[:puppet_attributes][:environment_name] ||= env_name if env_name
+          params[:puppet_attributes][:environment] ||= env if env
+        end
+
+        def process_deprecated_attributes!(params)
+          %w[puppetclass config_group].each do |relation|
+            ids = params.delete("#{relation}_ids".to_sym)
+            names = params.delete("#{relation}_names".to_sym)
+            plains = params.delete(relation.pluralize.to_sym)
+
+            next unless ids || names || plains
+            ::Foreman::Deprecation.api_deprecation_warning("param host[#{relation}_*] has been deprecated in favor of host[puppet_attributes][#{relation}_*]")
+
+            params[:puppet_attributes] ||= {}
+            params[:puppet_attributes]["#{relation}_ids".to_sym] ||= ids if ids
+            params[:puppet_attributes]["#{relation}_names".to_sym] ||= names if names
+            params[:puppet_attributes][relation.pluralize.to_sym] ||= plains if plains
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_puppet/extensions/parameters_hostgroup.rb

@@ -0,0 +1,70 @@
+module ForemanPuppet
+  module Extensions
+    module ParametersHostgroup
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          prepend PatchedClassMethods
+        end
+
+        prepend PatchedMethods
+      end
+
+      module PatchedClassMethods
+        def hostgroup_params_filter
+          super.tap do |filter|
+            filter.permit :environment_id, :environment_name,
+              config_group_ids: [], config_group_names: [],
+              puppetclass_ids: [], puppetclass_names: []
+
+            # TODO: bring to core - this is what facets should do, but does not
+            filter.permit(puppet_attributes: {})
+          end
+        end
+      end
+
+      module PatchedMethods
+        def hostgroup_params(*attrs)
+          params = super(*attrs)
+
+          process_deprecated_hostgroup_environment_params!(params)
+          process_deprecated_hostgroup_attributes!(params)
+          params
+        end
+
+        def process_deprecated_hostgroup_environment_params!(params)
+          env_id = env_name = nil
+          if ForemanPuppet.extracted_from_core?
+            env_id = params.delete(:environment_id)
+            env_name = params.delete(:environment_name)
+          else
+            env_id = params[:environment_id]
+            env_name = params[:environment_name]
+          end
+
+          return unless env_id || env_name
+          ::Foreman::Deprecation.api_deprecation_warning('param hostgroup[environment_*] has been deprecated in favor of hostgroup[puppet_attributes][environment_*]')
+
+          params[:puppet_attributes] ||= {}
+          params[:puppet_attributes][:environment_id] ||= env_id if env_id
+          params[:puppet_attributes][:environment_name] ||= env_name if env_name
+        end
+
+        def process_deprecated_hostgroup_attributes!(params)
+          %w[puppetclass config_group].each do |relation|
+            ids = params.delete("#{relation}_ids")
+            names = params.delete("#{relation}_names")
+
+            next unless ids || names
+            ::Foreman::Deprecation.api_deprecation_warning("param hostgroup[#{relation}_*] has been deprecated in favor of hostgroup[puppet_attributes][#{relation}_*]")
+
+            params[:puppet_attributes] ||= {}
+            params[:puppet_attributes]["#{relation}_ids".to_sym] ||= ids if ids
+            params[:puppet_attributes]["#{relation}_names".to_sym] ||= names if names
+          end
+        end
+      end
+    end
+  end
+end