foreman_ansible 6.2.0 → 6.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d95899e15050cbf3f25d75a8f3c9bc5a3059a9dd0ffa90f4690ce84cf49d3408
-  data.tar.gz: 466754ac90d1e80046fca70ca8db372e90d2b61a0d26a726f0807f7e81227728
+  metadata.gz: 4a67f34724383faf6ead25e0d28e47d86b30d817839e3d9e3e6ef0531f9a4c5a
+  data.tar.gz: e758ebdaa34fe47e84aac20c5cd12af9013cad2d17810b73f894a7b6177e570b
 SHA512:
-  metadata.gz: 9f79b560e9e01e8719c6e705ff5fef6a9f9e7b91bc9ec1b9b79c81750b572c4de6929d2ab07049caefdf4f555a5087c31eb76543d52b87622038107a1e02ea63
-  data.tar.gz: 357b61ffdb94b61a37ecf87afba07f7e0c2158d4af14d39b701fb31152803692a8feaac09294bb2bc8c0ae8fe8d9daa66eb8eb6f0869c4901315dca688f06dab
+  metadata.gz: 0a3f9e4fe92c5325908b61e9542e4a99c4256f1c9b0b66f58873e73c8fa3b90194d39a054c2857060edc37ebd214b2186d8dced6078950f936ec8e9ae4b5fde4
+  data.tar.gz: 82aab4e76eedc22109debf0c1a60bc316c512677749dff6b1a53a4357c66d16dee37260fdc53ce643b362fcbc253a5ad6b3c8ff9636c736faee22ad229f821b7

data/app/controllers/ansible_roles_controller.rb

@@ -4,7 +4,7 @@
 class AnsibleRolesController < ::ApplicationController
   include Foreman::Controller::AutoCompleteSearch
   include ForemanAnsible::Concerns::ImportControllerHelper
-
+  include ::ForemanAnsible::AnsibleRolesDataPreparations
   def index
     @ansible_roles = resource_base.search_for(params[:search],
                                               :order => params[:order]).
@@ -22,18 +22,21 @@ class AnsibleRolesController < ::ApplicationController
 
   def import
     changed = @importer.import!
-    if changed.values.all?(&:empty?)
+    @rows = prepare_ansible_import_rows(changed, @variables_importer)
+    if @rows.empty?
       success no_changed_roles_message
       redirect_to ansible_roles_path
     else
-      render :locals => { :changed => changed }
+      render
     end
   end
 
   def confirm_import
-    @importer.finish_import(params[:changed]&.to_unsafe_h)
-    success _('Import of roles successfully finished.')
-    redirect_to ansible_roles_path
+    job = SyncRolesAndVariables.perform_later(params['changed'].to_unsafe_h, @proxy)
+    task = ForemanTasks::Task.find_by(external_id: job.provider_job_id)
+    render json: {
+      task: task
+    }, status: :ok
   end
 
   private
@@ -44,10 +47,11 @@ class AnsibleRolesController < ::ApplicationController
 
   def create_importer
     @importer = ForemanAnsible::UiRolesImporter.new(@proxy)
+    @variables_importer = ForemanAnsible::VariablesImporter.new(@proxy)
   end
 
   def no_changed_roles_message
-    return _('No changes in roles detected.') if @proxy.blank?
-    _('No changes in roles detected on %s.') % @proxy.name
+    return _('No added or removed roles nor variables.') if @proxy.blank?
+    _('No added or removed roles nor variables detected on %s.') % @proxy.name
   end
 end

data/app/controllers/ansible_variables_controller.rb

@@ -104,4 +104,8 @@ class AnsibleVariablesController < ::LookupKeysController
     end
     @smart_proxy
   end
+
+  def controller_permission
+    'ansible_variables'
+  end
 end

data/app/controllers/api/v2/ansible_roles_controller.rb

@@ -5,6 +5,7 @@ module Api
     # API controller for Ansible Roles
     class AnsibleRolesController < ::Api::V2::BaseController
       include ::Api::Version2
