foreman_remote_execution 4.2.1 → 4.4.0

data/Gemfile

@@ -2,7 +2,4 @@ source 'http://rubygems.org'
 
 gemspec :name => 'foreman_remote_execution'
 
-gem 'rubocop', '~> 0.80.0'
-gem 'rubocop-minitest'
-gem 'rubocop-performance'
-gem 'rubocop-rails'
+gem 'theforeman-rubocop', '~> 0.1.0.pre'

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

@@ -64,6 +64,16 @@ module Api
           param :description_format, String, :required => false, :desc => N_('Override the description format from the template for this invocation only')
           param :execution_timeout_interval, Integer, :required => false, :desc => N_('Override the timeout interval from the template for this invocation only')
           param :feature, String, :required => false, :desc => N_('Remote execution feature label that should be triggered, job template assigned to this feature will be used')
+
+          RemoteExecutionProvider.providers.each_value do |provider|
+            next if !provider.respond_to?(:provider_inputs_doc) || provider.provider_inputs_doc.empty?
+            doc = provider.provider_inputs_doc
+            param doc[:namespace], Hash, doc[:opts] do
+              doc[:children].map do |input|
+                param input[:name], input[:type], input[:opts]
+              end
+            end
+          end
         end
       end
 
@@ -195,9 +205,15 @@ module Api
         end
         job_invocation_params[:inputs] ||= {}
         job_invocation_params[:inputs].permit!
+        permit_provider_inputs job_invocation_params
         @job_invocation_params = job_invocation_params
       end
 
