foreman_deployments 0.0.1

data/app/lib/foreman_deployments/task_reference.rb

@@ -0,0 +1,48 @@
+module ForemanDeployments
+  class TaskReference
+    attr_accessor :task, :task_id, :output_key
+
+    def initialize(task_id, output_key, task = nil)
+      @task_id = task_id
+      @output_key = output_key
+      @task = task
+    end
+
+    def dereference(output)
+      output_keys.each do |key|
+        return nil if output.nil?
+        if output.is_a?(Hash) || output.is_a?(Dynflow::ExecutionPlan::OutputReference)
+          output = output[key]
+        else
+          output = output.send(key)
+        end
+      end
+      return output
+    rescue NoMethodError
+      return nil
+    end
+
+    def accept(visitor)
+      visitor.visit(self)
+    end
+
+    def to_hash
+      {
+        '_type' => 'reference',
+        '_name' => self.class.tag_name,
+        'object' => task_id,
+        'field' => output_key
+      }
+    end
+
+    def self.tag_name
+      'reference'
+    end
+
+    private
+
+    def output_keys
+      @output_key.to_s.split('.')
+    end
+  end
+end

data/app/lib/foreman_deployments/tasks/base_action.rb

@@ -0,0 +1,6 @@
+module ForemanDeployments
+  module Tasks
+    class BaseAction < Actions::Base
+    end
+  end
+end

data/app/lib/foreman_deployments/tasks/base_definition.rb

@@ -0,0 +1,72 @@
+module ForemanDeployments
+  module Tasks
+    class BaseDefinition
+      attr_accessor :task_id, :parameters
+      attr_reader :planned
+
+      def initialize(params = nil)
+        @parameters = ForemanDeployments::Config.cast_to_configuration(params || {})
+      end
+
+      def plan(parent_task)
+        @planned ||= parent_task.send(:plan_action, dynflow_action, parameters.configured)
+      end
+
+      def dynflow_action
+        fail NotImplementedError, "Method 'dynflow_action' method needs to be implemented"
+      end
+
+      def validate
+        fail NotImplementedError, "Method 'validate' needs to be implemented"
+      end
+
+      def preliminary_output
+        fail NotImplementedError, "Method 'preliminary_output' needs to be implemented"
+      end
+
+      def configure(parameters)
+        @parameters.configure(parameters)
+      end
+
+      def merge_configuration(additional_parameters)
+        @parameters.merge_configuration(additional_parameters)
+      end
+
+      def configuration
+        @parameters.configuration
+      end
+
+      def accept(visitor)
+        visit_parameters(visitor, parameters)
+        visitor.visit(self)
+      end
+
+      def to_hash
+        @parameters.configured.merge(
+          '_type' => 'task',
+          '_name' => self.class.tag_name
+        )
+      end
+
+      def self.tag_name
+        name.split('::').last
+      end
+
+      def self.build(params = {})
+        new(params)
+      end
+
+      private
+
+      def visit_parameters(visitor, value)
+        if value.respond_to?(:accept)
+          value.accept(visitor)
+        elsif value.is_a? Array
+          value.each { |item| visit_parameters(visitor, item) }
+        elsif value.is_a? Hash
+          value.each { |_key, item| visit_parameters(visitor, item) }
+        end
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/tasks/creation_task_definition.rb

@@ -0,0 +1,68 @@
+module ForemanDeployments
+  module Tasks
+    class CreationTaskDefinition < ForemanDeployments::Tasks::BaseDefinition
+      class Action < BaseAction
+        def run
+          obj = CreationTaskDefinition.create_object(input)
+          obj.save!
+          CreationTaskDefinition.create_output(obj, output)
+        end
+      end
+
+      def validate
+        obj = self.class.create_object(parameters.configured)
+        obj.valid?
+        ForemanDeployments::Validation::ValidationResult.new(obj.errors.full_messages)
+      rescue ActiveRecord::ActiveRecordError => e
+        ForemanDeployments::Validation::ValidationResult.new([e.message])
+      end
+
+      def preliminary_output
+        self.class.create_output(self.class.create_object(parameters.configured))
+      end
+
+      def dynflow_action
+        self.class::Action
+      end
+
+      def self.create_object(parameters)
+        object_type = parameters['class']
+        object_params = parameters['params'] || {}
+
+        object_type = object_type.constantize if object_type.is_a? String
+        object = object_type.new
+
+        set_parameters(object, object_params)
+      end
+
+      def self.set_parameters(object, object_params)
+        object_params.each do |key, value|
+          if object.respond_to?("#{key}=")
+            object.send("#{key}=", value)
+            # TODO: else, add warning message
+          end
+        end
+
+        object
+      end
+
+      def self.create_output(obj, output_hash = {})
+        output_hash['object'] = obj
+        output_hash
+      end
+
+      def self.tag_name
+        'CreateResource'
+      end
+
+      def self.build(parameters)
+        case parameters['class']
+        when 'Host', 'Host::Managed'
+          HostCreationTaskDefinition.new(parameters)
+        else
+          CreationTaskDefinition.new(parameters)
+        end
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/tasks/host_creation_task_definition.rb

