smart_proxy_dynflow 0.6.3 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6673ce798c24b310ce2b132ac1c07cddbdfbd49ac9b0dd8e0e8abbc0312b2a0c
-  data.tar.gz: b966221317f31e9e32ba85a77d8f26c64ae238d35d99548da8e9647da5b092a5
+  metadata.gz: 0c9cd93e1cf950c5f7977d700a2d8b307faa98182af93063c55ced580617d054
+  data.tar.gz: 2de7767e855c5914d6db7678ef2c2302c414a20b04cb6dd4df7294263ee00f95
 SHA512:
-  metadata.gz: e05968e12c48d7b997d60231cc541d4bb0ae13a3f2ba8a1b586af0a0a1232086cd09cceb5b49e10deb68bd8dfe65817a925b09a44f022126a7695316532bf89d
-  data.tar.gz: ea263ed0aa2e2ca216c85385c7ec00e66cca6df6ca569cc6dda67f98fe1c5ef0d30eea3510b6227fdc69f61a9619b949265bd2f286a036a8d3f09520ed004326
+  metadata.gz: b03995ac1c1bf44c900926371d3b42c56f05dc8b994fb07f3c87613e788a990e9ec597d67bb24a97279ae4bc0557fca01dabfbaace26299553467f8173ff8f73
+  data.tar.gz: 0d4737d0298d940988c51ba62e04c45740530660ae76c492e706459965446e984f2ddeb319651a416864636dca407d4f281029bb75da9ad747da7f6b6d71ee42

data/lib/smart_proxy_dynflow/action/batch.rb

@@ -3,15 +3,16 @@ module Proxy::Dynflow::Action
     include Dynflow::Action::WithSubPlans
     include Dynflow::Action::WithPollingSubPlans
 
-    # { task_id => { :action_class => Klass, :input => input } }
+    # { execution_plan_uuid => { :action_class => Klass, :input => input } }
     def plan(launcher, input_hash)
-      launcher.launch_children(self, input_hash)
-      plan_self
+      plan_self :input_hash => input_hash,
+                :launcher => launcher.to_hash
     end
 
-    def initiate
-      ping suspended_action
-      wait_for_sub_plans sub_plans
+    def create_sub_plans
+      Proxy::Dynflow::TaskLauncher::Abstract
+        .new_from_hash(world, input[:launcher])
+        .launch_children(self, input[:input_hash])
     end
 
     def rescue_strategy

data/lib/smart_proxy_dynflow/action/batch_callback.rb

@@ -1,7 +1,12 @@
 module Proxy::Dynflow::Action
   class BatchCallback < ::Dynflow::Action
     def plan(input_hash, results)
-      plan_self :targets => input_hash, :results => results
+      # In input_hash there are complete inputs for all the actions for which this is reporting
+      # Trim it down to only the bare minimum we actually need
+      callbacks = input_hash.reduce({}) do |acc, (key, value)|
+        acc.merge(key => value['action_input']['callback'])
+      end
+      plan_self :targets => callbacks, :results => results
     end
 
     def run

data/lib/smart_proxy_dynflow/action/batch_runner.rb

@@ -2,13 +2,13 @@ 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
+    def plan(launcher, input, runner_id)
+      plan_self :targets => launcher.runner_input(input), :operation => launcher.operation, :runner_id => runner_id
     end
 
     def initiate_runner
       launcher = Proxy::Dynflow::TaskLauncherRegistry.fetch(input[:operation])
-      launcher.runner_class.new(input[:targets], suspended_action: suspended_action)
+      launcher.runner_class.new(input[:targets], suspended_action: suspended_action, id: input[:runner_id])
     end
   end
 end

data/lib/smart_proxy_dynflow/action/external_polling.rb

@@ -0,0 +1,16 @@
+module Proxy::Dynflow::Action
+  module WithExternalPolling
+    Poll = Algebrick.atom
+
+    def run(event = nil)
+      if event.is_a?(Poll)
+        poll
+        suspend
+      else
+        super
+      end
+    end
+
+    def poll; end
+  end
+end

