foreman_puppet 0.0.1

data/app/controllers/foreman_puppet/puppetclasses_controller.rb

@@ -0,0 +1,113 @@
+module ForemanPuppet
+  class PuppetclassesController < ApplicationController
+    include Foreman::Controller::AutoCompleteSearch
+    include Foreman::Controller::Parameters::Host
+    include Foreman::Controller::Parameters::Hostgroup
+    include ForemanPuppet::Parameters::Environment
+    include ForemanPuppet::Parameters::Puppetclass
+
+    before_action :find_resource, only: %i[edit update destroy override]
+    before_action :setup_search_options, only: :index
+
+    helper ForemanPuppet::PuppetclassLookupKeysHelper
+
+    # TODO: extracted_from_core?
+    def host_params(top_level_hash = controller_name.singularize)
+      filter = self.class.host_params_filter
+      filter.permit(puppet_attributes: {})
+      filter.filter_params(params, parameter_filter_context, top_level_hash).tap do |normalized|
+        if parameter_filter_context.ui? && normalized['compute_attributes'] && normalized['compute_attributes']['scsi_controllers']
+          normalize_scsi_attributes(normalized['compute_attributes'])
+        end
+      end
+    end
+
+    def index
+      @puppetclasses = resource_base_search_and_page
+      allowed_hostgroup_ids = HostgroupPuppetFacet.joins(:hostgroup_classes)
+                                                  .where(HostgroupClass.arel_table[:puppetclass_id].in(@puppetclasses.map(&:id)))
+                                                  .pluck(:hostgroup_id).uniq
+      @hostgroups_authorizer = Authorizer.new(User.current, collection: allowed_hostgroup_ids)
+    end
+
+    def edit
+    end
+
+    def update
+      if @puppetclass.update(puppetclass_params)
+        process_success
+      else
+        process_error
+      end
+    end
+
+    def destroy
+      if @puppetclass.destroy
+        process_success
+      else
+        process_error
+      end
+    end
+
+    def override
+      if @puppetclass.class_params.present?
+        @puppetclass.class_params.each do |class_param|
+          class_param.update(override: params[:enable])
+        end
+        if [true, 'true'].include?(params[:enable])
+          success _('Successfully overridden all parameters of Puppet class %s') % @puppetclass.name
+        else
+          success _('Successfully reset all parameters of Puppet class %s to their default values') % @puppetclass.name
+        end
+      else
+        error _('No parameters to override for Puppet class %s') % @puppetclass.name
+      end
+      redirect_to puppetclasses_path
+    end
+
+    # form AJAX methods
+    def parameters
+      puppetclass = Puppetclass.find(params[:id])
+      render partial: 'foreman_puppet/puppetclasses/class_parameters',
+             locals: { puppetclass: puppetclass,
+                       obj: find_host_or_hostgroup }
+    end
+
+    def resource_class
+      model_of_controller
+    end
+
+    private
+
+    def find_host_or_hostgroup
+      # params['host_id'] = 'undefined' if NEW since hosts/form and hostgroups/form has no data-id
+      host_id = params.delete(:host_id)
+      if host_id == 'undefined'
+        @obj = Host::Managed.new(host_params('host')) if params['host']
+        @obj ||= Hostgroup.new(hostgroup_params('hostgroup')) if params['hostgroup']
+      elsif params['host']
+        @obj = Host::Base.find(host_id)
+        unless @obj.is_a?(Host::Managed)
+          @obj      = @obj.becomes(Host::Managed)
+          @obj.type = 'Host::Managed'
+        end
+        # puppetclass_ids and config_group_ids need to be removed so they don't cause automatic insertsgroup
+        @obj.attributes = host_params('host')
+      elsif params['hostgroup']
+        # hostgroup.id is assigned to params['host_id'] by host_edit.js#load_puppet_class_parameters
+        @obj = Hostgroup.find(host_id)
+        @obj.attributes = hostgroup_params('hostgroup')
+      end
+      @obj
+    end
+
+    def action_permission
+      case params[:action]
+      when 'override'
+        :edit
+      else
+        super
+      end
+    end
+  end
+end

data/app/controllers/foreman_puppet/react_controller.rb

@@ -0,0 +1,19 @@
+module ForemanPuppet
+  class ReactController < ::ApplicationController
+    layout 'foreman_puppet/layouts/application_react'
+
+    def index
+      render html: nil, layout: true
+    end
+
+    private
+
+    def controller_permission
+      :foreman_puppet
+    end
+
+    def action_permission
+      :view
+    end
+  end
+end

data/app/helpers/concerns/foreman_puppet/template_renderer_scope.rb

@@ -0,0 +1,14 @@
+module ForemanPuppet
+  module TemplateRendererScope
+    extend ActiveSupport::Concern
+    extend ApipieDSL::Module
+
+    apipie :method, 'Returns puppet classes assigned to the host' do
+      returns Array, desc: 'Puppet classes assigned to the host'
+    end
+    def host_puppet_classes
+      check_host
+      host.puppet&.puppetclasses || []
+    end
+  end
+end

data/app/helpers/foreman_puppet/environments_helper.rb

@@ -0,0 +1,17 @@
+module ForemanPuppet
+  module EnvironmentsHelper
+    include PuppetclassesAndEnvironmentsHelper
+
+    def url_for(*args)
+      super
+    rescue ActionController::UrlGenerationError => _e
+      foreman_puppet.url_for(*args)
+    end
+
+    def environments_title_actions
+      title_actions import_proxy_select(hash_for_import_environments_environments_path),
+        button_group(new_link(_('Create Puppet Environment'), engine: foreman_puppet)),
+        button_group(help_button)
+    end
+  end
+end

data/app/helpers/foreman_puppet/hosts_and_hostgroups_helper.rb

@@ -0,0 +1,96 @@
+module ForemanPuppet
+  module HostsAndHostgroupsHelper
+    # TODO: remove me - prevents the puppetclass tab duplication
+    # unless ForemanPuppet.extracted_from_core?
+    def puppetclasses_tab(puppetclasses_receiver)
+    end
+
+    def environment_inherited_by_default?(host)
+      return false unless host.hostgroup && host.hostgroup_id_was.nil?
+      return false if params[:action] == 'clone'
+      return true unless params[:host]
+      !params[:host].dig(:puppet_attributes, :environment_id)
+    end
+
+    # rubocop:disable Rails/HelperInstanceVariable
+    def user_set_environment?
+      # if the host has no hostgroup
+      return true unless @host&.hostgroup
+      # when editing a host, the values are specified explicitly
+      return true if params[:action] == 'edit'
+      return true if params[:action] == 'clone'
+      # check if the user set the field explicitly despite setting a hostgroup.
+      params[:host] && params[:host][:hostgroup_id] && params[:host].dig(:puppet_attributes, :environment_id)
+    end
+    # rubocop:enable Rails/HelperInstanceVariable
+
+    def host_puppet_environment_field(form, select_options = {}, html_options = {})
+      form.fields_for(:puppet, form.object.puppet || form.object.build_puppet, include_id: false) do |fields|
+        select_options = {
+          include_blank: true,
+          disable_button: _(::HostsAndHostgroupsHelper::INHERIT_TEXT),
+          disable_button_enabled: environment_inherited_by_default?(form.object),
+          user_set: user_set_environment?,
+        }.deep_merge(select_options)
+
+        html_options = {
+          data: {
+            host: {
+              id: form.object.id,
+            },
+          },
+        }.deep_merge(html_options)
+
+        puppet_environment_field(
+          fields,
+          accessible_resource(fields.object, 'ForemanPuppet::Environment', association: :environment),
+          select_options,
+          html_options
+        )
+      end
+    end
+
+    def hostgroup_puppet_environment_field(form, select_options = {}, html_options = {})
+      form.fields_for(:puppet, form.object.puppet || form.object.build_puppet, include_id: false) do |fields|
+        select_options = {
+          include_blank: blank_or_inherit_f(fields, :environment),
+        }.deep_merge(select_options)
+
+        puppet_environment_field(
+          fields,
+          accessible_resource(fields.object, 'ForemanPuppet::Environment', association: :environment),
+          select_options,
+          html_options
+        )
+      end
+    end
+
+    def puppet_environment_field(form, environments_choice, select_options = {}, html_options = {})
+      html_options = {
+        onchange: 'tfm.puppetEnc.hostForm.updatePuppetclasses(this)',
+        help_inline: :indicator,
+      }.deep_merge(html_options)
+
+      select_f(
+        form,
+        :environment_id,
+        environments_choice,
+        :id,
+        :to_label,
+        select_options,
+        html_options
+      )
+    end
+
+    def puppetclasses_with_parameters_for(obj)
+      classes = obj.all_puppetclasses
+      ids = classes.reorder(nil).pluck(:id)
+      class_vars = ForemanPuppet::PuppetclassLookupKey.reorder(nil)
+                                                      .joins(:environment_classes)
+                                                      .where(EnvironmentClass.arel_table[:puppetclass_id].in(ids))
+                                                      .distinct
+                                                      .pluck('environment_classes.puppetclass_id')
+      classes.where(id: class_vars)
+    end
+  end
+end

