foreman-tasks-core 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf0691634b81dc717a0678d8dbbf78da4489fe4a4ad8e141815c0715de637192
-  data.tar.gz: 49f3a9a18cd5cd1bee5405b9272ef9cba77476bc57973ac1dc87e65a98eebf4e
+  metadata.gz: c46d9f3def1bf8405c45eb6a32331437dede8c68071d0c0c8a0159a2e489f007
+  data.tar.gz: 24e606e5743d4694c607514b25bbff6492153290d9d3c99546a91b6ce75967d0
 SHA512:
-  metadata.gz: 519b03fc48675250a25bb0c75d49fa6f335c1e8c904acc7fe57d7f5b6b143d25cf3b6effd7ae4554fd69796f9648eb13ef1e9e853366a22c17bbb8dae75e4978
-  data.tar.gz: f7009108c1a9c5e515e37213e435e91cb35a704d72c650576a1331d6395cacf2c7fc2d8cedda1363de33384c59b3dbe55f38d871143e8c7b405bed00d1a76ec4
+  metadata.gz: 5a3c8a38e39d80a3f5f9bc1deebdcf7e4b082838e687ae78846a17448302dddff4c00c24e81235ad455133c12bfd7112d657b7ca630210ce79bddd1f4d04e13f
+  data.tar.gz: c4777a0ca2d8d7562e3b2f0ab02293e7af5039753adcd9c7d0fabe1955726b60cf15e2c9664376410aff9e08de45054459ce9e2ac7a0d4a94ce49e02b3a61936

data/lib/foreman_tasks_core.rb

@@ -4,6 +4,7 @@
 require 'foreman_tasks_core/settings_loader'
 require 'foreman_tasks_core/otp_manager'
 require 'foreman_tasks_core/ticker'
+require 'foreman_tasks_core/task_launcher'
 
 module ForemanTasksCore
   def self.dynflow_world

data/lib/foreman_tasks_core/runner.rb

@@ -7,3 +7,4 @@ require 'foreman_tasks_core/runner/update'
 require 'foreman_tasks_core/runner/base'
 require 'foreman_tasks_core/runner/dispatcher'
 require 'foreman_tasks_core/runner/action'
+require 'foreman_tasks_core/runner/parent'

data/lib/foreman_tasks_core/runner/base.rb

@@ -6,9 +6,10 @@ module ForemanTasksCore
       attr_reader :id
       attr_writer :logger
 
-      def initialize(*_args)
+      def initialize(*_args, suspended_action: nil)
+        @suspended_action = suspended_action
         @id = SecureRandom.uuid
-        @continuous_output = ::ForemanTasksCore::ContinuousOutput.new
+        initialize_continuous_outputs
       end
 
       def logger
@@ -18,11 +19,7 @@ module ForemanTasksCore
       def run_refresh
         logger.debug('refreshing runner')
         refresh
-        new_data = @continuous_output
-        @continuous_output = ForemanTasksCore::ContinuousOutput.new
-        if !new_data.empty? || @exit_status
-          return Runner::Update.new(new_data, @exit_status)
-        end
+        generate_updates
       end
 
       def start
@@ -59,13 +56,28 @@ module ForemanTasksCore
       def publish_exception(context, exception, fatal = true)
         logger.error("#{context} - #{exception.class} #{exception.message}:\n" + \
                      exception.backtrace.join("\n"))
-        @continuous_output.add_exception(context, exception)
+        dispatch_exception context, exception
         publish_exit_status('EXCEPTION') if fatal
       end
 
       def publish_exit_status(status)
         @exit_status = status
       end
+
+      def dispatch_exception(context, exception)
+        @continuous_output.add_exception(context, exception)
+      end
+
+      def generate_updates
+        return {} if @continuous_output.empty? && @exit_status.nil?
+        new_data = @continuous_output
+        @continuous_output = ForemanTasksCore::ContinuousOutput.new
+        { @suspended_action => Runner::Update.new(new_data, @exit_status) }
+      end
+
+      def initialize_continuous_outputs
+        @continuous_output = ::ForemanTasksCore::ContinuousOutput.new
+      end
     end
   end
 end

data/lib/foreman_tasks_core/runner/dispatcher.rb

@@ -37,10 +37,14 @@ module ForemanTasksCore
 
         def refresh_runner
           @logger.debug("refresh runner #{@runner.id}")
-          if (update = @runner.run_refresh)
-            @suspended_action << update
-            finish if update.exit_status
-          end
+          updates = @runner.run_refresh
+
+          updates.each { |receiver, update| (receiver || @suspended_action) << update }
+
+          # This is a workaround when the runner does not accept the suspended action
+          main_key = updates.keys.any?(&:nil?) ? nil : @suspended_action
+          main_process = updates[main_key]
+          finish if main_process && main_process.exit_status
         ensure
           @refresh_planned = false
           plan_next_refresh

data/lib/foreman_tasks_core/runner/parent.rb

