smart_proxy_dynflow 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9d6cea06294915fa84d7b26d9ece58ee0ffd80f338edef46ca2125b8426aeb4
-  data.tar.gz: 0e133744d22ec2d9e35a4663cbcbe7466cfe162aacbbd85aaf166727156a9f51
+  metadata.gz: d19598abd3ab23ee44430f2e5c2207c6ac11d9c7919769ed5885408ee2e39f1c
+  data.tar.gz: 39d351c883a1f3c5d9402462961591d7bd4bd70e4ae0ca04d8c7095a710c70d2
 SHA512:
-  metadata.gz: d9f6e160782a439619bb500a6844d1b9a6a3d3929295e1b19bf2c4ef4b9eebdc246c22a0f8f4fd863b10524bf08025798af0933b4023dfe3f6235b123eded2e4
-  data.tar.gz: 12adb0be784f291d6493ece13b6d7fa7256968321eeca05bf5d21e5ab08c44be12de67c271a63f01196e23079734055b143e4b7a2d2c3eee9ce53ebf8519e8cc
+  metadata.gz: a557af273f69dda522cd9236d4f99cce270fd66d71c3b09150df6ba37eecbb0ddd2663e670b81c5ba806dd1af6927740c66f70b02551a42468d8e39f296f9e0f
+  data.tar.gz: 37a46da28658e4b26eceb19a86bdd2849cc387caf004213166bfd16580ec603a3f035fe797a7892423fad9e97129fcfeb95c82a789522d3088bf2a0dc3a3eefd

data/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gemspec :name => 'smart_proxy_dynflow_core'
+gemspec :name => 'smart_proxy_dynflow'
 
 group :development do
   gem 'pry'
@@ -8,10 +8,12 @@ end
 
 group :test do
   gem 'smart_proxy', :git => "https://github.com/theforeman/smart-proxy", :branch => "develop"
-  gem 'smart_proxy_dynflow', :path => '.'
 
+  gem 'minitest'
+  gem 'mocha'
   gem 'public_suffix'
   gem 'rack-test'
+  gem 'rake'
   gem 'rubocop', '~> 0.52.1'
 end
 

data/bundler.d/inspect_anything.rb

@@ -0,0 +1 @@
+# gem 'inspect_anything'

data/bundler.d/x.local.rb

@@ -0,0 +1 @@
+# gem 'dynflow', :path => '../dynflow'

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,12 +1,17 @@
 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
       payload = format_payload(input['targets'], input['results'])
-      SmartProxyDynflowCore::Callback::Request.new.callback({ :callbacks => payload }.to_json)
+      Proxy::Dynflow::Callback::Request.new.callback({ :callbacks => payload }.to_json)
     end
 
     private

data/lib/smart_proxy_dynflow/action/batch_runner.rb

@@ -7,7 +7,7 @@ module Proxy::Dynflow::Action
     end
 
     def initiate_runner
-      launcher = SmartProxyDynflowCore::TaskLauncherRegistry.fetch(input[:operation])
+      launcher = Proxy::Dynflow::TaskLauncherRegistry.fetch(input[:operation])
       launcher.runner_class.new(input[:targets], suspended_action: suspended_action)
     end
   end

data/lib/smart_proxy_dynflow/action/external_polling.rb

@@ -0,0 +1,17 @@
+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

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

data/lib/smart_proxy_dynflow/action/runner.rb

@@ -52,6 +52,7 @@ module Proxy::Dynflow
 
       def finish_run(update)
         output[:exit_status] = update.exit_status
+        output[:result] = output_result
       end
 
       def process_external_event(event)
@@ -60,7 +61,7 @@ module Proxy::Dynflow
       end
 
       def process_update(update)
-        output[:result].concat(update.continuous_output.raw_outputs)
+        output_chunk(update.continuous_output.raw_outputs) unless update.continuous_output.raw_outputs.empty?
         if update.exit_status
           finish_run(update)
         else
@@ -71,6 +72,10 @@ module Proxy::Dynflow
       def failed_run?
         output[:exit_status] != 0
       end
+
+      def output_result
+        (stored_output_chunks + (@pending_output_chunks || [])).map { |c| c[:chunk] }.reduce([], &:concat)
+      end
     end
   end
 end

data/lib/smart_proxy_dynflow/action/shareable.rb

@@ -12,14 +12,14 @@ module Proxy::Dynflow::Action
       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)
+        plan_action(Proxy::Dynflow::Callback::Action, callback, planned_action.output)
       end
     end
 
     private
 
     def on_proxy?
-      defined?(SmartProxyDynflowCore::Callback)
+      true
     end
   end
 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/callback.rb

@@ -2,57 +2,21 @@ require 'rest-client'
 
 module Proxy::Dynflow
   module Callback
