smart_proxy_dynflow 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3c381a5358391ea92bacf8c59c3a279b49a50a49369bd962c0ff94e7c4d459e
-  data.tar.gz: 3d83db86f0ce2a76b5d1e1f4ca5afd57eb82a5b327ba1ad2f561c77217e4ae0f
+  metadata.gz: be2013a41681b30175177e9bcdb2bdc24186e6b6edccf3dcbdadcb5ca006f49b
+  data.tar.gz: 7c54a27ae6b0055cdd5b1189a8c89a1c644626fbe0386a9e48e3a48da3ebf71e
 SHA512:
-  metadata.gz: da9ce875255e93fcc491fc438eb6cbe3fb0b803b6524539a71575f47b29e0a65bcffb1378a6bacc3eee85e4c5194a3d0e3a9f77faff3fe5a82211f4242f671ea
-  data.tar.gz: 55b4f92fdf94ca2b0cde9282f02be12d167674bd358729bd26a766d320a45de0dcc2f8535d94dc31b164963691e076b6b3740c60f385b4f9ca18b2d06c8abf82
+  metadata.gz: 6fb8325c06bdac95fbc2b8b3e8b59cb9cf75f43ba71a944dc1cf423a36ea7cfe7a02be1b928f6f2f21728c7de90011cc5c24867dcce58ba90e66bda6396922cc
+  data.tar.gz: 913260f459727549e5559938558f09f398dce1d78e0c7cd42ad596e9da58394d92b2f9ba9dc5dd421371cffa71ae9f4c2038db15d0ce1e6ca4290627910a61ef

data/lib/smart_proxy_dynflow.rb

@@ -3,10 +3,9 @@ require 'dynflow'
 require 'smart_proxy_dynflow/task_launcher_registry'
 require 'smart_proxy_dynflow/middleware/keep_current_request_id'
 
-require 'foreman_tasks_core'
-
 require 'smart_proxy_dynflow/log'
 require 'smart_proxy_dynflow/settings'
+require 'smart_proxy_dynflow/ticker'
 require 'smart_proxy_dynflow/core'
 require 'smart_proxy_dynflow/callback'
 
@@ -16,10 +15,6 @@ require 'smart_proxy_dynflow/helpers'
 require 'smart_proxy_dynflow/api'
 
 module Proxy
-  class Dynflow
-    Core.after_initialize do |dynflow_core|
-      ForemanTasksCore.dynflow_setup(dynflow_core.world)
-    end
-    Core.register_silencer_matchers ForemanTasksCore.silent_dead_letter_matchers
+  module Dynflow
   end
 end

data/lib/smart_proxy_dynflow/action.rb

@@ -0,0 +1,12 @@
+module Proxy::Dynflow
+  module Action
+  end
+end
+
+require 'smart_proxy_dynflow/action/batch'
+require 'smart_proxy_dynflow/action/batch_callback'
+require 'smart_proxy_dynflow/action/batch_runner'
+require 'smart_proxy_dynflow/action/output_collector'
+require 'smart_proxy_dynflow/action/shareable'
+require 'smart_proxy_dynflow/action/runner'
+require 'smart_proxy_dynflow/action/single_runner_batch'

data/lib/smart_proxy_dynflow/action/batch.rb

@@ -0,0 +1,21 @@
+module Proxy::Dynflow::Action
+  class Batch < ::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/smart_proxy_dynflow/action/batch_callback.rb

@@ -0,0 +1,20 @@
+module Proxy::Dynflow::Action
+  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/smart_proxy_dynflow/action/batch_runner.rb

@@ -0,0 +1,14 @@
+require 'smart_proxy_dynflow/action/runner'
+
+module Proxy::Dynflow::Action
+  class BatchRunner < ::Proxy::Dynflow::Action::Runner
+    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/smart_proxy_dynflow/action/output_collector.rb

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

data/lib/smart_proxy_dynflow/action/runner.rb