@@ -0,0 +1,48 @@
+module ForemanTasksCore
+  module Runner
+    class Parent < Base
+      # targets = { hostname => { :execution_plan_id => "...", :run_step_id => id,
+      #                           :input => { ... } }
+      def initialize(targets = {}, suspended_action: nil)
+        @targets = targets
+        super suspended_action: suspended_action
+      end
+
+      def generate_updates
+        @outputs.reduce({}) do |acc, (key, value)|
+          if value.empty? && @exit_status.nil?
+            acc
+          else
+            @outputs[key] = ForemanTasksCore::ContinuousOutput.new
+            key = host_action(key) unless key == @suspended_action
+            acc.merge(key => Runner::Update.new(value, @exit_status))
+          end
+        end
+      end
+
+      def initialize_continuous_outputs
+        @outputs = ([@suspended_action] + @targets.keys).reduce({}) do |acc, target|
+          acc.merge(target => ForemanTasksCore::ContinuousOutput.new)
+        end
+      end
+
+      def host_action(hostname)
+        options = @targets[hostname].slice('execution_plan_id', 'run_step_id')
+                                    .merge(:world => ForemanTasksCore.dynflow_world)
+        Dynflow::Action::Suspended.new OpenStruct.new(options)
+      end
+
+      def broadcast_data(data, type)
+        @outputs.each { |_k, output| output.add_output(data, type) }
+      end
+
+      def publish_data_for(hostname, data, type)
+        @outputs[hostname].add_output(data, type)
+      end
+
+      def dispatch_exception(context, exception)
+        @outputs.values.each { |output| output.add_exception(context, exception) }
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/task_launcher.rb

@@ -0,0 +1,8 @@
+module ForemanTasksCore
+  module TaskLauncher
+  end
+end
+
+require 'foreman_tasks_core/task_launcher/abstract'
+require 'foreman_tasks_core/task_launcher/single'
+require 'foreman_tasks_core/task_launcher/batch'

data/lib/foreman_tasks_core/task_launcher/abstract.rb

@@ -0,0 +1,42 @@
+module ForemanTasksCore
+  module TaskLauncher
+    class Abstract
+      attr_reader :callback, :options, :results, :world
+      def initialize(world, callback, options = {})
+        @world = world
+        @callback = callback
+        @options = options
+        @results = {}
+      end
+
+      def launch!(_input)
+        raise NotImplementedError
+      end
+
+      private
+
+      def format_result(result)
+        if result.triggered?
+          { :result => 'success', :task_id => result.execution_plan_id }
+        else
+          plan = world.persistence.load_execution_plan(result.id)
+          { :result => 'error', :errors => plan.errors }
+        end
+      end
+
+      def action_class(input)
+        ::Dynflow::Utils.constantize(input['action_class'])
+      end
+
+      def with_callback(input)
+        input.merge(:callback_host => callback)
+      end
+
+      def trigger(parent, klass, *input)
+        world.trigger do
+          world.plan_with_options(caller_action: parent, action_class: klass, args: input)
+        end
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/task_launcher/batch.rb

@@ -0,0 +1,37 @@
+module ForemanTasksCore
+  module TaskLauncher
+    class ParentAction < ::Dynflow::Action
+      include Dynflow::Action::WithSubPlans
+      include Dynflow::Action::WithPollingSubPlans
+
+      # { task_id => { :action_class => Klass, :input => input } }
+      def plan(launcher, input_hash)
+        launcher.launch_children(self, input_hash)
+        plan_self
+      end
+
+      def initiate
+        ping suspended_action
+        wait_for_sub_plans sub_plans
+      end
+
+      def rescue_strategy
+        Dynflow::Action::Rescue::Fail
+      end
+    end
+
+    class Batch < Abstract
+      def launch!(input)
+        trigger(nil, ParentAction, self, input)
+      end
+
+      def launch_children(parent, input_hash)
+        input_hash.each do |task_id, input|
+          launcher = Single.new(world, callback, :parent => parent)
+          launcher.launch!(input)
+          results[task_id] = launcher.results
+        end
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/task_launcher/single.rb

@@ -0,0 +1,14 @@
+module ForemanTasksCore
+  module TaskLauncher
+    class Single < Abstract
+      # { :action_class => "MyActionClass", :action_input => {} }
+      def launch!(input)
+        triggered = trigger(options[:parent],
+                            action_class(input),
+                            with_callback(input.fetch('action_input', {})))
+        @results = format_result(triggered)
+        triggered
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasksCore
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.3.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks-core
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-08 00:00:00.000000000 Z
+date: 2019-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dynflow
@@ -42,9 +42,14 @@ files:
 - lib/foreman_tasks_core/runner/base.rb
 - lib/foreman_tasks_core/runner/command_runner.rb
 - lib/foreman_tasks_core/runner/dispatcher.rb
+- lib/foreman_tasks_core/runner/parent.rb
 - lib/foreman_tasks_core/runner/update.rb
 - lib/foreman_tasks_core/settings_loader.rb
 - lib/foreman_tasks_core/shareable_action.rb
+- lib/foreman_tasks_core/task_launcher.rb
+- lib/foreman_tasks_core/task_launcher/abstract.rb
+- lib/foreman_tasks_core/task_launcher/batch.rb
+- lib/foreman_tasks_core/task_launcher/single.rb
 - lib/foreman_tasks_core/ticker.rb
 - lib/foreman_tasks_core/version.rb
 homepage: https://github.com/theforeman/foreman-tasks