-    class Request
-      class << self
-        def send_to_foreman_tasks(callback_info, data)
-          self.new.callback(prepare_payload(callback_info, data))
-        end
-
-        def ssl_options
-          return @ssl_options if defined? @ssl_options
-          @ssl_options = {}
-          settings = Proxy::SETTINGS
-          return @ssl_options unless URI.parse(settings.foreman_url).scheme == 'https'
-
-          @ssl_options[:verify_ssl] = OpenSSL::SSL::VERIFY_PEER
-
-          private_key_file = settings.foreman_ssl_key || settings.ssl_private_key
-          if private_key_file
-            private_key = File.read(private_key_file)
-            @ssl_options[:ssl_client_key] = OpenSSL::PKey::RSA.new(private_key)
-          end
-          certificate_file = settings.foreman_ssl_cert || settings.ssl_certificate
-          if certificate_file
-            certificate = File.read(certificate_file)
-            @ssl_options[:ssl_client_cert] = OpenSSL::X509::Certificate.new(certificate)
-          end
-          ca_file = settings.foreman_ssl_ca || settings.ssl_ca_file
-          @ssl_options[:ssl_ca_file] = ca_file if ca_file
-          @ssl_options
-        end
-        # rubocop:enable Metrics/PerceivedComplexity
-
-        private
-
-        def prepare_payload(callback, data)
-          { :callback => callback, :data => data }.to_json
-        end
+    class Request < ::Proxy::HttpRequest::ForemanRequest
+      def self.send_to_foreman_tasks(callback_info, data)
+        self.new.callback({ :callback => callback_info, :data => data }.to_json)
       end
 
       def callback(payload)
-        response = callback_resource.post(payload, :content_type => :json)
+        request = request_factory.create_post '/foreman_tasks/api/tasks/callback',
+                                              payload
+        response = send_request(request)
+
         if response.code.to_s != "200"
           raise "Failed performing callback to Foreman server: #{response.code} #{response.body}"
         end
         response
       end
-
-      private
-
-      def callback_resource
-        @resource ||= RestClient::Resource.new(Proxy::SETTINGS.foreman_url + '/foreman_tasks/api/tasks/callback',
-                                               self.class.ssl_options)
-      end
     end
 
     class Action < ::Dynflow::Action

data/lib/smart_proxy_dynflow/helpers.rb

@@ -35,7 +35,12 @@ module Proxy
 
       def task_status(task_id)
         ep = world.persistence.load_execution_plan(task_id)
-        ep.to_hash.merge(:actions => ep.actions.map(&:to_hash))
+        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
+        end
+        ep.to_hash.merge(:actions => actions)
       rescue KeyError => _e
         status 404
         {}

data/lib/smart_proxy_dynflow/plugin.rb

@@ -14,13 +14,22 @@ module Proxy::Dynflow
                      :execution_plan_cleaner_age => 60 * 60 * 24
     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'
       require 'smart_proxy_dynflow/action'
       require 'smart_proxy_dynflow/task_launcher'
 
+      Proxy::Dynflow::TaskLauncherRegistry.register('single',
+                                                    Proxy::Dynflow::TaskLauncher::Single)
+
       Proxy::Dynflow::Core.ensure_initialized
     end
+
+    def self.available_operations
+      TaskLauncherRegistry.operations
+    end
   end
 end

data/lib/smart_proxy_dynflow/process_manager.rbs

@@ -0,0 +1,46 @@
+# TypeProf 0.21.2
+
+# Classes
+module Proxy
+  module Dynflow
+    class IOBuffer
+      @callback: nil
+
+      attr_accessor io: nil
+      attr_reader buffer: String
+      def initialize: (nil io) -> void
+      def on_data: -> nil
+      def to_io: -> IO
+      def to_s: -> String
+      def empty?: -> bool
+      def closed?: -> untyped
+      def close: -> nil
+      def read_available!: -> nil
+      def write_available!: -> nil
+      def add_data: (untyped data) -> String
+
+      private
+      def with_callback: (String? data) -> String?
+    end
+
+    class ProcessManager
+      @command: untyped
+
+      attr_reader stdin: IOBuffer
+      attr_reader stdout: IOBuffer
+      attr_reader stderr: IOBuffer
+      attr_reader pid: Integer
+      attr_reader status: Integer?
+      def initialize: (untyped command) -> void
+      def run!: -> ProcessManager
+      def start!: -> String
+      def started?: -> bool
+      def done?: -> bool
+      def close: -> [IOBuffer, IOBuffer, IOBuffer]
+      def process: (?timeout: nil) -> Array[untyped]?
+      def finish: -> Integer?
+      def on_stdout: -> nil
+      def on_stderr: -> nil
+    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

@@ -7,8 +7,8 @@ module Proxy::Dynflow
         raise NotImplementedError
       end
 
-      def launch!(input)
-        trigger(nil, Action::SingleRunnerBatch, self, input)
+      def action_class
+        Action::SingleRunnerBatch
       end
 
       def launch_children(parent, input_hash)

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.5.1'.freeze
+    VERSION = '0.7.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dynflow
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-15 00:00:00.000000000 Z
+date: 2022-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dynflow
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
@@ -146,11 +146,14 @@ files:
 - Gemfile
 - LICENSE
 - bundler.d/dynflow.rb
+- bundler.d/inspect_anything.rb
+- bundler.d/x.local.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/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
@@ -165,6 +168,7 @@ files:
 - 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.rbs
 - lib/smart_proxy_dynflow/proxy_adapter.rb
 - lib/smart_proxy_dynflow/runner.rb
 - lib/smart_proxy_dynflow/runner/base.rb
@@ -195,7 +199,7 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement