foreman_remote_execution 0.1.1 → 0.1.2

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

@@ -3,18 +3,21 @@ module Actions
     class RunHostsJob < Actions::ActionWithSubPlans
 
       middleware.use Actions::Middleware::BindJobInvocation
+      middleware.use Actions::Middleware::RecurringLogic
 
-      def delay(delay_options, job_invocation)
+      def delay(delay_options, job_invocation, locked = false)
+        task.add_missing_task_groups(job_invocation.task_group)
         job_invocation.targeting.resolve_hosts! if job_invocation.targeting.static?
-        action_subject(job_invocation)
-        super(delay_options, job_invocation, true)
+        super delay_options, job_invocation, locked
       end
 
-      def plan(job_invocation, locked = false, connection_options = {})
+      def plan(job_invocation, locked = false)
+        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
         job_invocation.targeting.resolve_hosts! if job_invocation.targeting.dynamic? || !locked
         input.update(:job_name => job_invocation.job_name)
-        plan_self(:job_invocation_id => job_invocation.id, :connection_options => connection_options)
+        plan_self(:job_invocation_id => job_invocation.id)
       end
 
       def create_sub_plans
@@ -24,7 +27,7 @@ module Actions
         job_invocation.targeting.hosts.map do |host|
           template_invocation = job_invocation.template_invocation_for_host(host)
           proxy = determine_proxy(template_invocation, host, load_balancer)
-          trigger(RunHostJob, job_invocation, host, template_invocation, proxy, input[:connection_options])
+          trigger(RunHostJob, job_invocation, host, template_invocation, proxy)
         end
       end
 

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

@@ -3,7 +3,7 @@ module ForemanRemoteExecution
     extend ActiveSupport::Concern
 
     included do
-      has_many :job_invocations, :dependent => :nullify, :foreign_key => 'last_task_id'
+      has_many :job_invocations, :dependent => :nullify, :foreign_key => 'task_id'
     end
   end
 end

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

@@ -0,0 +1,9 @@
+module ForemanRemoteExecution
+  module ForemanTasksTriggeringExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :job_invocation, :dependent => :nullify, :foreign_key => 'triggering_id'
+    end
+  end
+end

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

@@ -28,7 +28,9 @@ module ForemanRemoteExecution
       params = params_without_remote_execution
       keys = remote_execution_ssh_keys
       params['remote_execution_ssh_keys'] = keys unless keys.blank?
-      params['remote_execution_ssh_user'] = Setting[:remote_execution_ssh_user] unless params.key?('remote_execution_ssh_user')
+      [:remote_execution_ssh_user, :remote_execution_effective_user_method].each do |key|
+        params[key.to_s] = Setting[key] unless params.key?(key.to_s)
+      end
       params
     end
 

data/app/models/job_invocation.rb

@@ -15,20 +15,43 @@ class JobInvocation < ActiveRecord::Base
 
   scoped_search :on => :job_name
 
+  scoped_search :in => :recurring_logic, :on => 'id', :rename => 'recurring_logic.id', :auto_complete => true
+
   delegate :bookmark, :resolved?, :to => :targeting, :allow_nil => true
 
   include ForemanTasks::Concerns::ActionSubject
 
-  belongs_to :last_task, :class_name => 'ForemanTasks::Task'
-  has_many :sub_tasks, :through => :last_task
+  belongs_to :task, :class_name => 'ForemanTasks::Task'
+  has_many :sub_tasks, :through => :task
+
+  belongs_to :task_group, :class_name => 'JobInvocationTaskGroup'
+
+  has_many :tasks, :through => :task_group, :class_name => 'ForemanTasks::Task'
 
   scoped_search :on => [:job_name], :complete_value => true
 
-  attr_accessor :start_before
+  scoped_search :in => :task, :on => :started_at, :rename => 'started_at', :complete_value => true
+  scoped_search :in => :task, :on => :ended_at, :rename => 'ended_at', :complete_value => true
+
+  belongs_to :triggering, :class_name => 'ForemanTasks::Triggering'
+  has_one :recurring_logic, :through => :triggering, :class_name => 'ForemanTasks::RecurringLogic'
+
+  scope :with_task, -> { joins('LEFT JOIN foreman_tasks_tasks ON foreman_tasks_tasks.id = job_invocations.task_id') }
+
+  default_scope -> { order('job_invocations.id DESC') }
+
+  attr_accessor :start_before, :description_format
   attr_writer :start_at
 
-  def self.allowed_trigger_modes
-    %w(immediate future)
+  def deep_clone
+    JobInvocationComposer.from_job_invocation(self).job_invocation.tap do |invocation|
+      invocation.task_group = JobInvocationTaskGroup.new.tap(&:save!)
+      invocation.triggering = self.triggering
+      invocation.description_format = self.description_format
+      invocation.description = self.description
+      invocation.template_invocations = self.template_invocations.map(&:deep_clone)
+      invocation.save!
+    end
   end
 
   def to_action_input
@@ -63,42 +86,6 @@ class JobInvocation < ActiveRecord::Base
     end
   end
 
-  def delay_options
-    {
-      :start_at => start_at_parsed,
-      :start_before => start_before_parsed
-    }
-  end
-
-  def trigger_mode
-    @trigger_mode || :immediate
-  end
-
-  def trigger_mode=(value)
-    return trigger_mode if @trigger_mode || value.nil?
-    if JobInvocation.allowed_trigger_modes.include?(value)
-      @trigger_mode = value.to_sym
-    else
-      raise ::Foreman::Exception, _("Job Invocation trigger mode must be one of [#{JobInvocation.allowed_trigger_modes.join(', ')}]")
-    end
-  end
-
-  def start_at_parsed
-    @start_at.present? && Time.strptime(@start_at, time_format)
-  end
-
-  def start_at
-    @start_at ||= Time.now.strftime(time_format)
-  end
-
-  def start_before_parsed
-    @start_before.present? && Time.strptime(@start_before, time_format) || nil
-  end
-
-  def time_format
-    '%Y-%m-%d %H:%M'
-  end
-
   def template_invocation_for_host(host)
     providers = available_providers(host)
     providers.each do |provider|
@@ -118,4 +105,24 @@ class JobInvocation < ActiveRecord::Base
   def sub_task_for_host(host)
     sub_tasks.joins(:locks).where("#{ForemanTasks::Lock.table_name}.resource_type" => 'Host::Managed', "#{ForemanTasks::Lock.table_name}.resource_id" => host.id).first
   end
+
+  def output(host)
+    return unless (task = sub_task_for_host(host)) && task.main_action && task.main_action.live_output.any?
+    task.main_action.live_output.first['output']
+  end
+
+  def generate_description!
+    key_re = /%\{([^\}]+)\}/
+    template_invocation = template_invocations.first
+    input_names = template_invocation.template.template_input_names
+    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.update(:job_name => job_name)
+    description_format.scan(key_re) { |key| input_hash[key.first] }
+    self.description = description_format
+    input_hash.each do |k, v|
+      self.description.gsub!(Regexp.new("%\{#{k}\}"), v)
+    end
+    save!
+  end
 end

data/app/models/job_invocation_composer.rb

@@ -1,38 +1,174 @@
 class JobInvocationComposer
-  attr_accessor :params, :job_invocation, :host_ids, :search_query
-  attr_reader :job_template_ids
-  delegate :job_name, :targeting, :to => :job_invocation
 
-  def initialize(job_invocation = JobInvocation.new)
-    @job_invocation = job_invocation
+  class UiParams
+    attr_reader :ui_params
+    def initialize(ui_params)
+      @ui_params = ui_params
+    end
+
+    def params
+      { :job_name => job_invocation_base[:job_name],
+        :targeting => ui_params.fetch(:targeting, {}).merge(:user_id => User.current.id),
+        :triggering => ui_params.fetch(:triggering, {}),
+        :host_ids => ui_params[:host_ids],
+        :description_format => job_invocation_base[:description_format],
+        :template_invocations => template_invocations_params }.with_indifferent_access
+    end
+
+    def job_invocation_base
+      ui_params.fetch(:job_invocation, {})
+    end
+
+    def providers_base
+      job_invocation_base.fetch(:providers, {})
+    end
+
+    # parses params to get job templates in form of id => attributes for selected job templates, e.g.
+    # {
+    #   "459" => {},
+    #   "454" => {
+    #     "input_values" => {
+    #       "2" => {
+    #         "value" => ""
+    #       },
+    #       "5" => {
+    #         "value" => ""
+    #       }
+    #     }
+    #   }
+    # }
+    def template_invocations_params
+      providers_base.values.map do |template_params|
+        template_base = (template_params.fetch(:job_templates, {}).fetch(template_params[:job_template_id], {})).dup.with_indifferent_access
+        template_base[:template_id] = template_params[:job_template_id]
+        input_values_params = template_base.fetch(:input_values, {})
+        template_base[:input_values] = input_values_params.map do |id, values|
+          values.merge(:template_input_id => id)
+        end
+
+        template_base
+      end
+    end
+  end
+
+  class ApiParams
+    attr_reader :api_params
+
+    def initialize(api_params)
+      @api_params = api_params
+    end
+
+    def params
+      { :job_name => job_name,
+        :targeting => targeting_params,
+        :triggering => {},
+        :description_format => api_params[:description_format] || template_with_default.generate_description_format,
+        :template_invocations => template_invocations_params }.with_indifferent_access
+    end
+
+    def job_name
+      api_params[:job_name]
+    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)
+    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.find_by_name(name)
+        unless input
+          raise ::Foreman::Exception, _('Unknown input %{input_name} for template %{template_name}') %
+              { :input_name => name, :template_name => template.name }
+        end
+        { :template_input_id => input.id, :value => value }
+      end
+      [template_invocation_params]
+    end
+
+    def template_with_default
+      template = nil
+      templates = JobTemplate.authorized(:view_job_templates).where(:job_name => job_name)
+      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_name unless template
+      return template
+    end
+
   end
 