+      def permit_provider_inputs(invocation_params)
+        providers = RemoteExecutionProvider.providers.values.reject { |provider| !provider.respond_to?(:provider_input_namespace) || provider.provider_input_namespace.empty? }
+        providers.each { |provider| invocation_params[provider.provider_input_namespace]&.permit! }
+      end
+
       def composer_for_feature
         JobInvocationComposer.for_feature(
           job_invocation_params[:feature],
@@ -214,7 +230,7 @@ module Api
       end
 
       def host_output(job_invocation, host, default: nil, since: nil, raw: false)
-        refresh = true
+        refresh = !job_invocation.finished?
 
         if (task = job_invocation.sub_task_for_host(host))
           refresh = task.pending?

data/app/controllers/foreman_remote_execution/concerns/api/v2/registration_commands_controller_extensions.rb

@@ -0,0 +1,19 @@
+module ForemanRemoteExecution
+  module Concerns
+    module Api
+      module V2
+        module RegistrationCommandsControllerExtensions
+          module ApipieExtensions
+            extend Apipie::DSL::Concern
+
+            update_api(:create) do
+              param :registration_command, Hash do
+                param :remote_execution_interface, String, desc: N_("Identifier of the Host interface for Remote execution")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/ui_job_wizard_controller.rb

@@ -0,0 +1,18 @@
+class UiJobWizardController < ::Api::V2::BaseController
+  def categories
+    job_categories = resource_scope
+                     .search_for("job_category ~ \"#{params[:search]}\"")
+                     .select(:job_category).distinct
+                     .reorder(:job_category)
+                     .pluck(:job_category)
+    render :json => {:job_categories =>job_categories}
+  end
+
+  def resource_class
+    JobTemplate
+  end
+
+  def action_permission
+    :view_job_templates
+  end
+end

data/app/helpers/remote_execution_helper.rb

@@ -60,6 +60,12 @@ module RemoteExecutionHelper
     job_invocation = task.task_groups.find { |group| group.class == JobInvocationTaskGroup }.job_invocation
     task_authorizer = Authorizer.new(User.current, :collection => [task])
     buttons = []
+    if (template = job_report_template) && authorized_for(controller: :report_templates, action: :generate)
+      buttons << link_to(_('Create Report'), generate_report_template_path(template, job_report_template_parameters(job_invocation, template)),
+        class: 'btn btn-default',
+        title: _('Create report for this job'),
+        disabled: task.pending?)
+    end
     if authorized_for(hash_for_new_job_invocation_path)
       buttons << link_to(_('Rerun'), rerun_job_invocation_path(:id => job_invocation.id),
         :class => 'btn btn-default',
@@ -230,6 +236,27 @@ module RemoteExecutionHelper
     task.execution_plan.actions[1].try(:input).try(:[], 'script')
   end
 
+  def job_report_template
+    template = ReportTemplate.where(name: Setting['remote_execution_job_invocation_report_template']).first
+
+    template if template.template_inputs.where(name: 'job_id').exists?
+  end
+
+  def job_report_template_parameters(job_invocation, template)
+    template_input = template.template_inputs.where(name: 'job_id').first
+    raise "#job_report_template_parameters need template that has 'job_id' input" unless template_input
+
+    {
+      report_template_report: {
+        input_values: {
+          "#{template_input.id}": {
+            value: job_invocation.id,
+          },
+        },
+      },
+    }
+  end
+
   def targeting_hosts(job_invocation, hosts)
     hosts.map do |host|
       template_invocation = job_invocation.template_invocations.find { |template_inv| template_inv.host_id == host.id }

data/app/lib/actions/remote_execution/run_host_job.rb

@@ -3,6 +3,7 @@ module Actions
     class RunHostJob < Actions::EntryAction
       include ::Actions::Helpers::WithContinuousOutput
       include ::Actions::Helpers::WithDelegatedAction
+      include ::Actions::ObservableAction
 
       middleware.do_not_use Dynflow::Middleware::Common::Transaction
       middleware.use Actions::Middleware::HideSecrets
@@ -16,7 +17,7 @@ module Actions
       end
 
       def plan(job_invocation, host, template_invocation, proxy_selector = ::RemoteExecutionProxySelector.new, options = {})
-        action_subject(host, :job_category => job_invocation.job_category, :description => job_invocation.description)
+        action_subject(host, :job_category => job_invocation.job_category, :description => job_invocation.description, :job_invocation_id => job_invocation.id)
 
         template_invocation.host_id = host.id
         template_invocation.run_host_job_task_id = task.id
@@ -121,6 +122,26 @@ module Actions
         delegated_output[:exit_status]
       end
 
+      def host_id
+        input['host']['id']
+      end
+
+      def host_name
+        input['host']['name']
+      end
+
+      def job_invocation_id
+        input['job_invocation_id']
+      end
+
+      def job_invocation
+        @job_invocation ||= ::JobInvocation.authorized.find(job_invocation_id)
+      end
+
+      def host
+        @host ||= ::Host.authorized.find(host_id)
+      end
+
       private
 
       def update_host_status
@@ -173,6 +194,22 @@ module Actions
         end
         proxy
       end
+
+      extend ApipieDSL::Class
+      apipie :class, "An action representing execution of a job against a host" do
+        name 'Actions::RemoteExecution::RunHostJob'
+        refs 'Actions::RemoteExecution::RunHostJob'
+        sections only: %w[all webhooks]
+        property :task, object_of: 'Task', desc: 'Returns the task to which this action belongs'
+        property :host_name, String, desc: "Returns the name of the host"
+        property :host_id, Integer, desc: "Returns the id of the host"
+        property :host, object_of: 'Host', desc: "Returns the host"
+        property :job_invocation_id, Integer, desc: "Returns the id of the job invocation"
+        property :job_invocation, object_of: 'JobInvocation', desc: "Returns the job invocation"
+      end
+      class Jail < ::Actions::ObservableAction::Jail
+        allow :host_name, :host_id, :host, :job_invocation_id, :job_invocation
+      end
     end
   end
 end

data/app/lib/foreman_remote_execution/provider_input.rb

@@ -0,0 +1,29 @@
+module ForemanRemoteExecution
+  class ProviderInput
+    attr_reader :name, :label, :description, :options, :value_type, :required
+    attr_accessor :value
+
+    def initialize(name:, label:, value:, description: nil, options: nil, value_type: nil, required: false, hidden: false)
+      @name = name
+      @label = label
+      @value = value
+      @description = description
+      @options = options
+      @value_type = value_type
+      @required = required
+      @hidden = hidden
+    end
+
+    def template_input
+      self
+    end
+
+    def hidden_value?
+      @hidden
+    end
+
+    def options_array
+      options.blank? ? [] : options.split(/\r?\n/).map(&:strip)
+    end
+  end
+end

data/app/lib/foreman_remote_execution/renderer/scope/input.rb

@@ -6,6 +6,7 @@ module ForemanRemoteExecution
         extend ApipieDSL::Class
 
         attr_reader :template, :host, :invocation, :input_template_instance, :current_user
+        attr_accessor :error_message
         delegate :input, to: :input_template_instance
 
         apipie :class, 'Macros related to template rendering' do

data/app/models/foreign_input_set.rb

@@ -4,7 +4,7 @@ class ForeignInputSet < ApplicationRecord
   class CircularDependencyError < Foreman::Exception
   end
 
-  attr_exportable :exclude, :include, :include_all, :template => ->(input_set) { input_set.template.name }
+  attr_exportable :exclude, :include, :include_all, :template => ->(input_set) { input_set.target_template.name }
 
   belongs_to :template
   belongs_to :target_template, :class_name => 'Template'

data/app/models/host_status/execution_status.rb

@@ -49,6 +49,13 @@ class HostStatus::ExecutionStatus < HostStatus::Status
     end
   end
 
+  def status_link
+    job_invocation = last_stopped_task.parent_task.job_invocations.first
+    return nil unless User.current.can?(:view_job_invocations, job_invocation)
+
+    Rails.application.routes.url_helpers.job_invocation_path(job_invocation)
+  end
+
   class ExecutionTaskStatusMapper
     attr_accessor :task
 

data/app/models/invocation_provider_input_value.rb

@@ -0,0 +1,12 @@
+class InvocationProviderInputValue < ApplicationRecord
+  belongs_to :template_invocation
+
+  validates :name, :presence => true
+
+  validates :value, :inclusion => { :in => proc { |v| v.provider_input.options_array } },
+                    :if => proc { |v| v.provider_input.options_array.present? }
+
+  def provider_input
+    template_invocation.template.provider.provider_inputs.find { |item| item.name == name }
+  end
+end

data/app/models/job_invocation.rb

@@ -76,6 +76,10 @@ class JobInvocation < ApplicationRecord
 
   encrypts :password, :key_passphrase, :effective_user_password
 
+  class Jail < Safemode::Jail
+    allow :sub_task_for_host, :template_invocations_hosts
+  end
+
   def self.search_by_status(key, operator, value)
     conditions = HostStatus::ExecutionStatus::ExecutionTaskStatusMapper.sql_conditions_for(value)
     conditions[0] = "NOT (#{conditions[0]})" if operator == '<>'
@@ -241,7 +245,7 @@ class JobInvocation < ApplicationRecord
   end
 
   def finished?
-    !task.pending?
+    !(task.nil? || task.pending?)
   end
 
   def missing_hosts_count

data/app/models/job_invocation_composer.rb

@@ -64,6 +64,10 @@ class JobInvocationComposer
           values.merge(:template_input_id => id)
         end
 
+        provider_values_params = template_base.fetch(:provider_input_values, {})
+        template_base[:provider_input_values] = provider_values_params.map do |key, hash|
+          { :name => key, :value => hash[:value] }
+        end
         template_base
       end
     end
@@ -147,6 +151,7 @@ class JobInvocationComposer
 
     def template_invocations_params
       template_invocation_params = { :template_id => template.id, :effective_user => api_params[:effective_user] }
+      template_invocation_params[:provider_input_values] = filter_provider_inputs api_params
       template_invocation_params[:input_values] = api_params.fetch(:inputs, {}).to_h.map do |name, value|
         input = template.template_inputs_with_foreign.find { |i| i.name == name }
         unless input
@@ -158,6 +163,13 @@ class JobInvocationComposer
       [template_invocation_params]
     end
 
+    def filter_provider_inputs(api_params)
+      return [] if template.provider.provider_input_namespace.empty?
+      inputs = api_params[template.provider.provider_input_namespace].to_h
+      provider_input_names = template.provider.provider_inputs.map(&:name)
+      inputs.select { |key, value| provider_input_names.include? key }.map { |key, value| { :name => key, :value => value } }
+    end
+
     def template
       @template ||= JobTemplate.authorized(:view_job_templates).find(api_params[:job_template_id])
     end
@@ -503,6 +515,7 @@ class JobInvocationComposer
       input = template_invocation.template.template_inputs_with_foreign.find { |i| i.id.to_s == attributes[:template_input_id].to_s }
       input ? input.template_invocation_input_values.build(attributes) : nil
     end.compact
+    template_invocation.provider_input_values.build job_template_base.fetch('provider_input_values', [])
   end
 
   def build_targeting

data/app/models/remote_execution_provider.rb

@@ -20,7 +20,7 @@ class RemoteExecutionProvider
     end
 
     def proxy_command_options(template_invocation, host)
-      {:proxy_operation_name => proxy_operation_name}
+      {:proxy_operation_name => proxy_operation_name}.merge(proxy_command_provider_inputs(template_invocation))
     end
 
     def secrets(_host)
@@ -35,6 +35,9 @@ class RemoteExecutionProvider
       self.name
     end
 
+    def provider_input_namespace
+    end
+
     def supports_effective_user?
       false
     end
@@ -95,8 +98,20 @@ class RemoteExecutionProvider
     def ssh_key_passphrase(_host)
     end
 
+    def provider_inputs
+      []
+    end
+
+    def provider_inputs_doc
+      {}
+    end
+
+    def proxy_command_provider_inputs(template_invocation)
+      {}
+    end
+
     def proxy_action_class
-      ForemanRemoteExecutionCore::Actions::RunScript
+      'ForemanRemoteExecutionCore::Actions::RunScript'
     end
 
     # Return a specific proxy selector to use for running a given template

data/app/models/setting/remote_execution.rb

@@ -73,6 +73,16 @@ class Setting::RemoteExecution < Setting
         _('Form Job Template'),
         nil,
         { :collection => proc { Hash[JobTemplate.unscoped.map { |template| [template.name, template.name] }] } }),
+      self.set('remote_execution_job_invocation_report_template',
+        N_('Select a report template used for generating a report for a particular remote execution job'),
+        'Jobs - Invocation report template',
+        _('Job Invocation Report Template'),
+        nil,
+        { :collection => proc { self.job_invocation_report_templates_select } }),
     ]
   end