data/lib/smart_proxy_dynflow/action/output_collector.rb

@@ -2,6 +2,7 @@ module Proxy::Dynflow::Action
   class OutputCollector < ::Proxy::Dynflow::Action::Runner
     def init_run
       output[:result] = []
+      output[:runner_id] = input[:runner_id]
       suspend
     end
   end

data/lib/smart_proxy_dynflow/action/runner.rb

@@ -1,8 +1,10 @@
 require 'smart_proxy_dynflow/action/shareable'
+require 'smart_proxy_dynflow/action/external_polling'
 module Proxy::Dynflow
   module Action
     class Runner < Shareable
       include ::Dynflow::Action::Cancellable
+      include ::Proxy::Dynflow::Action::WithExternalPolling
 
       def run(event = nil)
         case event
@@ -14,6 +16,9 @@ module Proxy::Dynflow
           process_external_event(event)
         when ::Dynflow::Action::Cancellable::Cancel
           kill_run
+        when ::Proxy::Dynflow::Action::WithExternalPolling::Poll
+          poll
+          suspend
         else
           raise "Unexpected event #{event.inspect}"
         end
@@ -69,6 +74,10 @@ module Proxy::Dynflow
         end
       end
 
+      def poll
+        runner_dispatcher.refresh_output(output[:runner_id])
+      end
+
       def failed_run?
         output[:exit_status] != 0
       end

data/lib/smart_proxy_dynflow/action/single_runner_batch.rb

@@ -1,20 +1,8 @@
 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
+      results = super
+      plan_action BatchCallback, input_hash, results.output[:results]
     end
 
     def check_for_errors!(optional = true)

data/lib/smart_proxy_dynflow/core.rb

@@ -1,3 +1,5 @@
+require 'fileutils'
+
 module Proxy::Dynflow
   class Core
     attr_accessor :world, :accepted_cert_serial
@@ -29,6 +31,7 @@ module Proxy::Dynflow
         Log.instance.warn "Could not open DB for dynflow at '#{db_file}', " \
                           "will keep data in memory. Restart will drop all dynflow data."
       else
+        FileUtils.mkdir_p(File.dirname(db_file))
         db_conn_string += "/#{db_file}"
       end
 

data/lib/smart_proxy_dynflow/helpers.rb

@@ -36,9 +36,8 @@ module Proxy
       def task_status(task_id)
         ep = world.persistence.load_execution_plan(task_id)
         actions = ep.actions.map do |action|
-          hash = action.to_hash
-          hash[:output][:result] = action.output_result if action.is_a?(Proxy::Dynflow::Action::Runner)
-          hash
+          refresh_output(ep, action)
+          expand_output(action)
         end
         ep.to_hash.merge(:actions => actions)
       rescue KeyError => _e
@@ -58,6 +57,18 @@ module Proxy
                     params['step_id'].to_i,
                     ::Proxy::Dynflow::Runner::ExternalEvent.new(params))
       end
+
+      def refresh_output(execution_plan, action)
+        if action.is_a?(Proxy::Dynflow::Action::WithExternalPolling) && %i[running suspended].include?(action.run_step&.state)
+          world.event(execution_plan.id, action.run_step_id, Proxy::Dynflow::Action::WithExternalPolling::Poll)
+        end
+      end
+
+      def expand_output(action)
+        hash = action.to_hash
+        hash[:output][:result] = action.output_result if action.is_a?(Proxy::Dynflow::Action::Runner)
+        hash
+      end
     end
   end
 end

data/lib/smart_proxy_dynflow/io_buffer.rb