+      include ::ForemanAnsible::AnsibleRolesDataPreparations
 
       resource_description do
         api_version 'v2'
@@ -12,8 +13,8 @@ module Api
       end
 
       before_action :find_resource, :only => [:show, :destroy]
-      before_action :find_proxy, :only => [:import, :obsolete, :fetch]
-      before_action :create_importer, :only => [:import, :obsolete, :fetch]
+      before_action :find_proxy, :only => [:import, :obsolete, :fetch, :sync]
+      before_action :create_importer, :only => [:import, :obsolete, :fetch, :sync]
 
       api :GET, '/ansible_roles/:id', N_('Show role')
       param :id, :identifier, :required => true
@@ -32,28 +33,46 @@ module Api
         process_response @ansible_role.destroy
       end
 
-      api :PUT, '/ansible_roles/import', N_('Import Ansible roles')
+      api :PUT, '/ansible_roles/import', N_('DEPRECATED: Import Ansible roles'), deprecated: true
       param :proxy_id, :identifier, :required => true, :desc => N_('Smart Proxy to import from')
-      param :role_names, Array, N_('Ansible role names to import')
+      param :role_names, Array, N_('Ansible role names to be imported')
       def import
-        @imported = @importer.import!(role_names)
+        Foreman::Deprecation.api_deprecation_warning(_('Use sync instead, to sync roles from Smart Proxy with Ansible feature enabled'))
+        new_roles = @roles_importer.import_role_names['new']
+        if role_names.present?
+          new_roles.select! do |role|
+            role_names.include?(role.name)
+          end
+        end
+        new_roles.map(&:save)
+        @imported = new_roles
+      end
+
+      api :PUT, '/ansible_roles/sync', N_('Sync Ansible roles')
+      param :proxy_id, :identifier, :required => true, :desc => N_('Smart Proxy to sync from')
+      param :role_names, Array, N_('Ansible role names to be synced')
+      def sync
+        params = @importer.import!(role_names)
+        if params['changed'].present?
+          @task = @importer.confirm_sync(params)
+        else
+          render_message _('No changes detected in specified Ansible Roles and their variables')
+        end
       end
 
-      api :PUT, '/ansible_roles/obsolete', N_('Obsolete Ansible roles')
+      api :PUT, '/ansible_roles/obsolete', N_('DEPRECATED: Obsolete Ansible roles'), deprecated: true
       param :proxy_id, :identifier, N_('Smart Proxy to import from')
       def obsolete
+        Foreman::Deprecation.api_deprecation_warning(_('Use sync instead, to sync roles from Smart Proxy with Ansible feature enabled'))
         @obsoleted = @importer.obsolete!
       end
 
       api :GET, '/ansible_roles/fetch',
-          N_('Fetch Ansible roles available to be imported')
+          N_('Fetch Ansible roles available to be synced')
       param :proxy_id, :identifier, N_('Smart Proxy to fetch from'),
             :required => true
       def fetch
-        fetched = []
-        @importer.fetch!.each do |role_name|
-          fetched << { :name => role_name }
-        end
+        fetched =  prepare_ansible_import_rows(@roles_importer.import!, @variables_importer, false)
         respond_to do |format|
           format.json do
             render :json => { :results => { :ansible_roles => fetched } }
@@ -79,6 +98,8 @@ module Api
       # rubocop:enable Layout/DotPosition
 
       def create_importer
+        @roles_importer = ForemanAnsible::UiRolesImporter.new(@proxy)
+        @variables_importer = ForemanAnsible::VariablesImporter.new(@proxy)
         @importer = ForemanAnsible::ApiRolesImporter.new(@proxy)
       end
     end

data/app/controllers/api/v2/ansible_variables_controller.rb

@@ -69,20 +69,22 @@ module Api
       end
 
       api :PUT, '/ansible_variables/import',