@@ -0,0 +1,76 @@
+require 'smart_proxy_dynflow/action/shareable'
+module Proxy::Dynflow
+  module Action
+    class Runner < Shareable
+      include ::Dynflow::Action::Cancellable
+
+      def run(event = nil)
+        case event
+        when nil
+          init_run
+        when Proxy::Dynflow::Runner::Update
+          process_update(event)
+        when Proxy::Dynflow::Runner::ExternalEvent
+          process_external_event(event)
+        when ::Dynflow::Action::Cancellable::Cancel
+          kill_run
+        else
+          raise "Unexpected event #{event.inspect}"
+        end
+      rescue => e
+        action_logger.error(e)
+        process_update(Proxy::Dynflow::Runner::Update.encode_exception('Proxy error', e))
+      end
+
+      def finalize
+        # To mark the task as a whole as failed
+        error! 'Script execution failed' if on_proxy? && failed_run?
+      end
+
+      def rescue_strategy_for_self
+        ::Dynflow::Action::Rescue::Fail
+      end
+
+      def initiate_runner
+        raise NotImplementedError
+      end
+
+      def init_run
+        output[:result] = []
+        output[:runner_id] = runner_dispatcher.start(suspended_action, initiate_runner)
+        suspend
+      end
+
+      def runner_dispatcher
+        Proxy::Dynflow::Runner::Dispatcher.instance
+      end
+
+      def kill_run
+        runner_dispatcher.kill(output[:runner_id])
+        suspend
+      end
+
+      def finish_run(update)
+        output[:exit_status] = update.exit_status
+      end
+
+      def process_external_event(event)
+        runner_dispatcher.external_event(output[:runner_id], event)
+        suspend
+      end
+
+      def process_update(update)
+        output[:result].concat(update.continuous_output.raw_outputs)
+        if update.exit_status
+          finish_run(update)
+        else
+          suspend
+        end
+      end
+
+      def failed_run?
+        output[:exit_status] != 0
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/action/shareable.rb

@@ -0,0 +1,25 @@
+module Proxy::Dynflow::Action
+  class Shareable < ::Dynflow::Action
+    def plan(input)
+      input = input.dup
+      callback = input.delete('callback')
+      if callback
+        input[:task_id] = callback['task_id']
+      else
+        input[:task_id] ||= SecureRandom.uuid
+      end
+
+      planned_action = plan_self(input)
+      # code only applicable, when run with SmartProxyDynflowCore in place
+      if on_proxy? && callback
+        plan_action(SmartProxyDynflowCore::Callback::Action, callback, planned_action.output)
+      end
+    end
+
+    private
+
+    def on_proxy?
+      defined?(SmartProxyDynflowCore::Callback)
+    end
+  end
+end

data/lib/smart_proxy_dynflow/action/single_runner_batch.rb

@@ -0,0 +1,39 @@
+module Proxy::Dynflow::Action
+  class SingleRunnerBatch < Batch
+    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/smart_proxy_dynflow/api.rb

@@ -3,7 +3,7 @@ require 'proxy/helpers'
 require 'sinatra/authorization'
 
 module Proxy
-  class Dynflow
+  module Dynflow
     class Api < ::Sinatra::Base
       helpers ::Proxy::Helpers
       helpers ::Proxy::Log

data/lib/smart_proxy_dynflow/callback.rb

@@ -1,6 +1,6 @@
 require 'rest-client'
 
-class Proxy::Dynflow
+module Proxy::Dynflow
   module Callback
     class Request
       class << self

data/lib/smart_proxy_dynflow/continuous_output.rb

@@ -0,0 +1,50 @@
+module Proxy::Dynflow
+  class ContinuousOutput
+    attr_accessor :raw_outputs
+
+    def initialize(raw_outputs = [])
+      @raw_outputs = []
+      raw_outputs.each { |raw_output| add_raw_output(raw_output) }
+    end
+
+    def add_raw_output(raw_output)
+      missing_args = %w[output_type output timestamp] - raw_output.keys
+      unless missing_args.empty?
+        raise ArgumentError, "Missing args for raw output: #{missing_args.inspect}"
+      end
+      @raw_outputs << raw_output
+    end
+
+    def empty?
+      @raw_outputs.empty?
+    end
+
+    def last_timestamp
+      return if @raw_outputs.empty?
+      @raw_outputs.last.fetch('timestamp')
+    end
+
+    def sort!
+      @raw_outputs.sort_by! { |record| record['timestamp'].to_f }
+    end
+
+    def humanize
+      sort!
+      raw_outputs.map { |output| output['output'] }.join("\n")
+    end
+
+    def add_exception(context, exception, timestamp = Time.now.getlocal)
+      add_output(context + ": #{exception.class} - #{exception.message}", 'debug', timestamp)
+    end
+
+    def add_output(*args)
+      add_raw_output(self.class.format_output(*args))
+    end
+
+    def self.format_output(message, type = 'debug', timestamp = Time.now.getlocal)
+      { 'output_type' => type,
+        'output' => message,
+        'timestamp' => timestamp.to_f }
+    end
+  end
+end