@@ -0,0 +1,115 @@
+module Proxy
+  module Dynflow
+    # A buffer around an IO object providing buffering and convenience methods
+    # for non-blocking reads and writes.
+    #
+    # @note Using a single IOBuffer with a single IO for both reads and writes might not be a good idea. If you need to use a single IO for both reads and writes, wrap it in two separate IOBuffers.
+    #
+    # @attr_accessor [IO] io The IO which the buffer wraps
+    # @attr_reader [String] buffer The buffer where the data read from the underlying IO is buffered
+    class IOBuffer
+      attr_accessor :io
+      attr_reader :buffer
+
+      # @param [IO] io The IO object to be buffered
+      def initialize(io)
+        @buffer = ''
+        @io = io
+      end
+
+      # Sets a callback to be executed each time data is read from the
+      # underlying IO.
+      #
+      # @note Note that if the callback is provided, the buffer will store the return value of the callback instead of the raw data.
+      #
+      # @yieldparam [String] data read from the underlying IO
+      # @yieldreturn [String] data to be buffered
+      # @return [void]
+      def on_data(&block)
+        @callback = block
+      end
+
+      # Exposes the underlying IO so that the buffer itself can be used in IO.select calls.
+      #
+      # @return [IO] the underlying IO
+      def to_io
+        @io
+      end
+
+      # Exposes the contents of the buffer as a String
+      #
+      # @return [String] the buffered data
+      def to_s
+        @buffer
+      end
+
+      # Checks whether the buffer is empty
+      #
+      # @return [true, false] whether the buffer is empty
+      def empty?
+        @buffer.empty?
+      end
+
+      # Checks whether the underlying IO is empty
+      #
+      # @return [true, false] whether the underlying IO is empty
+      def closed?
+        @io.closed?
+      end
+
+      # Closes the underlying IO. Does nothing if the IO is already closed.
+      #
+      # @return [void]
+      def close
+        @io.close unless @io.closed?
+      end
+
+      # Reads all the data that is currently waiting in the IO and stores it. If
+      # EOFError is encountered during the read, the underlying IO is closed.
+      #
+      # @return [void]
+      def read_available!
+        data = ''
+        loop { data += @io.read_nonblock(4096) }
+      rescue IO::WaitReadable # rubocop:disable Lint/HandleExceptions
+      rescue EOFError
+        close
+      ensure
+        @buffer += with_callback(data) unless data.empty?
+      end
+
+      # Writes all the data into the IO that can be written without blocking. It
+      # is a no-op if there are no data to be written. If an EOFError is
+      # encountered during the write, the underlying IO is closed.
+      #
+      # @return [void]
+      def write_available!
+        until @buffer.empty?
+          n = @io.write_nonblock(@buffer)
+          @buffer = @buffer[n..-1]
+        end
+      rescue IO::WaitWritable # rubocop:disable Lint/HandleExceptions
+      rescue EOFError
+        close
+      end
+
+      # Adds data to the buffer. If the buffer is used for writing, then this
+      # should be the preferred method of queueing the data to be written.
+      #
+      # @return [void]
+      def add_data(data)
+        @buffer += data
+      end
+
+      private
+
+      def with_callback(data)
+        if @callback
+          @callback.call(data)
+        else
+          data
+        end
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/plugin.rb

@@ -14,6 +14,8 @@ module Proxy::Dynflow
                      :execution_plan_cleaner_age => 60 * 30
     plugin :dynflow, Proxy::Dynflow::VERSION
 
+    capability(proc { self.available_operations })
+
     after_activation do
       require 'smart_proxy_dynflow/settings_loader'
       require 'smart_proxy_dynflow/otp_manager'
@@ -25,5 +27,9 @@ module Proxy::Dynflow
 
       Proxy::Dynflow::Core.ensure_initialized
     end
+
+    def self.available_operations
+      TaskLauncherRegistry.operations
+    end
   end
 end

data/lib/smart_proxy_dynflow/process_manager.rb

