foreman_remote_execution 0.2.3 → 0.3.0

data/app/lib/actions/remote_execution/helpers/live_output.rb

@@ -2,11 +2,11 @@ module Actions
   module RemoteExecution
     module Helpers
       module LiveOutput
-        def exception_to_output(context, exception, timestamp = Time.now)
+        def exception_to_output(context, exception, timestamp = Time.now.getlocal)
           format_output(context + ": #{exception.class} - #{exception.message}", 'debug', timestamp)
         end
 
-        def format_output(message, type = 'debug', timestamp = Time.now)
+        def format_output(message, type = 'debug', timestamp = Time.now.getlocal)
           { 'output_type' => type,
             'output' => message,
             'timestamp' => timestamp.to_f }

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

@@ -43,7 +43,7 @@ module Actions
         host = Host.find(input[:host][:id])
         host.refresh_statuses
       rescue => e
-        Foreman::Logging.exception "Could not update execution status for #{input[:host][:name]}", e
+        ::Foreman::Logging.exception "Could not update execution status for #{input[:host][:name]}", e
       end
 
       def humanized_output
@@ -59,10 +59,13 @@ module Actions
         end
       end
 
+      def humanized_input
+        N_('%{description} on %{host}') % { :host => input[:host].try(:[], :name),
+                                            :description => input[:description].try(:capitalize) || input[:job_category] }
+      end
+
       def humanized_name
-        _('%{description} on %{host}') % { :job_category => input[:job_category],
-                                           :host => input[:host][:name],
-                                           :description => input[:description].try(:capitalize) || input[:job_category] }
+        N_('Remote action:')
       end
 
       def find_ip_or_hostname(host)

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

@@ -12,6 +12,7 @@ module Actions
       end
 
       def plan(job_invocation, locked = false)
+        set_up_concurrency_control job_invocation
         job_invocation.task_group.save! if job_invocation.task_group.try(:new_record?)
         task.add_missing_task_groups(job_invocation.task_group) if job_invocation.task_group
         action_subject(job_invocation) unless locked
@@ -34,6 +35,11 @@ module Actions
         end
       end
 
+      def set_up_concurrency_control(invocation)
+        limit_concurrency_level invocation.concurrency_level unless invocation.concurrency_level.nil?
+        distribute_over_time invocation.time_span unless invocation.time_span.nil?
+      end
+
       def rescue_strategy
         ::Dynflow::Action::Rescue::Skip
       end
@@ -42,6 +48,14 @@ module Actions
         super unless event == Dynflow::Action::Skip
       end
 
+      def humanized_input
+        input[:job_invocation][:description]
+      end
+
+      def humanized_name
+        '%s:' % _(super)
+      end
+
       private
 
       def determine_proxy(template_invocation, host, load_balancer)

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

@@ -62,7 +62,7 @@ module Actions
         proxy_data = proxy.status_of_task(output[:proxy_task_id])['actions'].detect { |action| action['class'] == proxy_action_name }
         proxy_data.fetch('output', {}).fetch('result', [])
       rescue => e
-        ::Foreman::Logging.exception("Failed to load data for task #{task.id} from proxy #{ input[:proxy_url] }", e)
+        ::Foreman::Logging.exception("Failed to load data for task #{task.id} from proxy #{input[:proxy_url]}", e)
         [exception_to_output(_('Error loading data from proxy'), e)]
       end
 
@@ -85,7 +85,7 @@ module Actions
 
       def final_timestamp(records)
         return task.ended_at if records.blank?
-        records.last.fetch('timestamp', task.ended_at) + 1
+        records.last.fetch('timestamp', task.ended_at).to_f + 1
       end
 
       def proxy_result

data/app/models/concerns/foreman_remote_execution/host_extensions.rb

@@ -12,7 +12,7 @@ module ForemanRemoteExecution
       has_many :template_invocations, :dependent => :destroy, :foreign_key => 'host_id'
       has_one :execution_status_object, :class_name => 'HostStatus::ExecutionStatus', :foreign_key => 'host_id'
 
-      scoped_search :in => :execution_status_object, :on => :status, :rename => :'execution_status',
+      scoped_search :in => :execution_status_object, :on => :status, :rename => :execution_status,
                     :complete_value => { :ok => HostStatus::ExecutionStatus::OK, :error => HostStatus::ExecutionStatus::ERROR }
     end
 
@@ -38,7 +38,7 @@ module ForemanRemoteExecution
       get_interface_by_flag(:execution)
     end
 
-    def remote_execution_proxies(provider)
+    def remote_execution_proxies(provider, authorized = true)
       proxies = {}
       proxies[:subnet]   = execution_interface.subnet.remote_execution_proxies.with_features(provider) if execution_interface && execution_interface.subnet
       proxies[:fallback] = smart_proxies.with_features(provider) if Setting[:remote_execution_fallback_proxy]
@@ -50,14 +50,15 @@ module ForemanRemoteExecution
                         proxy_scope = ::SmartProxy
                       end
 
-        proxies[:global] = proxy_scope.authorized.with_features(provider)
+        proxy_scope = proxy_scope.authorized if authorized
+        proxies[:global] = proxy_scope.with_features(provider)
       end
 
       proxies
     end
 
     def remote_execution_ssh_keys
-      remote_execution_proxies('SSH').values.flatten.uniq.map { |proxy| proxy.pubkey }.compact.uniq
+      remote_execution_proxies('SSH', false).values.flatten.uniq.map { |proxy| proxy.pubkey }.compact.uniq
     end
 
     def drop_execution_interface_cache

data/app/models/concerns/foreman_remote_execution/subnet_extensions.rb

@@ -5,6 +5,7 @@ module ForemanRemoteExecution
     included do
       has_many :target_remote_execution_proxies, :as => :target
       has_many :remote_execution_proxies, :dependent => :destroy, :through => :target_remote_execution_proxies
+      attr_accessible :remote_execution_proxies, :remote_execution_proxy_ids
     end
   end
 end

data/app/models/input_template_renderer.rb

@@ -2,6 +2,9 @@ class InputTemplateRenderer
   class UndefinedInput < ::Foreman::Exception
   end
 
+  class RenderError < ::Foreman::Exception
+  end
+
   include UnattendedHelper
 
   attr_accessor :template, :host, :invocation, :input_values, :error_message
@@ -22,7 +25,7 @@ class InputTemplateRenderer
 
   def render
     @template.validate_unique_inputs!
-    render_safe(@template.template, ::Foreman::Renderer::ALLOWED_HELPERS + [ :input, :render_template ], :host => @host)
+    render_safe(@template.template, ::Foreman::Renderer::ALLOWED_HELPERS + [ :input, :render_template, :preview?, :render_error ], :host => @host)
   rescue => e
     self.error_message ||= _('error during rendering: %s') % e.message
     Rails.logger.debug e.to_s + "\n" + e.backtrace.join("\n")
@@ -48,10 +51,14 @@ class InputTemplateRenderer
     end
   end
 
+  def render_error(message)
+    raise RenderError.new(message)
+  end
+
   def render_template(template_name, input_values = {}, options = {})
     options.assert_valid_keys(:with_foreign_input_set)
     with_foreign_input_set = options.fetch(:with_foreign_input_set, true)
-    template = JobTemplate.authorized(:view_job_templates).where(:name => template_name).first
+    template = JobTemplate.authorized(:view_job_templates).find_by(:name => template_name)
     unless template
       self.error_message = _('included template \'%s\' not found') % template_name
       raise error_message
@@ -69,8 +76,12 @@ class InputTemplateRenderer
     end
   end
 
+  def preview?
+    !!@preview
+  end
+
   def foreign_input_set_values(target_template, overrides = {})
-    input_set = @template.foreign_input_sets.where(:target_template_id => target_template).first
+    input_set = @template.foreign_input_sets.find_by(:target_template_id => target_template)
     return overrides if input_set.nil?
 
     inputs_to_generate = input_set.inputs.map(&:name) - overrides.keys.map(&:to_s)

data/app/models/job_invocation.rb

@@ -10,13 +10,8 @@ class JobInvocation < ActiveRecord::Base
 
   belongs_to :targeting, :dependent => :destroy
   has_many :all_template_invocations, :inverse_of => :job_invocation, :dependent => :destroy, :class_name => 'TemplateInvocation'