-          N_('Import Ansible variables. This will only import variables '\
-             'for already existing roles, it will not import any new roles')
+          N_('DEPRECATED: Import Ansible variables. This will only import variables '\
+             'for already existing roles, it will not import any new roles'), deprecated: true
       param :proxy_id, :identifier, N_('Smart Proxy to import from'), :required => true
       def import
+        Foreman::Deprecation.api_deprecation_warning(_('Use sync instead, to sync roles from Smart Proxy with Ansible feature enabled'))
         new_variables = @importer.import_variable_names([])[:new]
         new_variables.map(&:save)
         @imported = new_variables
       end
 
       api :PUT, '/ansible_variables/obsolete',
-          N_('Obsolete Ansible variables. This will only obsolete variables '\
-             'for already existing roles, it will not delete any old roles')
+          N_('DEPRECATED: Obsolete Ansible variables. This will only obsolete variables '\
+             'for already existing roles, it will not delete any old roles'), deprecated: true
       param :proxy_id, :identifier, N_('Smart Proxy to import from'), :required => true
       def obsolete
+        Foreman::Deprecation.api_deprecation_warning(_('Use sync instead, to sync roles from Smart Proxy with Ansible feature enabled'))
         old_variables = @importer.import_variable_names([])[:obsolete]
         old_variables.map(&:destroy)
         @obsoleted = old_variables

data/app/controllers/foreman_ansible/concerns/import_controller_helper.rb

@@ -9,15 +9,15 @@ module ForemanAnsible
       included do
         # rubocop:disable Rails/LexicallyScopedActionFilter
         before_action :find_resource, :only => [:destroy]
-        before_action :find_proxy, :only => [:import]
-        before_action :create_importer, :only => [:import, :confirm_import]
+        before_action :find_proxy, :only => [:import, :import_variables, :confirm_import]
+        before_action :create_importer, :only => [:import, :confirm_import, :import_variables, :confirm_import]
         before_action :default_order, :only => [:index]
         # rubocop:enable Rails/LexicallyScopedActionFilter
       end
 
       def find_proxy
         return nil unless params[:proxy]
-        @proxy = SmartProxy.authorized(:view_smart_proxies).find(params[:proxy])
+        @proxy = SmartProxy.find(params[:proxy])
       end
     end
   end

data/app/helpers/foreman_ansible/ansible_reports_helper.rb

@@ -19,6 +19,14 @@ module ForemanAnsible
       name
     end
 
+    def ansible_run_in_check_mode?(log)
+      log.message&.value == 'check_mode_enabled' if check_mode_log?(log)
+    end
+
+    def check_mode_log?(log)
+      log.source&.value == 'check_mode'
+    end
+
     def ansible_module_args(log)
       report_json_viewer module_invocations parsed_message_json(log)
     end

data/app/helpers/foreman_ansible/ansible_roles_data_preparations.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ForemanAnsible
+  module AnsibleRolesDataPreparations
+    VARIABLE_ACTION_NAMES = { 'new' => _('Add'), 'obsolete' => _('Remove'), 'update' => _('Update') }.freeze
+    ROLE_ACTION_NAMES = { 'new' => _('Import Role'), 'obsolete' => _('Remove Role'), 'old' => _('Update Role Variables') }.freeze
+
+    def variable_action_name(kind)
+      VARIABLE_ACTION_NAMES[kind]
+    end
+
+    def role_action_name(kind)
+      ROLE_ACTION_NAMES[kind]
+    end
+
+    def get_old_roles_variables(imported_variables, role)
+      variables = { 'new' => [], 'obsolete' => [], 'update' => [] }
+      imported_variables.each do |kind, temp_variables|
+        temp_variables.each do |temp_variable|
+          variables[kind].append(temp_variable.key) if temp_variable.ansible_role_id == role.id
+        end
+      end
+      variables
+    end
+
+    def variables_to_s(variables)
+      str = ''
+      variables.each do |action, temp_variables|
+        str += "#{variable_action_name action}: #{temp_variables.size}, " unless temp_variables.empty?
+      end
+      str[0..-3]
+    end
+
+    def get_roles_variables(imported_variables, variables_importer, kind, role)
+      if kind == 'new'
+        variables = { 'new' => variables_importer.get_variables_names(role.name) }
+      elsif kind == 'obsolete'
+        variables = { 'obsolete' => role.ansible_variables.map(&:key) }
+      elsif kind == 'old'
+        variables = get_old_roles_variables(imported_variables, role)
+      end
+      variables_to_s(variables)
+    end
+
+    def excluded_roles
+      Setting.convert_array_to_regexp(Setting[:ansible_roles_to_ignore])
+    end
+
+    def role_match_excluded_roles(role_name)
+      match = role_name.match(excluded_roles)
+      match.to_s.empty? ? nil : match
+    end
+
+    def prepare_api_row(role, kind, variables)
+      {
+        name: role.name,
+        id: role.id,
+        role_action: role_action_name(kind),
+        variables: variables,
+        hosts_count: kind == 'obsolete' ? role.hosts.count : '',
+        hostgroup_count: kind == 'obsolete' ? role.hostgroups.count : '',
+        kind: kind
+      }
+    end
+
+    def prepare_ui_row(role, kind, variables)
+      { cells: [
+        role.name,
+        role_action_name(kind),
+        variables,
+        kind == 'obsolete' ? role.hosts.count : '',
+        kind == 'obsolete' ? role.hostgroups.count : ''
+      ],
+        role: role, kind: kind, id: role.name }
+    end
+
+    def prepare_ansible_import_rows(changed, variables_importer, is_ui = true)
+      rows = []
+      changed.each do |kind, roles|
+        imported_variables = variables_importer.import_variable_names(roles)
+        roles.each do |role|
+          next if role_match_excluded_roles(role.name)
+          variables = get_roles_variables(imported_variables, variables_importer, kind, role)
+          next if variables.empty? && kind['old']
+          if is_ui
+            rows.append(prepare_ui_row(role, kind, variables))
+          else
+            rows.append(prepare_api_row(role, kind, variables))
+          end
+        end
+      end
+      rows
+    end
+  end
+end

data/app/helpers/foreman_ansible/ansible_roles_helper.rb

@@ -35,8 +35,27 @@ module ForemanAnsible
       _('%s ago') % time_ago_in_words(role.updated_at)
     end
 
+    def role_attributes_for_roles_switcher(form_object)
+      inherited_role_ids = form_object.inherited_ansible_roles.map(&:id)
+      if form_object.is_a?(Hostgroup)
+        assoc_roles = form_object.hostgroup_ansible_roles
+        assoc_key = :hostgroup_ansible_role_id
+      else
+        assoc_roles = form_object.host_ansible_roles
+        assoc_key = :host_ansible_role_id
+      end
+      own_roles_attrs = model_roles_attrs(assoc_roles.reject { |ar| inherited_role_ids.include?(ar.ansible_role_id) }, assoc_key)
+      roles_attrs(form_object.inherited_ansible_roles) + own_roles_attrs
+    end
+
     def roles_attrs(roles)
-      roles.map { |item| { :id => item.id, :name => item.name } }
+      roles.map { |item| { id: item.id, name: item.name } }
+    end
+
+    private
+
+    def model_roles_attrs(associated_roles, assoc_key)
+      associated_roles.map { |item| { id: item.ansible_role_id, name: item.ansible_role.name, position: item.position }.merge(assoc_key => item.id) }
     end
   end
 end

data/app/jobs/sync_roles_and_variables.rb

@@ -0,0 +1,20 @@
+class SyncRolesAndVariables < ::ApplicationJob
+  queue_as :default
+
+  def perform(changed, proxy)
+    roles_importer = ForemanAnsible::UiRolesImporter.new(proxy)
+    variables_importer = ForemanAnsible::VariablesImporter.new(proxy)
+    roles_importer.finish_import(changed)
+    variables_importer.import_variables_roles(changed) if changed['new'] || changed['old']
+    task = ForemanTasks::Task.where(:external_id => @provider_job_id)[0]
+    ForemanAnsible::ImportRolesAndVariablesSuccessNotification.deliver!(task)
+  rescue StandardError => e
+    task = ForemanTasks::Task.where(:external_id => @provider_job_id)[0]
+    notification = ForemanAnsible::ImportRolesAndVariablesErrorNotification.new(e, task)
+    notification.deliver!
+  end
+
+  def humanized_name
+    _('Import roles And Variables')
+  end
+end

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