@@ -0,0 +1,168 @@
+require 'smart_proxy_dynflow/io_buffer'
+
+module Proxy
+  module Dynflow
+    # An abstraction for managing local processes.
+    #
+    # It can be used to:
+    # - spawn a local process
+    # - track its lifecycle
+    # - communicate with it through its standard input, output and error
+    # - step through the execution one event at a time or start the child process and wait until it finishes
+    #
+    # @example Run date command and collect its output
+    #   pm = ProcessManager.new('date')
+    #   pm.run!
+    #   pm.status #=> 0
+    #   pm.stdout.to_s.chomp #=> "Thu Feb  3 04:27:42 PM CET 2022"
+    #
+    # @example Run a shell loop, outputting all the lines it generates
+    #   pm = ProcessManager.new(['/bin/sh', '-c', 'for i in 1 2 3; do echo $i; sleep 1; done'])
+    #   pm.on_stdout { |data| puts data; '' }
+    #   pm.run!
+    #   #=> 1
+    #   #=> 2
+    #   #=> 3
+    #
+    # @example Run bc (calculator) interactively and count down from 10 to 0
+    #   pm = ProcessManager.new('bc')
+    #   pm.on_stdout do |data|
+    #     if data.match?(/^\d+/)
+    #       n = data.to_i
+    #       if n.zero?
+    #         pm.stdin.to_io.close
+    #       else
+    #         pm.stdin.add_data("#{n} - 1\n")
+    #       end
+    #     end
+    #     data
+    #   end
+    #   pm.stdin.add_data("10\n")
+    #   pm.run!
+    #   pm.stdout.to_s.lines #=. ["10\n", "9\n", "8\n", "7\n", "6\n", "5\n", "4\n", "3\n", "2\n", "1\n", "0\n"]
+    #
+    # @attr_reader [Proxy::Dynflow::IOBuffer] stdin IOBuffer buffering writes to child process' standard input
+    # @attr_reader [Proxy::Dynflow::IOBuffer] stdout IOBuffer buffering reads from child process' standard output
+    # @attr_reader [Proxy::Dynflow::IOBuffer] stderr IOBuffer buffering reads from child process' standard error
+    # @attr_reader [nil, Integer] pid Process id of the child process, nil if the process was not started yet, -1 if the process could not be started
+    # @attr_reader [nil, Integer] status Exit status of the child process. nil if the child process has not finished yet, 255 if the process could not be started
+    class ProcessManager
+      attr_reader :stdin, :stdout, :stderr, :pid, :status
+
+      # @param [String, [String], [Hash, String]] command A command to run in one of the forms accepted by Kernel.spawn
+      def initialize(command)
+        @command = command
+        @stdin  = IOBuffer.new(nil)
+        @stdout = IOBuffer.new(nil)
+        @stderr = IOBuffer.new(nil)
+      end
+
+      # Starts the process manager and runs it until it finishes
+      #
+      # @return [ProcessManager] the process manager itself to allow method chaining
+      def run!
+        start! unless started?
+        process until done?
+        self
+      end
+
+      # Starts the child process. It creates 3 pipes for communicating with the
+      # child process and the forks it. The process manager is considered done
+      # if the child process cannot be started.
+      #
+      # @return [void]
+      def start!
+        in_read,  in_write  = IO.pipe
+        out_read, out_write = IO.pipe
+        err_read, err_write = IO.pipe
+
+        @stdin.io  = in_write
+        @stdout.io = out_read
+        @stderr.io = err_read
+
+        @pid = spawn(*@command, :in => in_read, :out => out_write, :err => err_write)
+        [in_read, out_write, err_write].each(&:close)
+      rescue Errno::ENOENT => e
+        [in_read, in_write, out_read, out_write, err_read, err_write].each(&:close)
+        @pid = -1
+        @status = 255
+        @stderr.add_data(e.message)
+      end
+
+      # Determines whether the process manager already forked off its child process
+      #
+      # @return [true, false] whether the process manager already forked off its child process
+      def started?
+        !pid.nil?
+      end
+
+      # Determines whether the child process of the process manager already finished
+      #
+      # @return [true, false] whether the child process of the process manager already finished
+      def done?
+        started? && !status.nil?
+      end
+
+      # Runs a single iteration of the manager's processing loop. It waits until either:
+      # - data is available in pipes connected to the child process' standard output or error
+      # - there is pending data to be written and the pipe connected to the child process' standard input is writable
+      # - a timeout is reached
+      #
+      # After the wait, all pending data is read and written.
+      #
+      # If all the pipes connected to the child process are closed, it marks the
+      # execution as complete and performs cleanup.
+      #
+      # @param timeout [nil, Numeric] controls how long this call should wait for data to become available. Waits indefinitely if nil.
+      # @return [void]
+      def process(timeout: nil)
+        raise 'Cannot process until the manager is started' unless started?
+        writers = [@stdin].reject { |buf| buf.empty? || buf.closed? }
+        readers = [@stdout, @stderr].reject(&:closed?)
+
+        if readers.empty? && writers.empty?
+          finish
+          return
+        end
+
+        ready_readers, ready_writers = IO.select(readers, writers, nil, timeout)
+        (ready_readers || []).each(&:read_available!)
+        (ready_writers || []).each(&:write_available!)
+      end
+
+      # Sets block to be executed each time data is read from child process' standard output
+      #
+      # @return [void]
+      def on_stdout(&block)
+        @stdout.on_data(&block)
+      end
+
+      # Sets block to be executed each time data is read from child process' standard error
+      #
+      # @return [void]
+      def on_stderr(&block)
+        @stderr.on_data(&block)
+      end
+
+      # Makes the process manager close all the pipes it may have opened to communicate with the child process
+      #
+      # @return [void]
+      def close
+        [@stdin, @stdout, @stderr].each(&:close)
+      end
+
+      private
+
+      # Makes the process manager finish its run, closing opened FDs and reaping the child process
+      #
+      # @return [void]
+      def finish
+        close
+        unless @pid == -1
+          _pid, status = Process.wait2(@pid)
+          @status = status.exitstatus
+        end
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/runner/base.rb

