foreman_remote_execution 0.0.1

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

@@ -0,0 +1,9 @@
+module ForemanRemoteExecution
+  module ForemanTasksTaskExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :job_invocations, :dependent => :nullify, :foreign_key => 'last_task_id'
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module ForemanRemoteExecution
+  module HostExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :targeting_hosts, :dependent => :destroy, :foreign_key => 'host_id'
+    end
+
+    # create or overwrite instance methods...
+    def instance_method_name
+    end
+
+    module ClassMethods
+      # create or overwrite class methods...
+      def class_method_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module ForemanRemoteExecution
+  module TemplateExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      accepts_nested_attributes_for :template_inputs, :allow_destroy => true
+      attr_accessible :template_inputs_attributes
+    end
+
+    # create or overwrite instance methods...
+    # def instance_method_name
+    # end
+
+    # module ClassMethods
+    #   # create or overwrite class methods...
+    #   def class_method_name
+    #   end
+    # end
+  end
+end

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

@@ -0,0 +1,10 @@
+module ForemanRemoteExecution
+  module TemplateRelations
+    extend ActiveSupport::Concern
+
+    included do
+      # autosave => true is required so the changes of inputs are saved even if template was not changed
+      has_many :template_inputs, :dependent => :destroy, :foreign_key => 'template_id', :autosave => true
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module ForemanRemoteExecution
+  module UserExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :targetings, :dependent => :nullify
+    end
+  end
+end

data/app/models/input_template_renderer.rb

@@ -0,0 +1,42 @@
+class InputTemplateRenderer
+  class UndefinedInput < ::Foreman::Exception
+  end
+
+  include UnattendedHelper
+
+  attr_accessor :template, :host, :invocation, :error_message
+
+  # takes template object that should be rendered
+  # host and template invocation arguments are optional
+  # so we can render values based on parameters, facts or user inputs
+  def initialize(template, host = nil, invocation = nil)
+    @host = host
+    @invocation = invocation
+    @template = template
+  end
+
+  def render
+    render_safe(@template.template, [ :input ], :host => @host)
+  rescue => e
+    self.error_message ||= _('error during rendering: %s') % e.message
+    Rails.logger.debug e.to_s + "\n" + e.backtrace.join("\n")
+    return false
+  end
+
+  def preview
+    @preview = true
+    output = render
+    @preview = false
+    output
+  end
+
+  def input(name)
+    input = @template.template_inputs.where(:name => name.to_s).first || @template.template_inputs.detect { |i| i.name == name.to_s }
+    if input
+      @preview ? input.preview(self) : input.value(self)
+    else
+      self.error_message = _('input macro with name \'%s\' used, but no input with such name defined for this template') % name
+      raise UndefinedInput, "Rendering failed, no input with name #{name} for input macro found"
+    end
+  end
+end

data/app/models/job_invocation.rb

@@ -0,0 +1,21 @@
+class JobInvocation < ActiveRecord::Base
+  include Authorizable
+
+  belongs_to :targeting, :dependent => :destroy
+  has_many :template_invocations, :inverse_of => :job_invocation, :dependent => :destroy
+
+  validates :targeting, :presence => true
+  validates :job_name, :presence => true
+
+  delegate :bookmark, :to => :targeting, :allow_nil => true
+
+  include ForemanTasks::Concerns::ActionSubject
+
+  belongs_to :last_task, :class_name => 'ForemanTasks::Task'
+
+  scoped_search :on => [:job_name], :complete_value => true
+
+  def to_action_input
+    { :id => id, :name => job_name }
+  end
+end

data/app/models/job_invocation_composer.rb