@@ -8,9 +8,12 @@ module ForemanAnsible
       base.instance_eval do
         include ::ForemanAnsible::Concerns::JobInvocationHelper
 
-        has_many :host_ansible_roles, :foreign_key => :host_id
-        has_many :ansible_roles, :through => :host_ansible_roles,
-                                 :dependent => :destroy
+        has_many :host_ansible_roles, -> { order('host_ansible_roles.position ASC') }, :foreign_key => :host_id
+        accepts_nested_attributes_for :host_ansible_roles, :allow_destroy => true
+        has_many :ansible_roles,
+                 -> { order('host_ansible_roles.position ASC') },
+                 :through => :host_ansible_roles,
+                 :dependent => :destroy
         scoped_search :relation => :ansible_roles, :on => :name,
                       :complete_value => true, :rename => :ansible_role,
                       :only_explicit => true
@@ -47,7 +50,7 @@ module ForemanAnsible
     end
 
     def all_ansible_roles
-      (ansible_roles + inherited_ansible_roles).uniq
+      (inherited_ansible_roles + ansible_roles).uniq
     end
 
     # Class methods we may need to override or add

data/app/models/concerns/foreman_ansible/hostgroup_extensions.rb

@@ -6,9 +6,12 @@ module ForemanAnsible
     extend ActiveSupport::Concern
 
     included do
-      has_many :hostgroup_ansible_roles, :foreign_key => :hostgroup_id
-      has_many :ansible_roles, :through => :hostgroup_ansible_roles,
-                               :dependent => :destroy
+      has_many :hostgroup_ansible_roles, -> { order('hostgroup_ansible_roles.position ASC') }, :foreign_key => :hostgroup_id
+      has_many :ansible_roles,
+               -> { order('hostgroup_ansible_roles.position ASC') },
+               :through => :hostgroup_ansible_roles,
+               :dependent => :destroy
+      accepts_nested_attributes_for :hostgroup_ansible_roles, :allow_destroy => true
       audit_associations :ansible_roles
 
       def inherited_ansible_roles
@@ -24,14 +27,14 @@ module ForemanAnsible
       end
 
       def host_ansible_roles
-        hosts.all.includes(:ansible_roles).flat_map(&:ansible_roles)
+        hosts.includes(:host_ansible_roles).flat_map(&:ansible_roles)
       end
 
       # includes also roles of all assigned hosts, useful to determine if
       # at least one host in this hostgroup has some ansible role assigned
       # either directly or through hostgroup
       def all_ansible_roles
-        (ansible_roles + inherited_ansible_roles + host_ansible_roles).uniq
+        (inherited_ansible_roles + ansible_roles + host_ansible_roles).uniq
       end
     end
   end

data/app/models/foreman_ansible/ansible_provider.rb

@@ -27,12 +27,14 @@ if defined? ForemanRemoteExecution
             :remote_execution_command => ansible_command?(
               template_invocation.template
             ),
-            :name => host.name
+            :name => host.name,
+            :check_mode => host.host_param('ansible_roles_check_mode')
           )
         end
 
         def secrets(host)
           {
+            :key_passphrase => Setting[:remote_execution_ssh_key_passphrase],
             'per-host' => {
               host.name => {
                 'ansible_password' => rex_ssh_password(host),

data/app/models/host_ansible_role.rb

@@ -4,6 +4,7 @@
 class HostAnsibleRole < ApplicationRecord
   belongs_to_host
   belongs_to :ansible_role
+  acts_as_list scope: :host
 
   validates :ansible_role_id, :presence => true,
                               :uniqueness => { :scope => :host_id }