data/lib/smart_proxy_dynflow/core.rb

@@ -1,4 +1,4 @@
-class Proxy::Dynflow
+module Proxy::Dynflow
   class Core
     attr_accessor :world, :accepted_cert_serial
 
@@ -75,7 +75,7 @@ class Proxy::Dynflow
       end
 
       def silencer_matchers
-        @matchers ||= []
+        @matchers ||= [::Dynflow::DeadLetterSilencer::Matcher.new(Ticker)]
       end
 
       def register_silencer_matchers(matchers)

data/lib/smart_proxy_dynflow/helpers.rb

@@ -1,5 +1,5 @@
 module Proxy
-  class Dynflow
+  module Dynflow
     module Helpers
       def world
         Proxy::Dynflow::Core.world
@@ -7,12 +7,12 @@ module Proxy
 
       def authorize_with_token(task_id:, clear: true)
         if request.env.key? 'HTTP_AUTHORIZATION'
-          if defined?(::ForemanTasksCore)
+          if defined?(::Proxy::Dynflow)
             auth = request.env['HTTP_AUTHORIZATION']
             basic_prefix = /\ABasic /
             if !auth.to_s.empty? && auth =~ basic_prefix &&
-               ForemanTasksCore::OtpManager.authenticate(auth.gsub(basic_prefix, ''),
-                                                         expected_user: task_id, clear: clear)
+               Proxy::Dynflow::OtpManager.authenticate(auth.gsub(basic_prefix, ''),
+                                                       expected_user: task_id, clear: clear)
               Log.instance.debug('authorized with token')
               return true
             end
@@ -51,7 +51,7 @@ module Proxy
       def dispatch_external_event(task_id, params)
         world.event(task_id,
                     params['step_id'].to_i,
-                    ::ForemanTasksCore::Runner::ExternalEvent.new(params))
+                    ::Proxy::Dynflow::Runner::ExternalEvent.new(params))
       end
     end
   end

data/lib/smart_proxy_dynflow/log.rb

@@ -1,6 +1,6 @@
 require 'logging'
 
-class Proxy::Dynflow
+module Proxy::Dynflow
   class Log
     LOGGER_NAME = 'dynflow-core'.freeze
 

data/lib/smart_proxy_dynflow/otp_manager.rb

@@ -0,0 +1,36 @@
+require 'base64'
+require 'securerandom'
+
+module Proxy::Dynflow
+  class OtpManager
+    class << self
+      def generate_otp(username)
+        otp = SecureRandom.hex
+        passwords[username] = otp.to_s
+      end
+
+      def drop_otp(username, password)
+        passwords.delete(username) if passwords[username] == password
+      end
+
+      def passwords
+        @password ||= {}
+      end
+
+      def authenticate(hash, expected_user: nil, clear: true)
+        plain = Base64.decode64(hash)
+        username, otp = plain.split(':', 2)
+        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)
+        Base64.strict_encode64("#{username}:#{password}")
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/plugin.rb

@@ -2,7 +2,7 @@ require 'proxy/log'
 require 'proxy/pluggable'
 require 'proxy/plugin'
 
-class Proxy::Dynflow
+module Proxy::Dynflow
   class Plugin < Proxy::Plugin
     rackup_path = File.expand_path('http_config.ru', __dir__)
     http_rackup_path rackup_path
@@ -15,6 +15,11 @@ class Proxy::Dynflow
     plugin :dynflow, Proxy::Dynflow::VERSION
 
     after_activation do
+      require 'smart_proxy_dynflow/settings_loader'
+      require 'smart_proxy_dynflow/otp_manager'
+      require 'smart_proxy_dynflow/action'
+      require 'smart_proxy_dynflow/task_launcher'
+
       Proxy::Dynflow::Core.ensure_initialized
     end
   end

data/lib/smart_proxy_dynflow/proxy_adapter.rb

@@ -1,5 +1,5 @@
 module Proxy
-  class Dynflow
+  module Dynflow
     class ProxyAdapter < ::Dynflow::LoggerAdapters::Simple
       def initialize(logger, level = Logger::DEBUG, formatters = [Formatters::Exception])
         super(nil, level, formatters)