-  def compose_from_params(params)
+  class ParamsFromJobInvocation
+    attr_reader :job_invocation
+
+    def initialize(job_invocation)
+      @job_invocation = job_invocation
+    end
+
+    def params
+      { :job_name => job_invocation.job_name,
+        :targeting => targeting_params,
+        :triggering => triggering_params,
+        :description_format => job_invocation.description_format,
+        :template_invocations => template_invocations_params }.with_indifferent_access
+    end
+
+    private
+
+
+    def targeting_params
+      job_invocation.targeting.attributes.slice('search_query', 'bookmark_id', 'user_id', 'targeting_type')
+    end
+
+    def template_invocations_params
+      job_invocation.template_invocations.map do |template_invocation|
+        params = template_invocation.attributes.slice('template_id', 'effective_user')
+        params['input_values'] = template_invocation.input_values.map { |v| v.attributes.slice('template_input_id', 'value') }
+        params
+      end
+    end
+
+    def triggering_params
+      ForemanTasks::Triggering.new_from_params.attributes.slice("mode", "start_at", "start_before")
+    end
+  end
+
+  attr_accessor :params, :job_invocation, :host_ids, :search_query
+  delegate :job_name, :template_invocations, :targeting, :triggering, :to => :job_invocation
+
+  def initialize(params, set_defaults = false)
     @params = params
+    @set_defaults = set_defaults
+    @job_invocation = JobInvocation.new
+    @job_invocation.task_group = JobInvocationTaskGroup.new
+    compose
 
     @host_ids = validate_host_ids(params[:host_ids])
-    @search_query = targeting_base[:search_query]
+    @search_query = job_invocation.targeting.search_query unless job_invocation.targeting.bookmark_id.present?
+  end
 
-    job_invocation.job_name = validate_job_name(job_invocation_base[:job_name])
-    job_invocation.job_name ||= available_job_names.first if job_invocation.new_record?
-    job_invocation.targeting = build_targeting
-    job_invocation.trigger_mode = job_invocation_base[:trigger_mode]
-    job_invocation.start_at = job_invocation_base[:start_at]
-    job_invocation.start_before = job_invocation_base[:start_before]
+  def self.from_job_invocation(job_invocation)
+    self.new(ParamsFromJobInvocation.new(job_invocation).params)
+  end
 
-    @job_template_ids = validate_job_template_ids(job_templates_base.keys.compact)
-    self
+  def self.from_ui_params(ui_params)
+    self.new(UiParams.new(ui_params).params, true)
   end
 
-  def compose_from_invocation(invocation)
-    @params = {}
+  def self.from_api_params(api_params)
+    self.new(ApiParams.new(api_params).params)
+  end
 
-    job_invocation.job_name = validate_job_name(invocation.job_name)
-    job_invocation.targeting = invocation.targeting.dup
-    @search_query = targeting.search_query unless targeting.bookmark_id.present?
+  def compose
+    job_invocation.job_name = validate_job_name(params[:job_name])
+    job_invocation.job_name ||= available_job_names.first if @set_defaults
+    job_invocation.targeting = build_targeting
+    job_invocation.triggering = build_triggering
+    job_invocation.template_invocations = build_template_invocations
+    job_invocation.description_format = params[:description_format]
 
-    @job_template_ids = invocation.template_invocations.map(&:template_id)
-    @template_invocations = dup_template_invocations(invocation)
     self
   end
 
@@ -44,6 +180,14 @@ class JobInvocationComposer
     valid? && job_invocation.save
   end
 
+  def save!
+    if valid?
+      job_invocation.save!
+    else
+      raise job_invocation.flattened_validation_exception
+    end
+  end
+
   def available_templates
     JobTemplate.authorized(:view_job_templates)
   end