-  if Rails::VERSION::MAJOR >= 4
-    has_many :template_invocations, -> { where('host_id IS NOT NULL') }, :inverse_of => :job_invocation
-    has_many :pattern_template_invocations, -> { where('host_id IS NULL') }, :inverse_of => :job_invocation, :class_name => 'TemplateInvocation'
-  else
-    has_many :template_invocations, :conditions => 'host_id IS NOT NULL', :inverse_of => :job_invocation
-    has_many :pattern_template_invocations, :conditions => 'host_id IS NULL', :inverse_of => :job_invocation, :class_name => 'TemplateInvocation'
-  end
+  has_many :template_invocations, -> { where('host_id IS NOT NULL') }, :inverse_of => :job_invocation
+  has_many :pattern_template_invocations, -> { where('host_id IS NULL') }, :inverse_of => :job_invocation, :class_name => 'TemplateInvocation'
 
   validates :targeting, :presence => true
   validates :job_category, :presence => true
@@ -48,11 +43,7 @@ class JobInvocation < ActiveRecord::Base
   belongs_to :triggering, :class_name => 'ForemanTasks::Triggering'
   has_one :recurring_logic, :through => :triggering, :class_name => 'ForemanTasks::RecurringLogic'
 
-  if Rails::VERSION::MAJOR >= 4
-    scope :with_task, -> { references(:task) }
-  else
-    scope :with_task, -> { joins('LEFT JOIN foreman_tasks_tasks ON foreman_tasks_tasks.id = job_invocations.task_id') }
-  end
+  scope :with_task, -> { references(:task) }
 
   scoped_search :in => :recurring_logic, :on => 'id', :rename => 'recurring_logic.id', :auto_complete => true
 
@@ -112,7 +103,7 @@ class JobInvocation < ActiveRecord::Base
   end
 
   def to_action_input
-    { :id => id, :name => job_category }
+    { :id => id, :name => job_category, :description => description }
   end
 
   def failed_template_invocation_tasks
@@ -152,7 +143,7 @@ class JobInvocation < ActiveRecord::Base
   end
 
   def sub_task_for_host(host)
-    template_invocations.where(:host => host.id).first.try(:run_host_job_task)
+    template_invocations.find_by(:host => host.id).try(:run_host_job_task)
   end
 
   def output(host)
@@ -165,7 +156,7 @@ class JobInvocation < ActiveRecord::Base
     template_invocation = pattern_template_invocations.first
     input_names = template_invocation.template.template_inputs_with_foreign(&:name)
     hash_base = Hash.new { |hash, key| hash[key] = "%{#{key}}" }
-    input_hash = hash_base.merge Hash[input_names.zip(template_invocation.input_values.pluck(:value))]
+    input_hash = hash_base.merge Hash[input_names.zip(template_invocation.input_values.map(&:value))]
     input_hash.update(:job_category => job_category)
     input_hash.update(:template_name => template_invocation.template.name)
     description_format.scan(key_re) { |key| input_hash[key.first] }

data/app/models/job_invocation_composer.rb

@@ -12,6 +12,7 @@ class JobInvocationComposer
         :triggering => ui_params.fetch(:triggering, {}),
         :host_ids => ui_params[:host_ids],
         :description_format => job_invocation_base[:description_format],
+        :concurrency_control => concurrency_control_params,
         :template_invocations => template_invocations_params }.with_indifferent_access
     end
 
@@ -49,6 +50,13 @@ class JobInvocationComposer
         template_base
       end
     end
+
+    def concurrency_control_params
+      {
+        :time_span => job_invocation_base[:time_span],
+        :level => job_invocation_base[:concurrency_level]
+      }
+    end
   end
 
   class ApiParams
@@ -59,17 +67,14 @@ class JobInvocationComposer
     end
 
     def params