data/lib/smart_proxy_dynflow/runner.rb

@@ -0,0 +1,10 @@
+module Proxy::Dynflow
+  module Runner
+  end
+end
+
+require 'smart_proxy_dynflow/runner/update'
+require 'smart_proxy_dynflow/runner/base'
+require 'smart_proxy_dynflow/runner/dispatcher'
+require 'smart_proxy_dynflow/action/runner'
+require 'smart_proxy_dynflow/runner/parent'

data/lib/smart_proxy_dynflow/runner/base.rb

@@ -0,0 +1,98 @@
+module Proxy::Dynflow
+  module Runner
+    # Runner is an object that is able to initiate some action and
+    # provide update data on refresh call.
+    class Base
+      attr_reader :id
+      attr_writer :logger
+
+      def initialize(*_args, suspended_action: nil)
+        @suspended_action = suspended_action
+        @id = SecureRandom.uuid
+        initialize_continuous_outputs
+      end
+
+      def logger
+        @logger ||= Logger.new(STDERR)
+      end
+
+      def run_refresh
+        logger.debug('refreshing runner')
+        refresh
+        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
+        raise NotImplementedError
+      end
+
+      def refresh
+        raise NotImplementedError
+      end
+
+      def kill
+        # Override when you can kill the runner in the middle
+      end
+
+      def close
+        # if cleanup is needed
+      end
+
+      def timeout
+        # Override when timeouts and regular kills should be handled differently
+        publish_data('Timeout for execution passed, trying to stop the job', 'debug')
+        kill
+      end
+
+      def timeout_interval
+        # A number of seconds after which the runner should receive a #timeout
+        #   or nil for no timeout
+      end
+
+      def publish_data(data, type)
+        @continuous_output.add_output(data, type)
+      end
+
+      def publish_exception(context, exception, fatal = true)
+        logger.error("#{context} - #{exception.class} #{exception.message}:\n" + \
+                     exception.backtrace.join("\n"))
+        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 = Proxy::Dynflow::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 = ::Proxy::Dynflow::ContinuousOutput.new
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/runner/command.rb

@@ -0,0 +1,40 @@
+module Proxy::Dynflow
+  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.positive?
+            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/smart_proxy_dynflow/runner/command_runner.rb

@@ -0,0 +1,11 @@
+require 'io/wait'
+require 'pty'
+require 'smart_proxy_dynflow/runner/command'
+
+module Proxy::Dynflow
+  module Runner
+    class CommandRunner < Base
+      include Command
+    end
+  end
+end

data/lib/smart_proxy_dynflow/runner/dispatcher.rb