@@ -0,0 +1,210 @@
+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, params)
+    @job_invocation = job_invocation
+    @params = params
+
+    @host_ids = validate_host_ids(params[:host_ids])
+    @search_query = targeting_base[:search_query]
+
+    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_template_ids = validate_job_template_ids(job_templates_base.keys.compact)
+  end
+
+  def valid?
+    targeting.valid? & job_invocation.valid? & !template_invocations.map(&:valid?).include?(false)
+  end
+
+  def save
+    valid? && job_invocation.save
+  end
+
+  def available_templates
+    JobTemplate.authorized(:view_job_templates)
+  end
+
+  def available_templates_for(job_name)
+    available_templates.where(:job_name => job_name)
+  end
+
+  def available_job_names
+    available_templates.reorder(:job_name).group(:job_name).pluck(:job_name)
+  end
+
+  def available_provider_types
+    available_templates_for(job_name).reorder(:provider_type).group(:provider_type).pluck(:provider_type)
+  end
+
+  def available_template_inputs
+    TemplateInput.where(:template_id => job_template_ids.nil? ? available_templates_for(job_name).map(&:id) : job_template_ids)
+  end
+
+  def needs_provider_type_selection?
+    available_provider_types.size > 1
+  end
+
+  def only_one_template_available?
+    !needs_provider_type_selection? && templates_for_provider(available_provider_types.first).size == 1
+  end
+
+  def displayed_provider_types
+    # TODO available_provider_types based on targets
+    available_provider_types
+  end
+
+  def templates_for_provider(provider_type)
+    available_templates_for(job_name).select { |t| t.provider_type == provider_type }
+  end
+
+  def selected_job_templates
+    available_templates_for(job_name).where(:id => job_template_ids)
+  end
+
+  def preselect_disabled_for_provider(provider_type)
+    (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
+    elsif host_ids.present?
+      targeting.build_query_from_hosts(host_ids)
+    elsif targeting.bookmark_id
+      if (bookmark = available_bookmarks.where(:id => targeting.bookmark_id).first)
+        bookmark.query
+      else
+        ''
+      end
+    else
+      ''
+    end
+  end
+
+  def available_bookmarks
+    Bookmark.authorized(:view_bookmarks).my_bookmarks
+  end
+
+  def targeted_hosts_count
+    Host.authorized(:view_hosts, Host).search_for(displayed_search_query).count
+  rescue
+    0
+  end
+
+  def template_invocation_input_value_for(input)
+    invocations = template_invocations
+    default = TemplateInvocationInputValue.new
+    if (invocation = invocations.detect { |i| i.template_id == input.template_id })
+      invocation.input_values.detect { |iv| iv.template_input_id == input.id } || default
+    else
+      default
+    end
+  end
+
+  private
+
+  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)
+      input ? input.template_invocation_input_values.build(attributes) : nil
+    end.compact
+  end
+
+  def build_targeting
+    # 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 = available_bookmarks.where(:id => bookmark_id).first
+    query = targeting_base[:search_query]
+    if bookmark.present? && query.present?
+      if query.strip == bookmark.query.strip
+        query = nil
+      else
+        bookmark_id = nil
+      end
+    elsif query.present?
+      query = targeting_base[:search_query]
+      bookmark_id = nil
+    end
+
+    Targeting.new(
+      :user => User.current,
+      :bookmark_id => bookmark_id,
+      :targeting_type => targeting_base[:targeting_type],
+      :search_query => query
+    )
+  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)
+      template_invocation
+    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)
+    available_job_names.include?(name) ? name : nil
+  end
+
+  def validate_job_template_ids(ids)
+    available_templates_for(job_name).where(:id => ids).pluck(:id)
+  end
+
+  def validate_host_ids(ids)
+    Host.authorized(:view_hosts, Host).where(:id => ids).pluck(:id)
+  end
+end

data/app/models/job_template.rb

@@ -0,0 +1,52 @@
+class JobTemplate < ::Template
+  attr_accessible :job_name, :provider_type
+
+  include Authorizable
+  extend FriendlyId
+  friendly_id :name
+  include Parameterizable::ByIdName
+
+  audited :allow_mass_assignment => true
+  has_many :audits, :as => :auditable, :class_name => Audited.audit_class.name
+
+  # these can't be shared in parent class, scoped search can't handle STI properly
+  # tested with scoped_search 3.2.0
+  include Taxonomix
+  scoped_search :on => :name, :complete_value => true, :default_order => true
+  scoped_search :on => :job_name, :complete_value => true
+  scoped_search :on => :locked, :complete_value => {:true => true, :false => false}
+  scoped_search :on => :snippet, :complete_value => {:true => true, :false => false}
+  scoped_search :on => :provider_type, :complete_value => true
+  scoped_search :on => :template
+
+  # with proc support, default_scope can no longer be chained
+  # include all default scoping here
+  default_scope lambda {
+                  with_taxonomy_scope do
+                    order("#{Template.table_name}.name")
+                  end
+                }
+
+  validates :provider_type, :presence => true
+  validate :provider_type_whitelist
+
+  # 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
+  def self.base_class
+    self
+  end
+  self.table_name = 'templates'
+
+  # Override method in Taxonomix as Template is not used attached to a Host,
+  # and matching a Host does not prevent removing a template from its taxonomy.
+  def used_taxonomy_ids(type)
+    []
+  end
+
+  private
+
+  # we can't use standard validator, .provider_names output can change but the validator does not reflect it
+  def provider_type_whitelist
+    errors.add :provider_type, :uniq unless RemoteExecutionProvider.provider_names.include?(self.provider_type)
+  end
+end