-      { :job_category => job_category,
+      { :job_category => template.job_category,
         :targeting => targeting_params,
         :triggering => triggering_params,
-        :description_format => api_params[:description_format] || template_with_default.generate_description_format,
+        :description_format => api_params[:description_format],
+        :concurrency_control => concurrency_control_params,
         :template_invocations => template_invocations_params }.with_indifferent_access
     end
 
-    def job_category
-      api_params[:job_category]
-    end
-
     def targeting_params
       raise ::Foreman::Exception, _('Cannot specify both bookmark_id and search_query') if api_params[:bookmark_id] && api_params[:search_query]
       api_params.slice(:targeting_type, :bookmark_id, :search_query).merge(:user_id => User.current.id)
@@ -98,8 +103,14 @@ class JobInvocationComposer
       end
     end
 
+    def concurrency_control_params
+      {
+        :level => api_params.fetch(:concurrency_control, {})[:concurrency_level],
+        :time_span => api_params.fetch(:concurrency_control, {})[:time_span]
+      }
+    end
+
     def template_invocations_params
-      template = template_with_default
       template_invocation_params = { :template_id => template.id, :effective_user => api_params[:effective_user] }
       template_invocation_params[:input_values] = api_params.fetch(:inputs, {}).map do |name, value|
         input = template.template_inputs_with_foreign.find { |i| i.name == name }
@@ -112,13 +123,8 @@ class JobInvocationComposer
       [template_invocation_params]
     end
 
-    def template_with_default
-      template = nil
-      templates = JobTemplate.authorized(:view_job_templates).where(:job_category => job_category)
-      template = templates.find(api_params[:job_template_id]) if api_params[:job_template_id]
-      template ||= templates.first if templates.count == 1
-      raise ::Foreman::Exception, _('Cannot determine the template to be used of job %s') % job_category unless template
-      return template
+    def template
+      @template ||= JobTemplate.authorized(:view_job_templates).find(api_params[:job_template_id])
     end
 
     private
@@ -141,11 +147,18 @@ class JobInvocationComposer
         :targeting => targeting_params,
         :triggering => triggering_params,
         :description_format => job_invocation.description_format,
+        :concurrency_control => concurrency_control_params,
         :template_invocations => template_invocations_params }.with_indifferent_access
     end
 
     private
 
+    def concurrency_control_params
+      {
+        :level => job_invocation.concurrency_level,
+        :time_span => job_invocation.time_span
+      }
+    end
 
     def targeting_params
       job_invocation.targeting.attributes.slice('search_query', 'bookmark_id', 'user_id', 'targeting_type')
@@ -164,6 +177,75 @@ class JobInvocationComposer
     end
   end
 
+  class ParamsForFeature
+    attr_reader :feature_label, :feature, :provided_inputs
+
+    def initialize(feature_label, hosts, provided_inputs = {})
+      @feature = RemoteExecutionFeature.feature(feature_label)
+      @provided_inputs = provided_inputs
+      if hosts.is_a? Bookmark
+        @host_bookmark = hosts
+      elsif hosts.is_a? Host::Base
+        @host_objects = [hosts]
+      elsif hosts.is_a? String
+        @host_scoped_search = hosts
+      else
+        @host_objects = hosts
+      end
+    end
+
+    def params
+      { :job_category => job_template.job_category,
+        :targeting => targeting_params,
+        :triggering => {},
+        :concurrency_control => {},
+        :template_invocations => template_invocations_params }.with_indifferent_access
+    end
+
+    private
+
+    def targeting_params
+      ret = {}
+      ret['targeting_type'] = Targeting::STATIC_TYPE
+      ret['search_query'] = @host_scoped_search if @host_scoped_search
+      ret['search_query'] = Targeting.build_query_from_hosts(@host_objects) if @host_objects
+      ret['bookmark_id'] = @host_bookmark.id if @host_bookmark
+      ret['user_id'] = User.current.id
+      ret
+    end
+
+    def template_invocations_params
+      [ { 'template_id' => job_template.id,
+          'input_values' => input_values_params } ]
+    end
+
+    def input_values_params
+      @provided_inputs.map do |key, value|
+        input = job_template.template_inputs_with_foreign.find { |i| i.name == key.to_s }
+        unless input
+          raise Foreman::Exception.new(N_('Feature input %{input_name} not defined in template %{template_name}'),
+                                       :input_name => key, :template_name => job_template.name)
+        end
+        { 'template_input_id' => input.id, 'value' => value }
+      end
+    end
+
+    def job_template
+      unless feature.job_template
+        raise Foreman::Exception.new(N_('No template mapped to feature %{feature_name}'),
+                                     :feature_name => feature.name)
+      end
+      template = JobTemplate.authorized(:view_job_templates).find_by_id(feature.job_template_id)
+
+      unless template
+        raise Foreman::Exception.new(N_('The template %{template_name} mapped to feature %{feature_name} is not accessible by the user'),
+                                     :template_name => template.name,
+                                     :feature_name => feature.name)
+      end
+      template
+    end
+  end
+
   attr_accessor :params, :job_invocation, :host_ids, :search_query
   delegate :job_category, :pattern_template_invocations, :template_invocations, :targeting, :triggering, :to => :job_invocation
 