@@ -0,0 +1,191 @@
+require 'smart_proxy_dynflow/ticker'
+
+module Proxy::Dynflow
+  module Runner
+    class Dispatcher
+      def self.instance
+        return @instance if @instance
+        @instance = new(Proxy::Dynflow::Core.world.clock,
+                        Proxy::Dynflow::Core.world.logger)
+      end
+
+      class RunnerActor < ::Dynflow::Actor
+        def initialize(dispatcher, suspended_action, runner, clock, logger, _options = {})
+          @dispatcher = dispatcher
+          @clock = clock
+          @ticker = dispatcher.ticker
+          @logger = logger
+          @suspended_action = suspended_action
+          @runner = runner
+          @finishing = false
+        end
+
+        def on_envelope(*args)
+          super
+        rescue => e
+          handle_exception(e)
+        end
+
+        def start_runner
+          @logger.debug("start runner #{@runner.id}")
+          set_timeout if @runner.timeout_interval
+          @runner.start
+          refresh_runner
+        ensure
+          plan_next_refresh
+        end
+
+        def refresh_runner
+          @logger.debug("refresh runner #{@runner.id}")
+          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&.exit_status
+        end
+
+        def timeout_runner
+          @logger.debug("timeout runner #{@runner.id}")
+          @runner.timeout
+        rescue => e
+          handle_exception(e, false)
+        end
+
+        def kill
+          @logger.debug("kill runner #{@runner.id}")
+          @runner.kill
+        rescue => e
+          handle_exception(e, false)
+        end
+
+        def finish
+          @logger.debug("finish runner #{@runner.id}")
+          @finishing = true
+          @dispatcher.finish(@runner.id)
+        end
+
+        def start_termination(*args)
+          @logger.debug("terminate #{@runner.id}")
+          super
+          @runner.close
+          finish_termination
+        end
+
+        def external_event(event)
+          dispatch_updates(@runner.external_event(event))
+        end
+
+        private
+
+        def set_timeout
+          timeout_time = Time.now.getlocal + @runner.timeout_interval
+          @logger.debug("setting timeout for #{@runner.id} to #{timeout_time}")
+          @clock.ping(reference, timeout_time, :timeout_runner)
+        end
+
+        def plan_next_refresh
+          if !@finishing && !@refresh_planned
+            @logger.debug("planning to refresh #{@runner.id}")
+            @ticker.tell([:add_event, reference, :refresh_runner])
+            @refresh_planned = true
+          end
+        end
+
+        def handle_exception(exception, fatal = true)
+          @dispatcher.handle_command_exception(@runner.id, exception, fatal)
+        end
+      end
+
+      attr_reader :ticker
+      def initialize(clock, logger)
+        @mutex  = Mutex.new
+        @clock  = clock
+        @logger = logger
+        @ticker = ::Proxy::Dynflow::Ticker.spawn('dispatcher-ticker', @clock, @logger, refresh_interval)
+        @runner_actors = {}
+        @runner_suspended_actions = {}
+      end
+
+      def synchronize(&block)
+        @mutex.synchronize(&block)
+      end
+
+      def start(suspended_action, runner)
+        synchronize do
+          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
+          runner_actor = @runner_actors[runner_id]
+          runner_actor&.tell(:kill)
+        rescue => exception
+          _handle_command_exception(runner_id, exception, false)
+        end
+      end
+
+      def finish(runner_id)
+        synchronize do
+          _finish(runner_id)
+        rescue => exception
+          _handle_command_exception(runner_id, exception, false)
+        end
+      end
+
+      def external_event(runner_id, external_event)
+        synchronize do
+          runner_actor = @runner_actors[runner_id]
+          runner_actor&.tell([:external_event, external_event])
+        end
+      end
+
+      def handle_command_exception(*args)
+        synchronize { _handle_command_exception(*args) }
+      end
+
+      def refresh_interval
+        1
+      end
+
+      private
+
+      def _finish(runner_id)
+        runner_actor = @runner_actors.delete(runner_id)
+        return unless runner_actor
+        @logger.debug("closing session for command [#{runner_id}]," \
+                      "#{@runner_actors.size} actors left ")
+        runner_actor.tell([:start_termination, Concurrent::Promises.resolvable_future])
+      ensure
+        @runner_suspended_actions.delete(runner_id)
+      end
+
+      def _handle_command_exception(runner_id, exception, fatal = true)
+        @logger.error("error while dispatching request to runner #{runner_id}:"\
+                      "#{exception.class} #{exception.message}:\n #{exception.backtrace.join("\n")}")
+        suspended_action = @runner_suspended_actions[runner_id]
+        if suspended_action
+          suspended_action << Runner::Update.encode_exception('Runner error', exception, fatal)
+        end
+        _finish(runner_id) if fatal
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/runner/parent.rb

