foreman-tasks 0.1.0

data/app/lib/actions/foreman/architecture/create.rb

@@ -0,0 +1,29 @@
+module Actions
+  module Foreman
+    module Architecture
+      class Create < Actions::EntryAction
+
+        def plan(architecture)
+          action_subject(architecture, :changes => architecture.changes)
+        end
+
+        def humanized_name
+          _("Create architecture")
+        end
+
+        def humanized_input
+          input[:architecture] && input[:architecture][:name]
+        end
+
+        def cli_example
+          return unless input[:architecture]
+        <<-EXAMPLE
+hammer architecture create --id '#{task_input[:architecture][:id]}' \
+--name '#{task_input[:architecture][:name]}'
+        EXAMPLE
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman/architecture/destroy.rb

@@ -0,0 +1,28 @@
+module Actions
+  module Foreman
+    module Architecture
+      class Destroy < Actions::EntryAction
+
+        def plan(architecture)
+          action_subject(architecture)
+        end
+
+        def humanized_name
+          _("Delete architecture")
+        end
+
+        def humanized_input
+          input[:architecture] && input[:architecture][:name]
+        end
+
+        def cli_example
+          return unless input[:architecture]
+        <<-EXAMPLE
+hammer architecture delete --id '#{task_input[:architecture][:id]}'
+        EXAMPLE
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman/architecture/update.rb

@@ -0,0 +1,21 @@
+module Actions
+  module Foreman
+    module Architecture
+      class Update < Actions::EntryAction
+
+        def plan(architecture)
+          action_subject(architecture, :changes => architecture.changes)
+        end
+
+        def humanized_name
+          _("Update architecture")
+        end
+
+        def humanized_input
+          input[:architecture] && input[:architecture][:name]
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman/host/import_facts.rb

@@ -0,0 +1,40 @@
+module Actions
+  module Foreman
+    module Host
+
+      class ImportFacts < Actions::EntryAction
+
+        def resource_locks
+          :import_facts
+        end
+
+        def plan(host_type, host_name, facts, certname, proxy_id)
+          host = ::Host::Base.importHost(host_name, certname, proxy_id)
+          action_subject(host, :facts => facts)
+        end
+
+        def run
+          ::User.as :admin do
+            host           = ::Host.find(input[:host][:id])
+            state          = host.importFacts(input[:facts])
+            output[:state] = state
+          end
+        rescue ::Foreman::Exception => e
+          # This error is what is thrown by Host#ImportHostAndFacts when
+          # the Host is in the build state. This can be refactored once
+          # issue #3959 is fixed.
+          raise e unless e.code == 'ERF51-9911'
+        end
+
+        def humanized_name
+          _("Import facts")
+        end
+
+        def humanized_input
+          input[:host] && input[:host][:name]
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/helpers/args_serialization.rb

@@ -0,0 +1,91 @@
+module Actions
+  module Helpers
+    module ArgsSerialization
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      class Builder
+        attr_reader :hash
+        def initialize(*objects)
+          @hash = {}.with_indifferent_access
+          objects.each do |object|
+            add_object(object)
+          end
+        end
+
+        private
+
+        def add_object(object)
+          case object
+          when ActiveRecord::Base
+            unless object.respond_to?(:action_input_key)
+              raise "Serialized model has to repond to :action_input_key method"
+            end
+            key = object.action_input_key
+            value = object_to_value(object)
+            add(key, value)
+          when Hash
+            add_hash(object_to_value(object))
+          else
+            raise "don't know how to serialize #{object.inspect}"
+          end
+        end
+
+        def object_to_value(object)
+          case object
+          when Array
+            object.map { |item| object_to_value(item) }
+          when Hash
+            object.reduce({}) do |new_hash, (key, value)|
+              new_hash.update(key => object_to_value(value))
+            end
+          when ActiveRecord::Base
+            unless object.respond_to?(:to_action_input)
+              raise "Serialized model has to repond to :to_action_input method"
+            end
+            object.to_action_input
+          when String, Numeric, true, false, nil
+            object
+          else
+            object.to_s
+          end
+        end
+
+        def add_hash(hash)
+          hash.each do |key, value|
+            add(key, value)
+          end
+        end
+
+        def add(key, value)
+          if hash.has_key?(key)
+            raise "Conflict while serializing action args in key #{key}"
+          end
+          hash.update(key => value)
+        end
+      end
+
+      module ClassMethods
+
+        def generate_phase(phase_module)
+          super.tap do |phase_class|
+            if phase_module == Dynflow::Action::PlanPhase
+              phase_class.send(:include, PlanMethods)
+            end
+          end
+        end
+
+      end
+
+      module PlanMethods
+
+        def serialize_args(*objects)
+          Builder.new(*objects).hash
+        end
+
+      end
+    end
+  end
+end
+

data/app/lib/actions/helpers/humanizer.rb