@@ -6,9 +6,9 @@ module Proxy::Dynflow
       attr_reader :id
       attr_writer :logger
 
-      def initialize(*_args, suspended_action: nil)
+      def initialize(*_args, suspended_action: nil, id: nil)
         @suspended_action = suspended_action
-        @id = SecureRandom.uuid
+        @id = id || SecureRandom.uuid
         initialize_continuous_outputs
       end
 
@@ -93,6 +93,12 @@ module Proxy::Dynflow
       def initialize_continuous_outputs
         @continuous_output = ::Proxy::Dynflow::ContinuousOutput.new
       end
+
+      def run_refresh_output
+        logger.debug('refreshing runner on demand')
+        refresh
+        generate_updates
+      end
     end
   end
 end

data/lib/smart_proxy_dynflow/runner/command.rb

@@ -1,5 +1,18 @@
 module Proxy::Dynflow
   module Runner
+    # This module expects to be included into a Runner action, where it can be
+    # used to simplify handling of long-running processes. However it tracks the
+    # running process as a group of instance variables, which has served us
+    # reasonably well in the past, but can be rather error prone.
+    #
+    # A better alternative to this is
+    # {::Proxy::Dynflow::Runner::ProcessManagerCommand}. It tracks the whole
+    # execution of a process under a single instance variable and uses a more
+    # robust {::Proxy::Dynflow::ProcessManager} under the hood. It also
+    # maintains the same interface and can be used as a drop-in replacement.
+    #
+    # This module is now soft-deprecated and
+    # {::Proxy::Dynflow::Runner::ProcessManagerCommand} should be used instead.
     module Command
       def initialize_command(*command)
         @command_out, @command_in, @command_pid = PTY.spawn(*command)

data/lib/smart_proxy_dynflow/runner/command_runner.rb

@@ -4,6 +4,7 @@ require 'smart_proxy_dynflow/runner/command'
 
 module Proxy::Dynflow
   module Runner
+    # This class is now soft-deprecated, see {::Proxy::Dynflow::Runner::Command}
     class CommandRunner < Base
       include Command
     end

data/lib/smart_proxy_dynflow/runner/dispatcher.rb

@@ -43,6 +43,11 @@ module Proxy::Dynflow
           plan_next_refresh
         end
 