@@ -0,0 +1,57 @@
+module Proxy::Dynflow
+  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(Proxy::Dynflow::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] = Proxy::Dynflow::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 => Proxy::Dynflow::ContinuousOutput.new)
+        end
+      end
+
+      def host_action(identifier)
+        options = @targets[identifier].slice('execution_plan_id', 'run_step_id')
+                                      .merge(:world => Proxy::Dynflow::Core.world)
+        Dynflow::Action::Suspended.new OpenStruct.new(options)
+      end
+
+      def broadcast_data(data, type)
+        @outputs.each_value { |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.each_value { |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/smart_proxy_dynflow/runner/update.rb

@@ -0,0 +1,28 @@
+require 'smart_proxy_dynflow/continuous_output'
+
+module Proxy::Dynflow
+  module Runner
+    # Runner::Update represents chunk of data produced by runner that
+    # can be consumed by other components, such as RunnerAction
+    class Update
+      attr_reader :continuous_output, :exit_status
+      def initialize(continuous_output, exit_status)
+        @continuous_output = continuous_output
+        @exit_status = exit_status
+      end
+
+      def self.encode_exception(context, exception, fatal = true)
+        continuous_output = ::Proxy::Dynflow::ContinuousOutput.new
+        continuous_output.add_exception(context, exception)
+        new(continuous_output, fatal ? 'EXCEPTION' : nil)
+      end
+    end
+
+    class ExternalEvent
+      attr_reader :data
+      def initialize(data = {})
+        @data = data
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/settings.rb

@@ -1,6 +1,6 @@
 # require 'ostruct'
 
-class Proxy::Dynflow
+module Proxy::Dynflow
   class Settings
     def self.instance
       Proxy::Dynflow::Plugin.settings

data/lib/smart_proxy_dynflow/settings_loader.rb

@@ -0,0 +1,53 @@
+module Proxy::Dynflow
+  module SettingsLoader
+    def self.settings_registry
+      @settings_registry ||= {}
+    end
+
+    def self.name_to_settings
+      @name_to_settings ||= {}
+    end
+
+    def self.settings_keys
+      @settings_keys ||= []
+    end
+
+    def self.settings_registered?(name)
+      name_to_settings.key?(name)
+    end
+
+    def self.register_settings(names, object)
+      names = [names] unless names.is_a? Array
+      names.each do |name|
+        raise 'settings name has to be a symbol' unless name.is_a? Symbol
+        raise "settings #{name} already registered" if SettingsLoader.settings_registered?(name)
+        name_to_settings[name] = object
+      end
+      settings_registry[names] = object
+    end
+
+    def self.setup_settings(name, settings)
+      raise "Settings for #{name} were not registered" unless settings_registered?(name)
+      name_to_settings[name].initialize_settings(settings)
+    end
+
+    def register_settings(names, defaults = {})
+      SettingsLoader.register_settings(names, self)
+      @defaults = defaults
+    end
+
+    def initialize_settings(settings = {})
+      @settings = @defaults.merge(settings)
+      validate_settings!
+    end
+
+    def settings
+      raise "Settings for #{self} not initalized" unless @settings
+      @settings
+    end
+
+    def validate_settings!
+      raise 'Only symbols expected in keys' unless @settings.keys.all? { |key| key.is_a? Symbol }
+    end
+  end
+end

data/lib/smart_proxy_dynflow/task_launcher.rb

@@ -0,0 +1,9 @@
+module Proxy::Dynflow
+  module TaskLauncher
+  end
+end
+
+require 'smart_proxy_dynflow/task_launcher/abstract'
+require 'smart_proxy_dynflow/task_launcher/single'
+require 'smart_proxy_dynflow/task_launcher/batch'
+require 'smart_proxy_dynflow/task_launcher/group'

data/lib/smart_proxy_dynflow/task_launcher/abstract.rb

@@ -0,0 +1,44 @@
+module Proxy::Dynflow
+  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/smart_proxy_dynflow/task_launcher/batch.rb

@@ -0,0 +1,37 @@
+module Proxy::Dynflow
+  module TaskLauncher
+    class Batch < Abstract
+      def launch!(input)
+        trigger(nil, Proxy::Dynflow::Action::Batch, 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/smart_proxy_dynflow/task_launcher/group.rb

@@ -0,0 +1,48 @@
+require 'smart_proxy_dynflow/runner'
+
+module Proxy::Dynflow
+  module TaskLauncher
+    class AbstractGroup < Batch
+      def self.runner_class
+        raise NotImplementedError
+      end
+
+      def launch!(input)
+        trigger(nil, Action::SingleRunnerBatch, self, input)
+      end
+
+      def launch_children(parent, input_hash)
+        super(parent, input_hash)
+        trigger(parent, Action::BatchRunner, 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 => Action::OutputCollector)
+      end
+
+      def transform_input(input)
+        wipe_callback(input)
+      end
+
+      def wipe_callback(input)
+        callback = input['action_input']['callback']
+        input.merge('action_input' => input['action_input'].merge('callback' => nil, :task_id => callback['task_id']))
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/task_launcher/single.rb

@@ -0,0 +1,17 @@
+module Proxy::Dynflow
+  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/smart_proxy_dynflow/task_launcher_registry.rb

@@ -1,4 +1,4 @@
-class Proxy::Dynflow
+module Proxy::Dynflow
   class TaskLauncherRegistry
     class << self
       def register(name, launcher)

data/lib/smart_proxy_dynflow/testing.rb

@@ -4,7 +4,7 @@ unless defined? DYNFLOW_TESTING_LOG_LEVEL
   DYNFLOW_TESTING_LOG_LEVEL = 4
 end
 
-class Proxy::Dynflow
+module Proxy::Dynflow
   # Helper for usage in other dependent plugins that need Dynflow
   # related things, such as testing instance of world etc.
   module Testing

data/lib/smart_proxy_dynflow/ticker.rb

@@ -0,0 +1,47 @@
+require 'dynflow'
+
+module Proxy::Dynflow
+  class Ticker < ::Dynflow::Actor
+    attr_reader :clock
+
+    def initialize(clock, logger, refresh_interval)
+      @clock = clock
+      @logger = logger
+      @events = []
+      @refresh_interval = refresh_interval
+      plan_next_tick
+    end
+
+    def tick
+      @logger.debug("Ticker ticking for #{@events.size} events")
+      @events.each do |(target, args)|
+        pass_event(target, args)
+      end
+      @events = []
+    ensure
+      @planned = false
+      plan_next_tick
+    end
+
+    def add_event(target, args)
+      @events << [target, args]
+      plan_next_tick
+    end
+
+    private
+
+    def pass_event(target, args)
+      target.tell(args)
+    rescue => e
+      @logger.error("Failed passing event to #{target} with #{args}")
+      @logger.error(e)
+    end
+
+    def plan_next_tick
+      if !@planned && !@events.empty?
+        @clock.ping(reference, Time.now.getlocal + @refresh_interval, :tick)
+        @planned = true
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/version.rb

@@ -1,5 +1,5 @@
 module Proxy
-  class Dynflow
-    VERSION = '0.4.0'.freeze
+  module Dynflow
+    VERSION = '0.5.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dynflow
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-07 00:00:00.000000000 Z
+date: 2021-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logging
@@ -119,18 +119,42 @@ files:
 - LICENSE
 - bundler.plugins.d/dynflow.rb
 - lib/smart_proxy_dynflow.rb
+- lib/smart_proxy_dynflow/action.rb
+- lib/smart_proxy_dynflow/action/batch.rb
+- lib/smart_proxy_dynflow/action/batch_callback.rb
+- lib/smart_proxy_dynflow/action/batch_runner.rb
+- lib/smart_proxy_dynflow/action/output_collector.rb
+- lib/smart_proxy_dynflow/action/runner.rb
+- lib/smart_proxy_dynflow/action/shareable.rb
+- lib/smart_proxy_dynflow/action/single_runner_batch.rb
 - lib/smart_proxy_dynflow/api.rb
 - lib/smart_proxy_dynflow/callback.rb
+- lib/smart_proxy_dynflow/continuous_output.rb
 - lib/smart_proxy_dynflow/core.rb
 - lib/smart_proxy_dynflow/helpers.rb
 - lib/smart_proxy_dynflow/http_config.ru
 - lib/smart_proxy_dynflow/log.rb
 - lib/smart_proxy_dynflow/middleware/keep_current_request_id.rb
+- lib/smart_proxy_dynflow/otp_manager.rb
 - lib/smart_proxy_dynflow/plugin.rb
 - lib/smart_proxy_dynflow/proxy_adapter.rb
+- lib/smart_proxy_dynflow/runner.rb
+- lib/smart_proxy_dynflow/runner/base.rb
+- lib/smart_proxy_dynflow/runner/command.rb
+- lib/smart_proxy_dynflow/runner/command_runner.rb
+- lib/smart_proxy_dynflow/runner/dispatcher.rb
+- lib/smart_proxy_dynflow/runner/parent.rb
+- lib/smart_proxy_dynflow/runner/update.rb
 - lib/smart_proxy_dynflow/settings.rb
+- lib/smart_proxy_dynflow/settings_loader.rb
+- lib/smart_proxy_dynflow/task_launcher.rb
+- lib/smart_proxy_dynflow/task_launcher/abstract.rb
+- lib/smart_proxy_dynflow/task_launcher/batch.rb
+- lib/smart_proxy_dynflow/task_launcher/group.rb
+- lib/smart_proxy_dynflow/task_launcher/single.rb
 - lib/smart_proxy_dynflow/task_launcher_registry.rb
 - lib/smart_proxy_dynflow/testing.rb
+- lib/smart_proxy_dynflow/ticker.rb
 - lib/smart_proxy_dynflow/version.rb
 - settings.d/dynflow.yml.example
 homepage: https://github.com/theforeman/smart_proxy_dynflow