foreman-tasks-core 0.3.0 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf0691634b81dc717a0678d8dbbf78da4489fe4a4ad8e141815c0715de637192
-  data.tar.gz: 49f3a9a18cd5cd1bee5405b9272ef9cba77476bc57973ac1dc87e65a98eebf4e
+  metadata.gz: 9eeba72428b030c0bcec9f51c7b58cbfb7e046eb7279b68b6030b46aaa72a434
+  data.tar.gz: 9a40808da08504914c856d9407a7d454a5c5045125a768ee5d6b54424444bd93
 SHA512:
-  metadata.gz: 519b03fc48675250a25bb0c75d49fa6f335c1e8c904acc7fe57d7f5b6b143d25cf3b6effd7ae4554fd69796f9648eb13ef1e9e853366a22c17bbb8dae75e4978
-  data.tar.gz: f7009108c1a9c5e515e37213e435e91cb35a704d72c650576a1331d6395cacf2c7fc2d8cedda1363de33384c59b3dbe55f38d871143e8c7b405bed00d1a76ec4
+  metadata.gz: c9cd9a1e5c8f247bd5b3f335998d2cba76d2a17ba6edfae529713f6eaaa60de6133d61125e76175544a8248f259f48bfa715de46cd4f1ff5132844d1c5c0250d
+  data.tar.gz: 2ddb3a83487315cdbc6ecf32886d67f599badb47f61f02019122fed0103602af72f0c8e5f999016dfec36a3caa56c17202fb3ce0426f5814084d5703bd702991

data/lib/foreman_tasks_core.rb

@@ -4,6 +4,12 @@
 require 'foreman_tasks_core/settings_loader'
 require 'foreman_tasks_core/otp_manager'
 require 'foreman_tasks_core/ticker'
+require 'foreman_tasks_core/batch_action'
+require 'foreman_tasks_core/batch_callback_action'
+require 'foreman_tasks_core/batch_runner_action'
+require 'foreman_tasks_core/output_collector_action'
+require 'foreman_tasks_core/single_runner_batch_action'
+require 'foreman_tasks_core/task_launcher'
 
 module ForemanTasksCore
   def self.dynflow_world

data/lib/foreman_tasks_core/batch_action.rb

@@ -0,0 +1,21 @@
+module ForemanTasksCore
+  class BatchAction < ::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
+end

data/lib/foreman_tasks_core/batch_callback_action.rb

@@ -0,0 +1,20 @@
+module ForemanTasksCore
+  class BatchCallback < ::Dynflow::Action
+    def plan(input_hash, results)
+      plan_self :targets => input_hash, :results => results
+    end
+
+    def run
+      payload = format_payload(input['targets'], input['results'])
+      SmartProxyDynflowCore::Callback::Request.new.callback({ :callbacks => payload }.to_json)
+    end
+
+    private
+
+    def format_payload(input_hash, results)
+      input_hash.map do |task_id, callback|
+        { :callback => callback, :data => results[task_id] }
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/batch_runner_action.rb

@@ -0,0 +1,14 @@
+require 'foreman_tasks_core/runner/action'
+
+module ForemanTasksCore
+  class BatchRunnerAction < ::ForemanTasksCore::Runner::Action
+    def plan(launcher, input)
+      plan_self :targets => launcher.runner_input(input), :operation => launcher.operation
+    end
+
+    def initiate_runner
+      launcher = SmartProxyDynflowCore::TaskLauncherRegistry.fetch(input[:operation])
+      launcher.runner_class.new(input[:targets], suspended_action: suspended_action)
+    end
+  end
+end

data/lib/foreman_tasks_core/otp_manager.rb

@@ -17,10 +17,15 @@ module ForemanTasksCore
         @password ||= {}
       end
 
-      def authenticate(hash)
+      def authenticate(hash, expected_user: nil, clear: true)
         plain = Base64.decode64(hash)
         username, otp = plain.split(':', 2)
-        drop_otp(username, otp)
+        if expected_user
+          return false unless expected_user == username
+        end
+        password_matches = passwords[username] == otp
+        passwords.delete(username) if clear && password_matches
+        password_matches
       end
 
       def tokenize(username, password)

data/lib/foreman_tasks_core/output_collector_action.rb

