app/lib/actions/proxy_action.rb in foreman-tasks-1.0.1 vs app/lib/actions/proxy_action.rb in foreman-tasks-1.1.0

@@ -39,16 +39,11 @@
 
     def run(event = nil)
       with_connection_error_handling(event) do |event|
         case event
         when nil
-          if remote_task
-            on_resume
-          else
-            trigger_proxy_task
-          end
-          suspend
+          start_or_resume
         when ::Dynflow::Action::Skip
           # do nothing
         when ::Dynflow::Action::Cancellable::Cancel
           cancel_proxy_task
         when ::Dynflow::Action::Cancellable::Abort
@@ -75,10 +70,16 @@
         remote_task.trigger(proxy_action_name, proxy_input)
         output[:proxy_task_id] = remote_task.remote_task_id
       end
     end
 
+    def trigger_remote_task
+      suspend do |_suspended_action|
+        ForemanTasks::RemoteTask.batch_trigger(remote_task.operation, [remote_task])
+      end
+    end
+
     def proxy_input(task_id = task.id)
       input.merge(:callback => { :task_id => task_id,
                                  :step_id => run_step_id })
     end
 
@@ -86,11 +87,11 @@
       response = proxy.status_of_task(proxy_task_id)
       if %w[stopped paused].include? response['state']
         if response['result'] == 'error'
           raise ::Foreman::Exception, _('The smart proxy task %s failed.') % proxy_task_id
         else
-          on_data(response['actions'].find { |block_action| block_action['class'] == proxy_action_name }['output'])
+          on_data(get_proxy_data(response))
         end
       else
         suspend
       end
     end
@@ -152,14 +153,12 @@
 
     def proxy_output(live = false)
       if output.key?(:proxy_output) || state == :error
         output.fetch(:proxy_output, {})
       elsif live && proxy_task_id
-        proxy_data = proxy.status_of_task(proxy_task_id)['actions'].detect do |action|
-          action['class'] == proxy_action_name || action.fetch('input', {})['proxy_operation_name'] == proxy_operation_name
-        end
-        proxy_data.fetch('output', {})
+        response = proxy.status_of_task(proxy_task_id)
+        get_proxy_data(response)
       else
         {}
       end
     end
 
@@ -203,10 +202,30 @@
       remote_task.destroy! if remote_task
     end
 
     private
 
+    def start_or_resume
+      if remote_task
+        if remote_task.state == 'external'
+          trigger_remote_task
+        else
+          on_resume
+        end
+      else
+        trigger_proxy_task
+      end
+      suspend
+    end
+
+    def get_proxy_data(response)
+      proxy_data = response['actions'].detect do |action|
+        action['class'] == proxy_action_name || action.fetch('input', {})['proxy_operation_name'] == proxy_operation_name
+      end
+      proxy_data.fetch('output', {})
+    end
+
     def proxy_version(proxy)
       match = proxy.statuses[:version].version['version'].match(/(\d+)\.(\d+)\.(\d+)/)
       { :major => match[1].to_i, :minor => match[2].to_i, :patch => match[3].to_i }
     end
 
@@ -245,13 +264,15 @@
         raise exception
       end
     end
 
     def prepare_remote_task
+      state = input[:use_concurrency_control] ? 'external' : 'new'
       ::ForemanTasks::RemoteTask.new(:execution_plan_id => execution_plan_id,
                                      :proxy_url => input[:proxy_url],
                                      :step_id => run_step_id,
-                                     :operation => proxy_operation_name)
+                                     :operation => proxy_operation_name,
+                                     :state => state)
     end
 
     def proxy_task_id
       output[:proxy_task_id] ||= remote_task.try(:remote_task_id)
     end