@@ -0,0 +1,44 @@
+module ForemanDeployments
+  module Tasks
+    class HostCreationTaskDefinition < ForemanDeployments::Tasks::CreationTaskDefinition
+      class Action < BaseAction
+        def run
+          obj = HostCreationTaskDefinition.create_object(input)
+          obj.save!
+          HostCreationTaskDefinition.create_output(obj, output)
+        end
+      end
+
+      def self.create_object(parameters)
+        object_type = parameters['class']
+        object_params = parameters['params']
+        object_params['managed'] ||= true
+
+        object_type = object_type.constantize if object_type.is_a? String
+
+        initial_params = {
+          :interfaces_attributes => object_params.delete('interfaces_attributes') || {}
+        }
+
+        object = object_type.new(initial_params)
+        object = set_parameters(object, object_params)
+
+        initialize_manged_host(object, object_params) if object.is_a? Host::Managed
+
+        object
+      end
+
+      def self.initialize_manged_host(object, object_params)
+        object_params['build'] ||= true
+        # Set compute attributes from a compute profile
+        if object.compute_resource_id && object.compute_profile_id
+          profile_attributes = object.compute_resource.compute_profile_attributes_for(object.compute_profile_id)
+          object.compute_attributes = profile_attributes.merge(object.compute_attributes || {})
+        end
+        # Merge interfaces from a compute profile
+        merge = InterfaceMerge.new
+        merge.run(object.interfaces, object.compute_resource.try(:compute_profile_for, object.compute_profile_id))
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/tasks/search_task_definition.rb

@@ -0,0 +1,55 @@
+module ForemanDeployments
+  module Tasks
+    class SearchTaskDefinition < BaseDefinition
+      class Action < BaseAction
+        def run
+          results = SearchTaskDefinition.search(input)
+          results = SerializableArray.new(results)
+          SearchTaskDefinition.create_output(results, output)
+        end
+      end
+
+      class SerializableArray < Array
+        def to_hash
+          {}
+        end
+      end
+
+      def validate
+        results = SearchTaskDefinition.search(parameters.configured)
+        messages = []
+        unless results.any?
+          messages = [
+            _('%s didn\'t return valid objects') % "#{parameters['class']}.search_for('#{parameters['search_term']}')"]
+        end
+
+        ForemanDeployments::Validation::ValidationResult.new(messages)
+      end
+
+      def preliminary_output
+        SearchTaskDefinition.create_output(SearchTaskDefinition.search(parameters.configured))
+      end
+
+      def dynflow_action
+        ForemanDeployments::Tasks::SearchTaskDefinition::Action
+      end
+
+      def self.search(parameters)
+        object_type = parameters['class']
+        object_type = object_type.constantize if object_type.is_a? String
+        results = object_type.search_for(parameters[:search_term])
+        results
+      end
+
+      def self.create_output(obj, output_hash = {})
+        output_hash['results'] = obj
+        output_hash['result'] = { 'ids' => obj.map(&:id) }
+        output_hash
+      end
+
+      def self.tag_name
+        'FindResource'
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/tasks/stack_deploy_action.rb

@@ -0,0 +1,10 @@
+module ForemanDeployments
+  module Tasks
+    class StackDeployAction < BaseAction
+      def plan(stack_definition)
+        stack_definition.accept(ForemanDeployments::PlannerVisitor.new(self))
+        plan_self
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/tasks/wait_until_built_task_definition.rb