@@ -0,0 +1,8 @@
+module ForemanTasksCore
+  class OutputCollectorAction < ::ForemanTasksCore::Runner::Action
+    def init_run
+      output[:result] = []
+      suspend
+    end
+  end
+end

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,14 @@ 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
+
+      # by default, external event just causes the refresh to be triggered: this allows the descendants
+      # of the Base to add custom logic to process the external events.
+      # Similarly as `run_refresh`, it's expected to return updates to be dispatched.
+      def external_event(_event)
+        run_refresh
       end
 
       def start
@@ -59,13 +63,36 @@ 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 no_update if @continuous_output.empty? && @exit_status.nil?
+        new_data = @continuous_output
+        @continuous_output = ForemanTasksCore::ContinuousOutput.new
+        new_update(new_data, @exit_status)
+      end
+
+      def no_update
+        {}
+      end
+
+      def new_update(data, exit_status)
+        { @suspended_action => Runner::Update.new(data, exit_status) }
+      end
+
+      def initialize_continuous_outputs
+        @continuous_output = ::ForemanTasksCore::ContinuousOutput.new
+      end
     end
   end
 end

data/lib/foreman_tasks_core/runner/command.rb

@@ -0,0 +1,40 @@
+module ForemanTasksCore
+  module Runner
+    module Command
+      def initialize_command(*command)
+        @command_out, @command_in, @command_pid = PTY.spawn(*command)
+      rescue Errno::ENOENT => e
+        publish_exception("Error running command '#{command.join(' ')}'", e)
+      end
+
+      def refresh
+        return if @command_out.nil?
+        ready_outputs, * = IO.select([@command_out], nil, nil, 0.1)
+        if ready_outputs
+          if @command_out.nread > 0
+            lines = @command_out.read_nonblock(@command_out.nread)
+          else
+            close_io
+            Process.wait(@command_pid)
+            publish_exit_status($CHILD_STATUS.exitstatus)
+          end
+          publish_data(lines, 'stdout') if lines && !lines.empty?
+        end
+      end
+
+      def close
+        close_io
+      end
+
+      private
+
+      def close_io
+        @command_out.close if @command_out && !@command_out.closed?
+        @command_out = nil
+
+        @command_in.close if @command_in && !@command_in.closed?
+        @command_in = nil
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/runner/command_runner.rb

@@ -1,41 +1,11 @@
 require 'io/wait'
 require 'pty'
+require 'foreman_tasks_core/runner/command'
 
 module ForemanTasksCore
   module Runner
-    class CommandRunner < Runner::Base
-      def initialize_command(*command)
-        @command_out, @command_in, @command_pid = PTY.spawn(*command)
-      end
-
-      def refresh
-        return if @command_out.nil?
-        ready_outputs, * = IO.select([@command_out], nil, nil, 0.1)
-        if ready_outputs
-          if @command_out.nread > 0
-            lines = @command_out.read_nonblock(@command_out.nread)
-          else
-            close_io
-            Process.wait(@command_pid)
-            publish_exit_status($CHILD_STATUS.exitstatus)
-          end
-          publish_data(lines, 'stdout') if lines && !lines.empty?
-        end
-      end
-
-      def close
-        close_io
-      end
-
-      private
-
-      def close_io
-        @command_out.close if @command_out && !@command_out.closed?
-        @command_out = nil
-
-        @command_in.close if @command_in && !@command_in.closed?
-        @command_in = nil
-      end
+    class CommandRunner < Base
+      include Command
     end
   end
 end

data/lib/foreman_tasks_core/runner/dispatcher.rb

@@ -37,15 +37,21 @@ 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
+          dispatch_updates(@runner.run_refresh)
         ensure
           @refresh_planned = false
           plan_next_refresh
         end
 
+        def dispatch_updates(updates)
+          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
+        end
+
         def timeout_runner
           @logger.debug("timeout runner #{@runner.id}")
           @runner.timeout
@@ -73,8 +79,8 @@ module ForemanTasksCore
           finish_termination
         end
 
-        def external_event(_event)
-          refresh_runner
+        def external_event(event)
+          dispatch_updates(@runner.external_event(event))
         end
 
         private
@@ -114,39 +120,33 @@ module ForemanTasksCore
 
       def start(suspended_action, runner)
         synchronize do