+        def refresh_output
+          @logger.debug("refresh output #{@runner.id}")
+          dispatch_updates(@runner.run_refresh_output)
+        end
+
         def dispatch_updates(updates)
           updates.each { |receiver, update| (receiver || @suspended_action) << update }
 
@@ -157,6 +162,12 @@ module Proxy::Dynflow
         end
       end
 
+      def refresh_output(runner_id)
+        synchronize do
+          @runner_actors[runner_id]&.tell([:refresh_output])
+        end
+      end
+
       def handle_command_exception(*args)
         synchronize { _handle_command_exception(*args) }
       end

data/lib/smart_proxy_dynflow/runner/parent.rb

@@ -3,10 +3,10 @@ module Proxy::Dynflow
     class Parent < Base
       # targets = { identifier => { :execution_plan_id => "...", :run_step_id => id,
       #                           :input => { ... } }
-      def initialize(targets = {}, suspended_action: nil)
+      def initialize(targets = {}, suspended_action: nil, id: nil)
         @targets = targets
         @exit_statuses = {}
-        super suspended_action: suspended_action
+        super suspended_action: suspended_action, id: id
       end
 
       def generate_updates

data/lib/smart_proxy_dynflow/runner/process_manager_command.rb

@@ -0,0 +1,44 @@
+require 'smart_proxy_dynflow/process_manager'
+
+module Proxy::Dynflow
+  module Runner
+    # A convenience module which should be included into a Runner action. It
+    # leverages {::Proxy::Dynflow::ProcessManager} to reliably keep track of
+    # an external process and collect its output.
+    #
+    # The only expectation from the Runner action is to call
+    # {#initialize_command} somewhere and pass the command to be run to it.
+    module ProcessManagerCommand
+      def initialize_command(*command)
+        @process_manager = ProcessManager.new(command)
+        set_process_manager_callbacks(@process_manager)
+        @process_manager.start!
+        if @process_manager.done? && @process_manager.status == 255
+          exception = RuntimeError.new(@process_manager.stderr.to_s)
+          exception.set_backtrace Thread.current.backtrace
+          publish_exception("Error running command '#{command.join(' ')}'", exception)
+        end
+      end
+
+      def set_process_manager_callbacks(pm)
+        pm.on_stdout do |data|
+          publish_data(data, 'stdout')
+          ''
+        end
+        pm.on_stderr do |data|
+          publish_data(data, 'stderr')
+          ''
+        end
+      end
+
+      def refresh
+        @process_manager.process(timeout: 0.1) unless @process_manager.done?
+        publish_exit_status(@process_manager.status) if @process_manager.done?
+      end
+
+      def close
+        @process_manager&.close
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/task_launcher/abstract.rb

@@ -15,6 +15,14 @@ module Proxy::Dynflow
 
       def self.input_format; end
 
+      def to_hash
+        { :class => self.class.to_s, :callback => callback, :options => options }
+      end
+
+      def self.new_from_hash(world, hash)
+        ::Dynflow::Utils.constantize(hash[:class]).new(world, hash[:callback], hash[:options])
+      end
+
       private
 
       def format_result(result)
@@ -34,9 +42,9 @@ module Proxy::Dynflow
         input.merge(:callback_host => callback)
       end
 
-      def trigger(parent, klass, *input)
+      def trigger(parent, klass, *input, id: nil)
         world.trigger do
-          world.plan_with_options(caller_action: parent, action_class: klass, args: input)
+          world.plan_with_options(caller_action: parent, action_class: klass, args: input, id: id)
         end
       end
     end

data/lib/smart_proxy_dynflow/task_launcher/batch.rb

@@ -2,36 +2,37 @@ module Proxy::Dynflow
   module TaskLauncher
     class Batch < Abstract
       def launch!(input)
-        trigger(nil, Proxy::Dynflow::Action::Batch, self, input)
+        plan = trigger(nil, action_class, self, input)
+        results[:parent] = format_result(plan)
       end
 
       def launch_children(parent, input_hash)