@@ -61,7 +205,7 @@ class JobInvocationComposer
   end
 
   def available_template_inputs
-    TemplateInput.where(:template_id => job_template_ids.nil? ? available_templates_for(job_name).map(&:id) : job_template_ids)
+    TemplateInput.where(:template_id => job_template_ids.empty? ? available_templates_for(job_name).map(&:id) : job_template_ids)
   end
 
   def needs_provider_type_selection?
@@ -89,15 +233,6 @@ class JobInvocationComposer
     (templates_for_provider(provider_type) & selected_job_templates).empty?
   end
 
-  def template_invocations
-    if job_invocation.new_record?
-      @template_invocations ||= build_template_invocations
-    else
-      job_invocation.template_invocations
-      # TODO update if base present? that would solve updating
-    end
-  end
-
   def displayed_search_query
     if @search_query.present?
       @search_query
@@ -132,6 +267,10 @@ class JobInvocationComposer
     0
   end
 
+  def template_invocation(job_template)
+    template_invocations.find { |invocation| invocation.template == job_template }
+  end
+
   def template_invocation_input_value_for(input)
     invocations = template_invocations
     default = TemplateInvocationInputValue.new
@@ -142,55 +281,26 @@ class JobInvocationComposer
     end
   end
 
+  def job_template_ids
+    job_invocation.template_invocations.map(&:template_id)
+  end
+
   private
 
   def dup_template_invocations(job_invocation)
     job_invocation.template_invocations.map do |template_invocation|
       duplicate = template_invocation.dup
       template_invocation.input_values.map { |value| duplicate.input_values.build :value => value.value, :template_input_id => value.template_input_id }
+      duplicate.effective_user = template_invocation.effective_user
       duplicate
     end
   end
 
-  def targeting_base
-    @params.fetch(:targeting, {})
-  end
-
-  def job_invocation_base
-    @params.fetch(:job_invocation, {})
-  end
-
-  def input_values_base
-    @params.fetch(:input_values, [])
-  end
-
-  def providers_base
-    job_invocation_base.fetch(:providers, {})
-  end
-
-  # parses params to get job templates in form of id => attributes for selected job templates, e.g.
-  # {
-  #   "459" => {},
-  #   "454" => {
-  #     "input_values" => {
-  #       "2" => {
-  #         "value" => ""
-  #       },
-  #       "5" => {
-  #         "value" => ""
-  #       }
-  #     }
-  #   }
-  # }
-  def job_templates_base
-    Hash[providers_base.values.map { |jt| [jt['job_template_id'], (jt['job_templates'] || {})[jt['job_template_id']] || {}] }]
-  end
-
   # builds input values for a given templates id based on params
   # omits inputs that belongs to unavailable templates
-  def build_input_values_for(job_template_id)
-    job_templates_base[job_template_id.to_s].fetch('input_values', {}).map do |input_id, attributes|
-      input = available_template_inputs.find_by_id(input_id)
+  def build_input_values_for(job_template_base)
+    job_template_base.fetch('input_values', {}).map do |attributes|
+      input = available_template_inputs.find_by_id(attributes[:template_input_id])
       input ? input.template_invocation_input_values.build(attributes) : nil
     end.compact
   end
@@ -199,9 +309,9 @@ class JobInvocationComposer
     # if bookmark was used we compare it to search query,
     # 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 = targeting_base[:bookmark_id]
+    bookmark_id = params[:targeting][:bookmark_id]
     bookmark = available_bookmarks.where(:id => bookmark_id).first
-    query = targeting_base[:search_query]
+    query = params[:targeting][:search_query]
     if bookmark.present? && query.present?
       if query.strip == bookmark.query.strip
         query = nil
@@ -209,26 +319,41 @@ class JobInvocationComposer
         bookmark_id = nil
       end
     elsif query.present?
-      query = targeting_base[:search_query]
+      query = params[:targeting][:search_query]
       bookmark_id = nil
     end
 
     Targeting.new(
-      :user => User.current,
-      :bookmark_id => bookmark_id,
-      :targeting_type => targeting_base[:targeting_type],
-      :search_query => query
-    )
+        :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
+    ::ForemanTasks::Triggering.new_from_params(params[:triggering])
   end
 
   def build_template_invocations