data/app/models/remote_execution_provider.rb

@@ -0,0 +1,17 @@
+class RemoteExecutionProvider
+  def self.provider_for(type)
+    providers[type.to_s] || providers[:Ssh]
+  end
+
+  def self.providers
+    @providers ||= { :Ssh => N_(SSHExecutionProvider) }.with_indifferent_access
+  end
+
+  def self.register(key, klass)
+    providers[key.to_sym] = klass
+  end
+
+  def self.provider_names
+    providers.keys.map(&:to_s)
+  end
+end

data/app/models/setting/remote_execution.rb

@@ -0,0 +1,19 @@
+class Setting::RemoteExecution < Setting
+
+  def self.load_defaults
+    # Check the table exists
+    return unless super
+
+    self.transaction do
+      [
+        self.set('remote_execution_global_proxy',
+                 N_("Allows searching for remote execution proxy outside of the proxies assigned to the host: useful when missing the host proxies associations"),
+                 false),
+      ].each { |s| self.create! s.update(:category => "Setting::RemoteExecution") }
+    end
+
+    true
+
+  end
+
+end

data/app/models/ssh_execution_provider.rb

@@ -0,0 +1,2 @@
+class SSHExecutionProvider < RemoteExecutionProvider
+end

data/app/models/targeting.rb

@@ -0,0 +1,56 @@
+class Targeting < ActiveRecord::Base
+
+  STATIC_TYPE = 'static_query'
+  DYNAMIC_TYPE = 'dynamic_query'
+  TYPES = { STATIC_TYPE => N_('Static Query'), DYNAMIC_TYPE => N_('Dynamic Query') }
+
+  belongs_to :user
+  belongs_to :bookmark
+
+  has_many :targeting_hosts, :dependent => :destroy
+  has_many :hosts, :through => :targeting_hosts
+  has_one :job_invocation
+  has_many :template_invocations, :through => :job_invocation
+
+  validates :targeting_type, :presence => true, :inclusion => Targeting::TYPES.keys
+  validate :bookmark_or_query_is_present
+
+  attr_accessible :targeting_type, :bookmark_id, :user, :search_query
+
+  before_create :assign_search_query, :if => :static?
+
+  def resolve_hosts!
+    raise ::Foreman::Exception, _('Cannot resolve hosts without a user') if user.nil?
+    raise ::Foreman::Exception, _('Cannot resolve hosts without a bookmark or search query') if bookmark.nil? && search_query.blank?
+
+    self.search_query = bookmark.query if dynamic? && bookmark.present?
+    self.touch(:resolved_at)
+    self.save!
+    self.hosts = User.as(user.login) { Host.authorized('edit_hosts', Host).search_for(search_query) }
+  end
+
+  def dynamic?
+    targeting_type == DYNAMIC_TYPE
+  end
+
+  def static?
+    targeting_type == STATIC_TYPE
+  end
+
+  def build_query_from_hosts(ids)
+    hosts = Host.where(:id => ids).all.group_by(&:id)
+    ids.map { |id| "name = #{hosts[id].first.name}" }.join(' or ')
+  end
+
+  private
+
+  def bookmark_or_query_is_present
+    if bookmark.nil? && search_query.nil?
+      errors.add :base, _('Bookmark or search query can\'t be nil')
+    end
+  end
+
+  def assign_search_query
+    self.search_query = bookmark.query if static? && bookmark
+  end
+end

data/app/models/targeting_host.rb

@@ -0,0 +1,9 @@
+class TargetingHost < ActiveRecord::Base
+
+  belongs_to :targeting
+  belongs_to_host
+
+  validates :targeting, :presence => true
+  validates :host, :presence => true
+
+end

data/app/models/template_input.rb