@@ -0,0 +1,65 @@
+module ForemanDeployments
+  module Tasks
+    class WaitUntilBuiltTaskDefinition < ForemanDeployments::Tasks::BaseDefinition
+      class Action < BaseAction
+        include Dynflow::Action::Polling
+
+        def done?
+          external_task['built'] == true
+        end
+
+        def timeout
+          input['timeout'] || 2 * 60 * 60 # 2 hours default
+        end
+
+        def invoke_external_task
+          schedule_timeout(timeout) unless timeout <= 0
+          WaitUntilBuiltTaskDefinition.build_status
+        end
+
+        def poll_external_task
+          fail(_("'%s' is a required parameter") % 'host_id') unless input.key?('host_id')
+
+          host = Host.find(input['host_id'])
+          WaitUntilBuiltTaskDefinition.create_output(host, output)
+          WaitUntilBuiltTaskDefinition.build_status(host)
+        end
+
+        def poll_interval
+          30
+        end
+      end
+
+      def validate
+        result = ForemanDeployments::Validation::ValidationResult.new([])
+        unless parameters.configured.key?('host_id')
+          result.messages << _("'%s' is a required parameter") % 'host_id'
+        end
+        result
+      end
+
+      def preliminary_output(_parameters)
+        WaitUntilBuiltTaskDefinition.create_output(Host::Managed.new)
+      end
+
+      def dynflow_action
+        ForemanDeployments::Tasks::WaitUntilBuiltTaskDefinition::Action
+      end
+
+      def self.create_output(host, output_hash = {})
+        output_hash['object'] = host
+        output_hash['object']['facts'] = host.facts
+        output_hash
+      end
+
+      def self.build_status(host = nil)
+        status = (!host.nil? && (host.reports.count > 1) && !host.reports.last.error?)
+        { 'build' => status }
+      end
+
+      def self.tag_name
+        'WaitUntilBuilt'
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/validation/dereference_visitor.rb

@@ -0,0 +1,18 @@
+module ForemanDeployments
+  module Validation
+    class DereferenceVisitor < ForemanDeployments::BaseDereferenceVisitor
+      protected
+
+      def get_dereference(ref)
+        ref.dereference(get_preliminary_output(ref.task))
+      end
+
+      def get_preliminary_output(task)
+        cached(task) do
+          task.parameters = dereference(task.parameters)
+          task.preliminary_output
+        end
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/validation/remove_ids_visitor.rb

@@ -0,0 +1,59 @@
+module ForemanDeployments
+  module Validation
+    class RemoveIdsVisitor
+      def visit(subject)
+        if subject.is_a? ForemanDeployments::Tasks::CreationTaskDefinition
+          remove_ids(subject.parameters)
+        end
+      end
+
+      private
+
+      def remove_ids(value)
+        case value
+        when Config::Hash
+          remove_ids_from_hash(value)
+        when Config::Array
+          remove_ids_from_array(value)
+        when TaskReference
+          remove_id_from_reference(value)
+        else
+          value
+        end
+      end
+
+      def remove_ids_from_hash(hash)
+        hash.transform! do |key, item|
+          if singular_reference?(key, item) || multiple_references?(key, item)
+            [key.to_s.sub('_id', ''), remove_ids(item)]
+          else
+            [key, remove_ids(item)]
+          end
+        end
+      end
+
+      def remove_ids_from_array(array)
+        array.transform! do |item|
+          remove_ids(item)
+        end
+      end
+
+      def remove_id_from_reference(ref)
+        if ref.output_key.end_with?('.ids')
+          ref.output_key.gsub!(/[.]ids$/, 's')
+        elsif ref.output_key.end_with?('.id')
+          ref.output_key.gsub!(/[.]id$/, '')
+        end
+        ref
+      end
+
+      def singular_reference?(key, value)
+        key.to_s.end_with?('_id') && value.is_a?(TaskReference)
+      end
+
+      def multiple_references?(key, values)
+        key.to_s.end_with?('_ids') && (values.is_a?(TaskReference) || values.all? { |v| v.is_a?(TaskReference) })
+      end
+    end
+  end
+end