data/app/helpers/foreman_puppet/hosts_helper.rb

@@ -0,0 +1,32 @@
+module ForemanPuppet
+  module HostsHelper
+    UI.register_host_description do
+      multiple_actions_provider :puppet_host_multiple_actions
+      # otherwise registered twice
+      overview_buttons_provider :puppet_host_overview_buttons if ForemanPuppet.extracted_from_core?
+    end
+
+    def puppet_host_multiple_actions
+      if ForemanPuppet.extracted_from_core?
+        actions = [{ action: [_('Change Environment'), foreman_puppet.select_multiple_environment_hosts_path], priority: 200 }]
+        if authorized_for(controller: :hosts, action: :edit) && SmartProxy.unscoped.authorized.with_features('Puppet').exists?
+          actions << { action: [_('Change Puppet Master'), foreman_puppet.select_multiple_puppet_proxy_hosts_path], priority: 1050 }
+        end
+        actions
+      else
+        []
+      end
+    end
+
+    def puppet_host_overview_buttons(host)
+      buttons = []
+      if SmartProxy.with_features('Puppet').any?
+        buttons << {
+          button: link_to(_('Puppet YAML'), foreman_puppet.externalNodes_host_path(name: host), title: _('Puppet external nodes YAML dump'),
+                                                                                                class: 'btn btn-default'), priority: 400
+        }
+      end
+      buttons
+    end
+  end
+end

data/app/helpers/foreman_puppet/puppet_smart_proxies_helper.rb

@@ -0,0 +1,8 @@
+module ForemanPuppet
+  module PuppetSmartProxiesHelper
+    # For dashboard chart to work
+    def hosts_path(*attrs)
+      main_app.hosts_path(*attrs)
+    end
+  end
+end

data/app/helpers/foreman_puppet/puppetclass_lookup_keys_helper.rb