@@ -0,0 +1,154 @@
+class TemplateInput < ActiveRecord::Base
+  class ValueNotReady < ::Foreman::Exception
+  end
+
+  TYPES = { :user => N_('User input'), :fact => N_('Fact value'), :variable => N_('Variable'),
+            :puppet_parameter => N_('Puppet parameter') }.with_indifferent_access
+
+  attr_accessible :name, :required, :input_type, :fact_name, :variable_name,
+                  :puppet_class_name, :puppet_parameter_name, :description, :job_template_id
+
+  belongs_to :template
+  has_many :template_invocation_input_values, :dependent => :destroy
+
+  validates :name, :presence => true, :uniqueness => { :scope => 'template_id' }
+  validates :input_type, :presence => true, :inclusion => TemplateInput::TYPES.keys
+
+  validates :fact_name, :presence => { :if => :fact_template_input? }
+  validates :variable_name, :presence => { :if => :variable_template_input? }
+  validates :puppet_parameter_name, :puppet_class_name, :presence => { :if => :puppet_parameter_template_input? }
+
+  def user_template_input?
+    input_type == 'user'
+  end
+
+  def fact_template_input?
+    input_type == 'fact'
+  end
+
+  def variable_template_input?
+    input_type == 'variable'
+  end
+
+  def puppet_parameter_template_input?
+    input_type == 'puppet_parameter'
+  end
+
+  def preview(renderer)
+    get_resolver(renderer).preview
+  end
+
+  def value(renderer)
+    get_resolver(renderer).value
+  end
+
+  private
+
+  def get_resolver(renderer)
+    resolver_class = case input_type
+      when 'user'
+        UserInputResolver
+      when 'fact'
+        FactInputResolver
+      when 'variable'
+        VariableInputResolver
+      when 'puppet_parameter'
+        PuppetParameterInputResolver
+      else
+        raise "unknown template input type #{input_type.inspect}"
+      end
+    resolver_class.new(self, renderer)
+  end
+
+  class InputResolver
+    def initialize(input, renderer)
+      @input = input
+      @renderer = renderer
+    end
+
+    def preview
+      ready? ? resolved_value : preview_value
+    end
+
+    def value
+      ready? ? resolved_value : raise(ValueNotReady, "Input '#{@input.name}' is not ready for rendering")
+    end
+
+    def preview_value
+      "$#{@input.input_type.upcase}_INPUT[#{@input.name}]"
+    end
+
+    # should be defined in descendants
+    def ready?
+      raise NotImplementedError
+    end
+
+    # should be defined in descendants
+    def resolved_value
+      raise NotImplementedError
+    end
+  end
+
+  class UserInputResolver < InputResolver
+    def ready?
+      !input_value.nil?
+    end
+
+    def resolved_value
+      input_value.value
+    end
+
+    private
+
+    def input_value
+      return unless @renderer.invocation
+      @renderer.invocation.input_values.find { |value| value.template_input_name == @input.name }
+    end
+  end
+
+  class FactInputResolver < InputResolver
+    # fact might not be present if it hasn't been uploaded yet, there's typo in name
+    def ready?
+      @renderer.host && get_fact.present?
+    end
+
+    def resolved_value
+      get_fact.value
+    end
+
+    private
+
+    def get_fact
+      @fact ||= @renderer.host.fact_values.includes(:fact_name).where(:'fact_names.name' => @input.fact_name).first
+    end
+  end
+
+  class VariableInputResolver < InputResolver
+    def ready?
+      @renderer.host && @renderer.host.params.key?(@input.variable_name)
+    end
+
+    def resolved_value
+      @renderer.host.params[@input.variable_name]
+    end
+  end
+
+  class PuppetParameterInputResolver < InputResolver
+    def ready?
+      @renderer.host &&
+        get_enc.key?(@input.puppet_class_name) &&
+        get_enc[@input.puppet_class_name].is_a?(Hash) &&
+        get_enc[@input.puppet_class_name].key?(@input.puppet_parameter_name)
+    end
+
+    def resolved_value
+      get_enc[@input.puppet_class_name][@input.puppet_parameter_name]
+    end
+
+    private
+
+    def get_enc
+      @enc ||= Classification::ClassParam.new(:host => @renderer.host).enc
+    end
+  end
+end

data/app/models/template_invocation.rb

@@ -0,0 +1,13 @@
+class TemplateInvocation < ActiveRecord::Base
+
+  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_one :targeting, :through => :job_invocation
+
+  include ForemanTasks::Concerns::ActionSubject
+
+  def to_action_input
+    { :id => id, :name => template.name }
+  end
+end

data/app/models/template_invocation_input_value.rb

@@ -0,0 +1,8 @@
+class TemplateInvocationInputValue < ActiveRecord::Base
+
+  belongs_to :template_invocation
+  belongs_to :template_input
+
+  validates :value, :presence => true, :if => proc { |v| v.template_input.required? }
+
+end

data/app/views/api/v2/job_templates/base.json.rabl

@@ -0,0 +1,3 @@
+object @job_template
+
+attributes :id, :name, :job_name, :provider_type