-    job_template_ids.map do |job_template_id|
-      template_invocation = job_invocation.template_invocations.build(:template_id => job_template_id)
-      template_invocation.input_values = build_input_values_for(job_template_id)
+    valid_template_ids = validate_job_template_ids(params[:template_invocations].map { |t| t[:template_id] })
+
+    params[:template_invocations].select { |t| valid_template_ids.include?(t[:template_id].to_i) }.map do |template_invocation_params|
+      template_invocation = job_invocation.template_invocations.build(:template_id => template_invocation_params[:template_id],
+                                                                      :effective_user => build_effective_user(template_invocation_params))
+      template_invocation.input_values = build_input_values_for(template_invocation_params)
       template_invocation
     end
   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?
+      template_invocation_params[:effective_user]
+    else
+      job_template.effective_user.compute_value
+    end
+  end
+
   # returns nil if user can't see any job template with such name
   # existing job_name string otherwise
   def validate_job_name(name)

data/app/models/job_invocation_task_group.rb

@@ -0,0 +1,18 @@
+class JobInvocationTaskGroup < ::ForemanTasks::TaskGroup
+
+  has_one :job_invocation, :foreign_key => :task_group_id
+
+  alias_method :resource, :job_invocation
+
+  def resource_name
+    N_('Job Invocation')
+  end
+
+  def self.search_query_for(thing)
+    case thing
+    when ::ForemanTasks::RecurringLogic
+      "recurring_logic.id = #{thing.id}"
+    end
+  end
+
+end

data/app/models/job_template.rb

@@ -1,5 +1,6 @@
 class JobTemplate < ::Template
-  attr_accessible :job_name, :provider_type
+
+  attr_accessible :job_name, :provider_type, :description_format, :effective_user_attributes
 
   include Authorizable
   extend FriendlyId
@@ -31,6 +32,8 @@ class JobTemplate < ::Template
   validates :job_name, :presence => true, :unless => ->(job_template) { job_template.snippet }
   validates :provider_type, :presence => true
   validate :provider_type_whitelist
+  has_one :effective_user, :class_name => 'JobTemplateEffectiveUser', :foreign_key => 'job_template_id', :dependent => :destroy
+  accepts_nested_attributes_for :effective_user, :update_only => true
 
   # we have to override the base_class because polymorphic associations does not detect it correctly, more details at
   # http://apidock.com/rails/ActiveRecord/Associations/ClassMethods/has_many#1010-Polymorphic-has-many-within-inherited-class-gotcha
@@ -77,6 +80,27 @@ class JobTemplate < ::Template
     end
   end
 
+  def provider
+    RemoteExecutionProvider.provider_for(provider_type)
+  end
+
+  def effective_user
+    super || (build_effective_user.tap(&:set_defaults))
+  end
+
+  def generate_description_format
+    if description_format.blank?
+      generated_description = '%{job_name}'
+      unless template_inputs.empty?
+        inputs = template_inputs.map(&:name).map { |name| %Q(#{name}="%{#{name}}") }.join(' ')
+        generated_description << " with inputs #{inputs}"
+      end
+      generated_description
+    else
+      description_format
+    end
+  end
+
   private
 
   def self.parse_metadata(template)

data/app/models/job_template_effective_user.rb

@@ -0,0 +1,23 @@
+class JobTemplateEffectiveUser < ActiveRecord::Base
+
+  belongs_to :job_template
+
+  before_validation :set_defaults
+
+  belongs_to :job_template
+
+  def set_defaults
+    self.overridable = true if self.overridable.nil?
+    self.current_user = false if self.current_user.nil?
+  end
+
+  def compute_value
+    if current_user?
+      User.current.login
+    elsif value.present?
+      value
+    else
+      Setting[:remote_execution_effective_user]
+    end
+  end
+end

data/app/models/remote_execution_provider.rb

@@ -1,17 +1,31 @@
 class RemoteExecutionProvider
-  def self.provider_for(type)
-    providers[type.to_s] || providers[:Ssh]
-  end
+  class << self
+    def provider_for(type)
+      providers[type.to_s] || providers[:Ssh]
+    end
 
-  def self.providers
-    @providers ||= { :Ssh => N_(SSHExecutionProvider) }.with_indifferent_access
-  end
+    def providers
+      @providers ||= { }.with_indifferent_access
+    end
 
-  def self.register(key, klass)
-    providers[key.to_sym] = klass
-  end
+    def register(key, klass)
+      providers[key.to_sym] = klass
+    end
+
+    def provider_names
+      providers.keys.map(&:to_s)
+    end
+
+    def proxy_command_options(template_invocation, host)
+      {}
+    end
+
+    def humanized_name
+      self.name
+    end
 
-  def self.provider_names
-    providers.keys.map(&:to_s)
+    def supports_effective_user?
+      false
+    end
   end
 end