@@ -0,0 +1,135 @@
+module ForemanPuppet
+  module PuppetclassLookupKeysHelper
+    def puppetclass_lookup_keys_breadcrumbs
+      breadcrumbs(resource_url: api_smart_class_parameters_path,
+                  name_field: 'parameter',
+                  switcher_item_url: '/puppetclass_lookup_keys/:id-:name/edit')
+    end
+
+    # ------ Host(group) Form Helpers -----
+
+    def overridable_puppet_lookup_keys(klass, obj)
+      klass.class_params.override.where(environment_classes: { environment_id: obj.environment_id })
+    end
+
+    def hidden_puppet_lookup_value_fields(lookup_key, lookup_value, disabled)
+      return unless can_edit_params?
+      value_prefix = lookup_value_name_prefix(lookup_key.id)
+      hidden_field(value_prefix, :lookup_key_id, value: lookup_key.id,
+                                                 disabled: disabled, class: 'send_to_remove') +
+        hidden_field(value_prefix, :id, value: lookup_value.id,
+                                        disabled: disabled, class: 'send_to_remove') +
+        hidden_field(value_prefix, :_destroy, value: false,
+                                              disabled: disabled, class: 'send_to_remove destroy')
+    end
+
+    def omit_puppet_lookup_check_box(lookup_key, lookup_value, disabled)
+      check_box(lookup_value_name_prefix(lookup_key.id), :omit,
+        value: lookup_value.id,
+        disabled: disabled || !can_edit_params?,
+        onchange: "toggleOmitValue(this, 'value')",
+        hidden: disabled,
+        title: _('Omit from classification output'),
+        checked: lookup_value.omit)
+    end
+
+    def puppet_override_toggle(overridden)
+      return unless can_edit_params?
+      link_to_function(icon_text('pencil-square-o', '', kind: 'fa'), 'tfm.puppetEnc.hostForm.overridePuppetclassParam(this)',
+        title: _('Override this value'),
+        'data-tag': 'override',
+        class: "btn btn-default btn-md btn-override #{'hide' if overridden}") +
+        link_to_function(icon_text('times', '', kind: 'fa'), 'tfm.puppetEnc.hostForm.overridePuppetclassParam(this)',
+          title: _('Remove this override'),
+          'data-tag': 'remove',
+          class: "btn btn-default btn-md btn-override #{'hide' unless overridden}")
+    end
+
+    def puppet_lookup_key_with_diagnostic(obj, lookup_key, lookup_value)
+      value, matcher = lookup_value_matcher(obj, lookup_key)
+      inherited_value = LookupKey.format_value_before_type_cast(value, lookup_key.key_type)
+      effective_value = lookup_value.lookup_key_id.nil? ? inherited_value.to_s : lookup_value.value_before_type_cast.to_s
+      warnings = lookup_key_warnings(lookup_key.required, effective_value.present?)
+      popover_value = lookup_key.hidden_value? ? lookup_key.hidden_value : inherited_value
+
+      parameter_value_content(
+        "#{parameters_receiver}_lookup_values_attributes_#{lookup_key.id}_value",
+        effective_value,
+        popover: diagnostic_popover(lookup_key, matcher, popover_value, warnings),
+        name: "#{lookup_value_name_prefix(lookup_key.id)}[value]",
+        disabled: !lookup_key.overridden?(obj) || lookup_value.omit || !can_edit_params?,
+        inherited_value: inherited_value,
+        lookup_key: lookup_key,
+        hidden_value?: lookup_key.hidden_value?,
+        lookup_key_type: lookup_key.key_type
+      )
+    end
+
+    def lookup_value_matcher(obj, lookup_key)
+      if parameters_receiver == 'host'
+        value = puppet_lookup_value_hash_host_cache(obj)[lookup_key.id]
+        value_for_key = value.try(:[], lookup_key.key)
+        if value_for_key.present?
+          [value_for_key[:value], "#{value_for_key[:element]} (#{value_for_key[:element_name]})"]
+        else
+          [lookup_key.default_value, _('Default value')]
+        end
+      else # hostgroup
+        obj.inherited_lookup_value(lookup_key)
+      end
+    end
+
+    # rubocop:disable Rails/HelperInstanceVariable
+    def puppet_lookup_value_hash_host_cache(host)
+      @puppet_lookup_value_hash_host_cache ||= {}
+      @puppet_lookup_value_hash_host_cache[host.id] ||= ForemanPuppet::HostInfoProviders::PuppetInfo.new(host).inherited_puppetclass_parameters
+    end
+    # rubocop:enable Rails/HelperInstanceVariable
+
+    def diagnostic_popover(lookup_key, matcher, inherited_value, warnings)
+      description = lookup_key_description(lookup_key, matcher, inherited_value)
+      popover('', description.prepend(warnings[:text]),
+        data: { placement: 'top' },
+        title: _('Original value info'),
+        icon: 'info-circle',
+        kind: 'fa')
+    end
+
+    def lookup_key_description(lookup_key, matcher, inherited_value)
+      format(_("<b>Description:</b> %{desc}<br/>
+        <b>Type:</b> %{type}<br/>
+        <b>Matcher:</b> %{matcher}<br/>
+        <b>Inherited value:</b> %{inherited_value}"),
+        desc: html_escape(lookup_key.description),
+        type: lookup_key.key_type,
+        matcher: html_escape(matcher),
+        inherited_value: html_escape(inherited_value))
+    end
+
+    def lookup_key_warnings(required, has_value)
+      return { text: '', icon: 'info' } if has_value
+
+      if required
+        { text: _('Required parameter without value.<br/><b>Please override!</b><br/>'),
+          icon: 'error-circle-o' }
+      else
+        { text: _('Optional parameter without value.<br/><i>Still managed by Foreman, the value will be empty.</i><br/>'),
+          icon: 'warning-triangle-o' }
+      end
+    end
+
+    # Input tags used to override lookup keys need a 'name' HTML attribute to
+    # tell Rails which lookup_value they belong to.
+    # This method returns the name attribute for any combination of lookup_key
+    # and host/hostgroup. Other objects that may receive parameters too will need
+    # to override this method in their respective helpers.
+    def lookup_value_name_prefix(lookup_key_id)
+      "#{parameters_receiver}[lookup_values_attributes][#{lookup_key_id}]"
+    end
+
+    def parameters_receiver
+      return 'host' if params.key?(:host) || params[:controller] == 'hosts'
+      'hostgroup'
+    end
+  end
+end

data/app/helpers/foreman_puppet/puppetclasses_and_environments_helper.rb

@@ -0,0 +1,55 @@
+module ForemanPuppet
+  module PuppetclassesAndEnvironmentsHelper
+    def class_update_text(pcs, env)
+      if pcs.empty?
+        _('Empty environment')
+      elsif pcs == ['_destroy_']
+        _('Deleted environment')
+      elsif pcs.delete '_destroy_'
+        format(_('Deleted environment %{env} and %{pcs}'), env: env, pcs: pcs.to_sentence)
+      elsif pcs == ['_ignored_']
+        _('Ignored environment')
+      else
+        module_puppetclasses(pcs.is_a?(Hash) ? pcs.keys : pcs)
+      end
+    end
+
+    def import_proxy_select(hash)
+      select_action_button(_('Import'), {}, import_proxy_links(hash, true))
+    end
+
+    def import_proxy_links(hash, import_env_text = false, classes = nil)
+      import_from_text = import_env_text ? _('Import environments from %s') : _('Import classes from %s')
+      SmartProxy.with_features('Puppet').map do |proxy|
+        display_link_if_authorized(import_from_text % proxy.name, hash.merge(proxy: proxy), { class: classes })
+      end.flatten
+    end
+
+    private
+
+    def module_puppetclasses(classes)
+      mod_classes = {}
+      classes.each do |klass|
+        if (mod = klass.gsub(/::.*/, ''))
+          mod_classes[mod] ||= []
+          mod_classes[mod] << klass
+        end
+      end
+      mod_classes.keys.sort.map do |mod_name|
+        num = mod_classes[mod_name].size
+        num_tag = tag.span(num.to_s, class: 'label label-info')
+        tag.a(
+          mod_name,
+          rel: 'popover',
+          data: { content: mod_classes[mod_name].sort.join('<br>').html_safe,
+                  "original-title": format(n_('%{name} has %{num_tag} class', '%{name} has %{num_tag} classes', num), name: mod_name, num_tag: num_tag),
+                  trigger: 'focus',
+                  container: 'body',
+                  html: true },
+          role: 'button',
+          tabindex: '-1'
+        )
+      end.to_sentence.html_safe
+    end
+  end
+end