@@ -190,6 +272,10 @@ class JobInvocationComposer
     self.new(ApiParams.new(api_params).params)
   end
 
+  def self.for_feature(feature_label, hosts, provided_inputs = {})
+    self.new(ParamsForFeature.new(feature_label, hosts, provided_inputs).params)
+  end
+
   def compose
     job_invocation.job_category = validate_job_category(params[:job_category])
     job_invocation.job_category ||= available_job_categories.first if @set_defaults
@@ -197,10 +283,26 @@ class JobInvocationComposer
     job_invocation.triggering = build_triggering
     job_invocation.pattern_template_invocations = build_template_invocations
     job_invocation.description_format = params[:description_format]
+    job_invocation.time_span = params[:concurrency_control][:time_span].to_i unless params[:concurrency_control][:time_span].blank?
+    job_invocation.concurrency_level = params[:concurrency_control][:level].to_i unless params[:concurrency_control][:level].blank?
 
     self
   end
 
+  def trigger(raise_on_error = false)
+    generate_description
+    if raise_on_error
+      save!
+    else
+      return false unless save
+    end
+    triggering.trigger(::Actions::RemoteExecution::RunHostsJob, job_invocation)
+  end
+
+  def trigger!
+    trigger(true)
+  end
+
   def valid?
     targeting.valid? & job_invocation.valid? & !pattern_template_invocations.map(&:valid?).include?(false)
   end
@@ -262,9 +364,9 @@ class JobInvocationComposer
     if @search_query.present?
       @search_query
     elsif host_ids.present?
-      targeting.build_query_from_hosts(host_ids)
+      Targeting.build_query_from_hosts(host_ids)
     elsif targeting.bookmark_id
-      if (bookmark = available_bookmarks.where(:id => targeting.bookmark_id).first)
+      if (bookmark = available_bookmarks.find_by(:id => targeting.bookmark_id))
         bookmark.query
       else
         ''
@@ -326,7 +428,7 @@ class JobInvocationComposer
     # when it's the same, we delete the query since it is used from bookmark
     # when no bookmark is set we store the query
     bookmark_id = params[:targeting][:bookmark_id]
-    bookmark = available_bookmarks.where(:id => bookmark_id).first
+    bookmark = available_bookmarks.find_by(:id => bookmark_id)
     query = params[:targeting][:search_query]
     if bookmark.present? && query.present?
       if query.strip == bookmark.query.strip
@@ -340,10 +442,10 @@ class JobInvocationComposer
     end
 
     Targeting.new(
-        :bookmark_id => bookmark_id,
-        :targeting_type => params[:targeting][:targeting_type],
-        :search_query => query
-    ) { |t| t.user_id =  params[:targeting][:user_id] }
+      :bookmark_id => bookmark_id,
+      :targeting_type => params[:targeting][:targeting_type],
+      :search_query => query
+    ) { |t| t.user_id = params[:targeting][:user_id] }
   end
 
   def build_triggering
@@ -361,6 +463,14 @@ class JobInvocationComposer
     end
   end
 
+  def generate_description
+    unless job_invocation.description_format
+      template = job_invocation.pattern_template_invocations.first.try(:template)
+      job_invocation.description_format = template.generate_description_format if template
+    end
+    job_invocation.generate_description! if job_invocation.description.blank?
+  end
+
   def build_effective_user(template_invocation_params)
     job_template = available_templates.find(template_invocation_params[:template_id])
     if job_template.effective_user.overridable? && template_invocation_params[:effective_user].present?