-        input_hash.each do |task_id, input|
+        input_hash.map do |task_id, input|
           launcher = child_launcher(parent)
-          launcher.launch!(transform_input(input))
+          triggered = launcher.launch!(transform_input(input), id: task_id)
           results[task_id] = launcher.results
+          triggered
         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
+        input_hash
       end
 
-      private
-
       def child_launcher(parent)
         Single.new(world, callback, :parent => parent)
       end
 
+      private
+
       # Identity by default
       def transform_input(input)
         input
       end
+
+      def action_class
+        Proxy::Dynflow::Action::Batch
+      end
     end
   end
 end

data/lib/smart_proxy_dynflow/task_launcher/group.rb

@@ -3,17 +3,22 @@ require 'smart_proxy_dynflow/runner'
 module Proxy::Dynflow
   module TaskLauncher
     class AbstractGroup < Batch
+      def initialize(*args)
+        super
+        @runner_id = SecureRandom.uuid
+      end
+
       def self.runner_class
         raise NotImplementedError
       end
 
-      def launch!(input)
-        trigger(nil, Action::SingleRunnerBatch, self, input)
+      def action_class
+        Action::SingleRunnerBatch
       end
 
       def launch_children(parent, input_hash)
         super(parent, input_hash)
-        trigger(parent, Action::BatchRunner, self, input_hash)
+        trigger(parent, Action::BatchRunner, self, input_hash, @runner_id)
       end
 
       def operation
@@ -36,7 +41,8 @@ module Proxy::Dynflow
       end
 
       def transform_input(input)
-        wipe_callback(input)
+        tmp = wipe_callback(input)
+        input.merge('action_input' => tmp['action_input'].merge(:runner_id => @runner_id))
       end
 
       def wipe_callback(input)

data/lib/smart_proxy_dynflow/task_launcher/single.rb

@@ -5,10 +5,11 @@ module Proxy::Dynflow
         { :action_class => "MyActionClass", :action_input => {} }
       end
 
-      def launch!(input)
+      def launch!(input, id: nil)
         triggered = trigger(options[:parent],
                             action_class(input),
-                            with_callback(input.fetch('action_input', {})))
+                            with_callback(input.fetch('action_input', {})),
+                            id: id)
         @results = format_result(triggered)
         triggered
       end

data/lib/smart_proxy_dynflow/version.rb

@@ -1,5 +1,5 @@
 module Proxy
   module Dynflow
-    VERSION = '0.6.3'.freeze
+    VERSION = '0.8.1'.freeze
   end
 end

data/settings.d/dynflow.yml.example

@@ -1,6 +1,6 @@
 ---
 :enabled: true
-:database: /var/lib/foreman-proxy/dynflow/dynflow.sqlite
+:database:
 
 # Require a valid cert to access Dynflow console
 # :console_auth: true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dynflow
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.8.1
 platform: ruby
 authors:
 - Ivan Nečas
@@ -151,6 +151,7 @@ files:
 - 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/external_polling.rb
 - lib/smart_proxy_dynflow/action/output_collector.rb
 - lib/smart_proxy_dynflow/action/runner.rb
 - lib/smart_proxy_dynflow/action/shareable.rb
@@ -161,10 +162,12 @@ files:
 - lib/smart_proxy_dynflow/core.rb
 - lib/smart_proxy_dynflow/helpers.rb
 - lib/smart_proxy_dynflow/http_config.ru
+- lib/smart_proxy_dynflow/io_buffer.rb
 - 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/process_manager.rb
 - lib/smart_proxy_dynflow/proxy_adapter.rb
 - lib/smart_proxy_dynflow/runner.rb
 - lib/smart_proxy_dynflow/runner/base.rb
@@ -172,6 +175,7 @@ files:
 - 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/process_manager_command.rb
 - lib/smart_proxy_dynflow/runner/update.rb
 - lib/smart_proxy_dynflow/settings.rb
 - lib/smart_proxy_dynflow/settings_loader.rb