+
+  def self.job_invocation_report_templates_select
+    Hash[ReportTemplate.unscoped.joins(:template_inputs).where(template_inputs: TemplateInput.where(name: 'job_id')).map { |template| [template.name, template.name] }]
+  end
 end

data/app/models/template_invocation.rb

@@ -11,6 +11,7 @@ class TemplateInvocation < ApplicationRecord
   belongs_to :template, :class_name => 'JobTemplate', :foreign_key => 'template_id'
   belongs_to :job_invocation, :inverse_of => :template_invocations
   has_many :input_values, :class_name => 'TemplateInvocationInputValue', :dependent => :destroy
+  has_many :provider_input_values, :class_name => 'InvocationProviderInputValue', :dependent => :destroy
   has_one :targeting, :through => :job_invocation
   belongs_to :host, :class_name => 'Host::Managed', :foreign_key => :host_id
   has_one :host_group, :through => :host, :source => :hostgroup
@@ -77,6 +78,7 @@ class TemplateInvocation < ApplicationRecord
   def deep_clone
     self.dup.tap do |invocation|
       invocation.input_values = self.input_values.map(&:dup)
+      invocation.provider_input_values = self.provider_input_values.map(&:dup)
     end
   end
 

data/app/services/renderer_methods.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# macros to fetch information about invoked jobs
+module RendererMethods
+  extend ActiveSupport::Concern
+
+  def find_job_invocation_by_id(job_id, preload: nil)
+    JobInvocation.preload(preload).find_by(id: job_id)
+  rescue ActiveRecord::NotFound => _e
+    raise ::Foreman::Exception.new(N_("Can't find Job Invocation for an id %s"), job_id)
+  end
+end

data/app/views/job_invocations/_form.html.erb

@@ -74,6 +74,14 @@
                     <% end %>
 
                     <div class="advanced hidden">
+                      <%= job_template_fields.fields_for :provider_input_values do |provider_input_fields| %>
+                        <% job_template.provider.provider_inputs.each do |input| %>
+                            <%= provider_input_fields.fields_for input.name, input do |input_fields| %>
+                              <%= template_input_f(input_fields) %>
+                            <% end %>
+                        <% end %>
+                      <% end %>
+
                       <% if job_template.effective_user.overridable? %>
                         <%= text_f job_template_fields, :effective_user, :value => @composer.template_invocation(job_template).try(:effective_user), :label => _('Effective user'), :label_help => N_("A user to be used for executing the script. If it differs from the SSH user, su or sudo is used to switch the accounts.") %>
                       <% end %>