@@ -0,0 +1,64 @@
+module Actions
+  module Helpers
+
+    class Humanizer
+
+      PARTS_ORDER = [:repository,
+                     :product,
+                     :system,
+                     :organization]
+      # Just to get the trings into pot file
+      PARTS_TRANSLATIONS = [N_('repository'),
+                            N_('product'),
+                            N_('system'),
+                            N_('organization')]
+
+      def initialize(action)
+        @action = action
+        @input  = action.respond_to?(:task_input) ? action.task_input : action.input
+        @input ||= {}
+        @output = action.respond_to?(:task_output) ? action.task_output : action.output
+        @output ||= {}
+      end
+
+      def input(*parts)
+        if parts.empty?
+          parts = PARTS_ORDER
+        end
+        included_parts(parts, @input).map do |part|
+          [part, humanize_resource(part, @input[part], @input)]
+        end
+      end
+
+      def included_parts(parts, data)
+        parts.select { |part| data.has_key?(part) }
+      end
+
+      def humanize_resource(type, data, other_data)
+        humanized_type = _(type)
+        humanized_value = data[:name] || data[:label] || data[:id]
+        { text: "#{humanized_type} '#{humanized_value}'",
+         link: link_to_resource(type, data, other_data) }
+      end
+
+      def link_to_resource(type, data, other_data)
+        case type
+        when :product
+          "#/products/#{data[:cp_id]}/info" if data[:cp_id]
+        when :repository
+          if other_data[:product] && other_data[:product][:cp_id] && data[:id]
+            "#/products/#{other_data[:product][:cp_id]}/repositories/#{data[:id]}"
+          end
+        when :system
+          if data[:uuid]
+            "#/systems/#{data[:uuid]}/info"
+          end
+        when :organization
+          if data[:label]
+            "/katello/organizations#/!=&panel=organization_#{data[:label]}&!="
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/helpers/lock.rb

@@ -0,0 +1,43 @@
+module Actions
+  module Helpers
+    module Lock
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def generate_phase(phase_module)
+          super.tap do |phase_class|
+            if phase_module == Dynflow::Action::PlanPhase
+              phase_class.send(:include, PlanMethods)
+            end
+          end
+        end
+
+      end
+
+      module PlanMethods
+
+        def task
+          ::ForemanTasks::Task::DynflowTask.find_by_external_id!(execution_plan_id)
+        end
+
+        # @see Lock.exclusive!
+        def exclusive_lock!(resource)
+          ::ForemanTasks::Lock.exclusive!(resource, task.id)
+        end
+
+        # @see Lock.lock!
+        def lock!(resource, *lock_names)
+          ::ForemanTasks::Lock.lock!(resource, task.id, *lock_names.flatten)
+        end
+
+        # @see Lock.link!
+        def link!(resource)
+          ::ForemanTasks::Lock.link!(resource, task.id)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/test_action.rb

@@ -0,0 +1,17 @@
+module Actions
+  class TestAction < Base
+
+    def run(event = nil)
+      case event
+      when nil
+        suspend do |suspended_action|
+          puts "Execution plan id is #{suspended_action.execution_plan_id}"
+          puts "Step id is #{suspended_action.step_id}"
+        end
+      else
+        puts event.inspect
+      end
+    end
+
+  end
+end

data/app/models/foreman_tasks/concerns/action_subject.rb

@@ -0,0 +1,102 @@
+module ForemanTasks
+  module Concerns
+    module ActionSubject
+
+      extend ActiveSupport::Concern
+
+      included do
+        after_create :plan_create_action
+        after_update :plan_update_action
+        after_destroy :plan_destroy_action
+        after_commit :execute_planned_action
+      end
+
+      module ClassMethods
+        def available_locks
+          [:read, :write]
+        end
+      end
+
+      def action_input_key
+        self.class.name.underscore[/\w*\Z/]
+      end
+
+      def to_action_input
+        if self.new_record?
+          raise "The resource needs to be saved first"
+        end
+        { id: id, name: name }.tap do |hash|
+          hash.update(label: label) if self.respond_to? :label
+        end
+      end
+
+      # @api override to return the objects that relate to this one, usually parent
+      # objects, e.g. repository would return product it belongs to, product would return
+      # provider etc.
+      #
+      # It's used to link a task running on top of this resource to it's related objects,
+      # so that is't possible to see all the sync tasks for a product etc.
+      def related_resources
+      end
+
+      # Recursively searches for related resources of this one, avoiding cycles
+      def related_resources_recursive(result = [])
+        Array(related_resources).each do |related_resource|
+          unless result.include?(related_resource)
+            result << related_resource
+            if related_resource.respond_to?(:related_resources_recursive)
+              related_resource.related_resources_recursive(result)
+            end
+          end
+        end
+        return result
+      end
+
+      def create_action
+      end
+
+      def update_action
+      end
+
+      def destroy_action
+      end
+
+      def plan_create_action
+        plan_action(create_action, self) if create_action
+        return true
+      end
+
+      def plan_update_action
+        plan_action(update_action, self) if update_action
+        return true
+      end
+
+      def plan_destroy_action
+        plan_action(destroy_action, self) if destroy_action
+        return true
+      end
+
+      # Perform planning phase of the action tied with the model event.
+      # We do it separately from the execution phase, because the transaction
+      # of planning phase is expected to be commited when execution occurs. Also
+      # we want to be able to rollback the whole db operation when planning fails.
+      def plan_action(action_class, *args)
+        @execution_plan = ::ForemanTasks.dynflow.world.plan(action_class, *args)
+        planned         = @execution_plan.state == :planned
+        unless planned
+          errors = @execution_plan.steps.values.map(&:error).compact
+          # we raise error so that the whole transaction is rollbacked
+          raise errors.map(&:message).join('; ')
+        end
+      end
+
+      # Execute the prepared execution plan after the db transaction was commited
+      def execute_planned_action
+        if @execution_plan
+          ::ForemanTasks.dynflow.world.execute(@execution_plan.id)
+        end
+        return true
+      end
+    end
+  end
+end