-          begin
-            raise "Actor with runner id #{runner.id} already exists" if @runner_actors[runner.id]
-            runner.logger = @logger
-            runner_actor = RunnerActor.spawn("runner-actor-#{runner.id}", self, suspended_action, runner, @clock, @logger)
-            @runner_actors[runner.id] = runner_actor
-            @runner_suspended_actions[runner.id] = suspended_action
-            runner_actor.tell(:start_runner)
-            return runner.id
-          rescue => exception
-            _handle_command_exception(runner.id, exception)
-            return nil
-          end
+          raise "Actor with runner id #{runner.id} already exists" if @runner_actors[runner.id]
+          runner.logger = @logger
+          runner_actor = RunnerActor.spawn("runner-actor-#{runner.id}", self, suspended_action, runner, @clock, @logger)
+          @runner_actors[runner.id] = runner_actor
+          @runner_suspended_actions[runner.id] = suspended_action
+          runner_actor.tell(:start_runner)
+          return runner.id
+        rescue => exception
+          _handle_command_exception(runner.id, exception)
+          return nil
         end
       end
 
       def kill(runner_id)
         synchronize do
-          begin
-            runner_actor = @runner_actors[runner_id]
-            runner_actor.tell(:kill) if runner_actor
-          rescue => exception
-            _handle_command_exception(runner_id, exception, false)
-          end
+          runner_actor = @runner_actors[runner_id]
+          runner_actor.tell(:kill) if runner_actor
+        rescue => exception
+          _handle_command_exception(runner_id, exception, false)
         end
       end
 
       def finish(runner_id)
         synchronize do
-          begin
-            _finish(runner_id)
-          rescue => exception
-            _handle_command_exception(runner_id, exception, false)
-          end
+          _finish(runner_id)
+        rescue => exception
+          _handle_command_exception(runner_id, exception, false)
         end
       end
 

data/lib/foreman_tasks_core/runner/parent.rb

@@ -0,0 +1,57 @@
+module ForemanTasksCore
+  module Runner
+    class Parent < Base
+      # targets = { identifier => { :execution_plan_id => "...", :run_step_id => id,
+      #                           :input => { ... } }
+      def initialize(targets = {}, suspended_action: nil)
+        @targets = targets
+        @exit_statuses = {}
+        super suspended_action: suspended_action
+      end
+
+      def generate_updates
+        base = {}
+        base[@suspended_action] = Runner::Update.new(ForemanTasksCore::ContinuousOutput.new, @exit_status) if @exit_status
+        # Operate on all hosts if the main process ended or only on hosts for which we have updates
+        @outputs.reject { |_, output| @exit_status.nil? && output.empty? }
+                .reduce(base) do |acc, (identifier, output)|
+                  @outputs[identifier] = ForemanTasksCore::ContinuousOutput.new # Create a new ContinuousOutput for next round of updates
+                  exit_status = @exit_statuses[identifier] || @exit_status if @exit_status
+                  acc.merge(host_action(identifier) => Runner::Update.new(output, exit_status))
+                end
+      end
+
+      def initialize_continuous_outputs
+        @outputs = @targets.keys.reduce({}) do |acc, target|
+          acc.merge(target => ForemanTasksCore::ContinuousOutput.new)
+        end
+      end
+
+      def host_action(identifier)
+        options = @targets[identifier].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(_data, _type)
+        true
+      end
+
+      def publish_data_for(identifier, data, type)
+        @outputs[identifier].add_output(data, type)
+      end
+
+      def dispatch_exception(context, exception)
+        @outputs.values.each { |output| output.add_exception(context, exception) }
+      end
+
+      def publish_exit_status_for(identifier, exit_status)
+        @exit_statuses[identifier] = exit_status
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/single_runner_batch_action.rb

@@ -0,0 +1,39 @@
+module ForemanTasksCore
+  class SingleRunnerBatchAction < ForemanTasksCore::BatchAction
+    def plan(launcher, input_hash)
+      launcher.launch_children(self, input_hash)
+      sequence do
+        results = plan_self
+        plan_action BatchCallback, launcher.prepare_batch(input_hash), results.output[:results]
+      end
+    end
+
+    def run(event = nil)
+      super unless event == Dynflow::Action::Skip
+    end
+
+    def initiate
+      ping suspended_action
+      wait_for_sub_plans sub_plans
+    end
+
+    def check_for_errors!(optional = true)
+      super unless optional
+    end
+
+    def on_finish
+      output[:results] = sub_plans.map(&:entry_action).reduce({}) do |acc, cur|
+        acc.merge(cur.execution_plan_id => cur.output)
+      end
+    end
+
+    def finalize
+      output.delete(:results)
+      check_for_errors!
+    end
+
+    def rescue_strategy_for_self
+      Dynflow::Action::Rescue::Skip
+    end
+  end
+end

data/lib/foreman_tasks_core/task_launcher.rb

@@ -0,0 +1,9 @@
+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'
+require 'foreman_tasks_core/task_launcher/group'

data/lib/foreman_tasks_core/task_launcher/abstract.rb

@@ -0,0 +1,44 @@
+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
+
+      def self.input_format; 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)
+        options[:action_class_override] || ::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 Batch < Abstract
+      def launch!(input)
+        trigger(nil, BatchAction, self, input)
+      end
+
+      def launch_children(parent, input_hash)
+        input_hash.each do |task_id, input|
+          launcher = child_launcher(parent)
+          launcher.launch!(transform_input(input))
+          results[task_id] = launcher.results
+        end
+      end
+
+      def prepare_batch(input_hash)
+        success_tasks = input_hash.select do |task_id, _input|
+          results[task_id][:result] == 'success'
+        end
+        success_tasks.reduce({}) do |acc, (key, value)|
+          acc.merge(results[key][:task_id] => value['action_input']['callback'])
+        end
+      end
+
+      private
+
+      def child_launcher(parent)
+        Single.new(world, callback, :parent => parent)
+      end
+
+      # Identity by default
+      def transform_input(input)
+        input
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/task_launcher/group.rb

@@ -0,0 +1,47 @@
+require 'foreman_tasks_core/runner'
+
+module ForemanTasksCore
+  module TaskLauncher
+    class AbstractGroup < Batch
+      def self.runner_class
+        raise NotImplementedError
+      end
+
+      def launch!(input)
+        trigger(nil, SingleRunnerBatchAction, self, input)
+      end
+
+      def launch_children(parent, input_hash)
+        super(parent, input_hash)
+        trigger(parent, BatchRunnerAction, self, input_hash)
+      end
+
+      def operation
+        raise NotImplementedError
+      end
+
+      def runner_input(input)
+        input.reduce({}) do |acc, (id, input)|
+          input = { :execution_plan_id => results[id][:task_id],
+                    :run_step_id => 2,
+                    :input => input }
+          acc.merge(id => input)
+        end
+      end
+
+      private
+
+      def child_launcher(parent)
+        Single.new(world, callback, :parent => parent, :action_class_override => OutputCollectorAction)
+      end
+
+      def transform_input(input)
+        wipe_callback(input)
+      end
+
+      def wipe_callback(input)
+        input.merge('action_input' => input['action_input'].merge('callback' => nil))
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/task_launcher/single.rb

@@ -0,0 +1,17 @@
+module ForemanTasksCore
+  module TaskLauncher
+    class Single < Abstract
+      def self.input_format
+        { :action_class => "MyActionClass", :action_input => {} }
+      end
+
+      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/ticker.rb

@@ -1,3 +1,5 @@
+require 'dynflow'
+
 module ForemanTasksCore
   class Ticker < ::Dynflow::Actor
     attr_reader :clock

data/lib/foreman_tasks_core/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasksCore
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.3.5'.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.5
 platform: ruby
 authors:
 - Ivan Nečas
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-02-08 00:00:00.000000000 Z
+date: 2021-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dynflow
@@ -26,7 +26,7 @@ dependencies:
         version: 1.2.0
 description: 'Common code used both at Forman and Foreman proxy regarding tasks
 
-'
+  '
 email:
 - inecas@redhat.com
 executables: []
@@ -35,22 +35,35 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - lib/foreman_tasks_core.rb
+- lib/foreman_tasks_core/batch_action.rb
+- lib/foreman_tasks_core/batch_callback_action.rb
+- lib/foreman_tasks_core/batch_runner_action.rb
 - lib/foreman_tasks_core/continuous_output.rb
 - lib/foreman_tasks_core/otp_manager.rb
+- lib/foreman_tasks_core/output_collector_action.rb
 - lib/foreman_tasks_core/runner.rb
 - lib/foreman_tasks_core/runner/action.rb
 - lib/foreman_tasks_core/runner/base.rb
+- lib/foreman_tasks_core/runner/command.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/single_runner_batch_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/group.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
-licenses: []
+licenses:
+- GPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -65,9 +78,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Common code used both at Forman and Foreman proxy regarding tasks
 test_files: []