foreman-tasks 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9309d18f9110a2295d933c2464788a8cceb42161
-  data.tar.gz: 94bc5fd42d4c176312d80ca1a45733593a23a395
+  metadata.gz: e52c285f1d8c6c98cc334d7d1028b190cebca6ea
+  data.tar.gz: 3d924a2162dfa1085a7d22c470184c0b5cebed61
 SHA512:
-  metadata.gz: 7536f877ffa338b8195477b8c2e14ca9856a0b3f125941ad1fda48383cf5c883c9061f3934e6b3ec68de7ffb706d69faa08709edc88c821139ac76765e3e5c48
-  data.tar.gz: f6285300dd2b63c27705c6a2fdc7f0e263e1f52faf62a4d0d40e41fa2566367df994daae4eaaebece8635b8ca0e62d9a07ab7643c04117bcc4915acbc8bfbf9a
+  metadata.gz: f8f42b585c90c6a2b5af2f57022a0bc8bd8c87367007f7dede5ed39c37431cdc84d553de1c3fb0e1876d34b667f31445e9f6afa191b85346e7ac92cad1ac4e21
+  data.tar.gz: 4397ef5b4c91c7598eb67edd6591341d44b725a955b2d048505e06c34a02d7ca3c670949fe7e196c6aa5963e667ef41fdf18a7ca71bdcda5af9baddb76ee7bc4

data/app/lib/actions/helpers/with_continuous_output.rb

@@ -0,0 +1,26 @@
+module Actions
+  module Helpers
+    module WithContinuousOutput
+      # @override
+      # array of objects defining fill_continuous_input
+      def continuous_output_providers
+        []
+      end
+
+      def continuous_output
+        continuous_output = ::ForemanTasksCore::ContinuousOutput.new
+        continuous_output_providers.each do |continous_output_provider|
+          continous_output_provider.fill_continuous_output(continuous_output)
+        end
+        continuous_output
+      end
+
+      def fill_planning_errors_to_continuous_output(continuous_output)
+        execution_plan.errors.map do |e|
+          continuous_output.add_exception(_('Failed to initialize'), e, task.started_at)
+        end
+      end
+    end
+  end
+end
+

data/app/lib/actions/helpers/with_delegated_action.rb

@@ -0,0 +1,57 @@
+module Actions
+  module Helpers
+    module WithDelegatedAction
+      include ::Actions::Helpers::WithContinuousOutput
+
+      def plan_delegated_action(proxy, klass, options)
+        case proxy
+        when :not_defined
+          if klass.is_a?(String)
+            raise ::Foreman::Exception.new(_('No proxy defined for execution'))
+          else
+            delegated_action = plan_action(klass, options)
+          end
+        when :not_available
+          raise ::Foreman::Exception.new(_('All proxies with the required feature are unavailable at the moment'))
+        when ::SmartProxy
+          delegated_action = plan_action(::Actions::ProxyAction, proxy, klass, options)
+        end
+
+        input[:delegated_action_id] = delegated_action.id
+        delegated_action
+      end
+
+      def humanized_output
+        delegated_output
+      end
+
+      def continuous_output_providers
+        super.tap do |ret|
+          ret << delegated_action if delegated_action.respond_to?(:fill_continuous_output)
+        end
+      end
+
+      def delegated_output
+        return @delegated_output if @delegated_output
+        action = delegated_action
+        @delegated_output = case action
+                            when NilClass
+                              {}
+                            when ::Actions::ProxyAction
+                              action.proxy_output(true)
+                            else
+                              action.output
+                            end
+      end
+
+      def delegated_action
+        # TODO: make it easier in dynflow to load action data
+        delegated_step = task.execution_plan.steps.values.find_all do |step|
+          step.action_id == input[:delegated_action_id]
+        end.last
+        return unless delegated_step
+        world.persistence.load_action(delegated_step)
+      end
+    end
+  end
+end

data/app/lib/actions/proxy_action.rb

@@ -1,6 +1,5 @@
 module Actions
   class ProxyAction < Base
-
     include ::Dynflow::Action::Cancellable
     include ::Dynflow::Action::Timeouts
 
@@ -12,10 +11,10 @@ module Actions
       end
     end
 
-    def plan(proxy, options)
+    def plan(proxy, klass, options)
       options[:connection_options] ||= {}
       default_connection_options.each { |key, value| options[:connection_options][key] ||= value }
-      plan_self(options.merge(:proxy_url => proxy.url))
+      plan_self(options.merge(:proxy_url => proxy.url, :proxy_action_name => klass.to_s))
     end
 
     def run(event = nil)
@@ -91,15 +90,31 @@ module Actions
 
     # @override String name of an action to be triggered on server
     def proxy_action_name
-      raise NotImplemented
+      input[:proxy_action_name]
     end
 
     def proxy
       ProxyAPI::ForemanDynflow::DynflowProxy.new(:url => input[:proxy_url])
     end
 
-    def proxy_output
-      output[:proxy_output]
+    def proxy_output(live = false)
+      if output.key?(:proxy_output)
+        output.fetch(:proxy_output) || {}
+      elsif live && output[:proxy_task_id]
+        proxy_data = proxy.status_of_task(output[:proxy_task_id])['actions'].detect { |action| action['class'] == proxy_action_name }
+        proxy_data.fetch('output', {})
+      else
+        {}
+      end
+    end
+
+    # The proxy action is able to contribute to continuous output
+    def fill_continuous_output(continuous_output)
+      failed_proxy_tasks.each do |failure_data|
+        message = _('Initialization error: %s') %
+            "#{failure_data[:exception_class]} - #{failure_data[:exception_message]}"
+        continuous_output.add_output(message, 'debug', failure_data[:timestamp])
+      end
     end
 
     def proxy_output=(output)
@@ -136,6 +151,10 @@ module Actions
 
     private
 
+    def failed_proxy_tasks
+      metadata[:failed_proxy_tasks] ||= []
+    end
+
     def with_connection_error_handling(event = nil)
       yield event
     rescue ::RestClient::Exception, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ETIMEDOUT => e
@@ -154,11 +173,10 @@ module Actions
     end
 
     def handle_connection_exception(exception, event = nil)
-      metadata[:failed_proxy_tasks] ||= []
       options = input[:connection_options]
-      metadata[:failed_proxy_tasks] << format_exception(exception)
+      failed_proxy_tasks << format_exception(exception)
       output[:proxy_task_id] = nil
-      if metadata[:failed_proxy_tasks].count < options[:retry_count]
+      if failed_proxy_tasks.count < options[:retry_count]
         suspend do |suspended_action|
           @world.clock.ping suspended_action,
                             Time.now + options[:retry_interval],

data/app/services/foreman_tasks/proxy_selector.rb

@@ -0,0 +1,58 @@
+module ForemanTasks
+  class ProxySelector
+
+    attr_reader :offline
+
+    def initialize
+      @tasks   = {}
+      @offline = []
+    end
+
+    def strategies
+      [:subnet, :fallback, :global]
+    end
+
+    def available_proxies(*args)
+      raise NotImplementedError
+    end
+
+    def determine_proxy(*args)
+      available_proxies = self.available_proxies(*args)
+      return :not_defined if available_proxies.empty? || available_proxies.values.all?(&:empty?)
+      proxy = nil
+
+      strategies.each do |strategy|
+        next unless available_proxies[strategy].present?
+        proxy = select_by_jobs_count(available_proxies[strategy])
+        break if proxy
+      end
+
+      proxy || :not_available
+    end
+
+    # Get the least loaded proxy from the given list of proxies
+    def select_by_jobs_count(proxies)
+      exclude = @tasks.keys + @offline
+      @tasks.merge!(get_counts(proxies - exclude))
+      next_proxy = @tasks.select { |proxy, _| proxies.include?(proxy) }.
+          min_by { |_, job_count| job_count }.try(:first)
+      @tasks[next_proxy] += 1 if next_proxy.present?
+      next_proxy
+    end
+
+    private
+
+    def get_counts(proxies)
+      proxies.inject({}) do |result, proxy|
+        begin
+          proxy_api = ProxyAPI::ForemanDynflow::DynflowProxy.new(:url => proxy.url)
+          result[proxy] = proxy_api.tasks_count('running')
+        rescue => e
+          @offline << proxy
+          Foreman::Logging.exception "Could not fetch task counts from #{proxy}, skipped.", e
+        end
+        result
+      end
+    end
+  end
+end

data/foreman-tasks-core.gemspec

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "foreman_tasks_core/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "foreman-tasks-core"
+  s.version     = ForemanTasksCore::VERSION
+  s.authors     = ["Ivan Nečas"]
+  s.email       = ["inecas@redhat.com"]
+  s.homepage    = "https://github.com/theforeman/foreman-tasks"
+  s.summary     = "Common code used both at Forman and Foreman proxy regarding tasks"
+  s.description = <<DESC
+Common code used both at Forman and Foreman proxy regarding tasks
+DESC
+
+  s.files = Dir['lib/foreman_tasks_core/**/*'] + ['lib/foreman_tasks_core.rb']
+end

data/foreman-tasks.gemspec

@@ -26,6 +26,7 @@ DESC
   s.test_files = `git ls-files test`.split("\n")
   s.extra_rdoc_files = Dir['README*', 'LICENSE']
 
+  s.add_dependency "foreman-tasks-core"
   s.add_dependency "dynflow", '~> 0.8.13'
   s.add_dependency "sequel" # for Dynflow process persistence
   s.add_dependency "sinatra" # for Dynflow web console

data/lib/foreman_tasks.rb

@@ -37,7 +37,7 @@ module ForemanTasks
 
   def self.sync_task(action, *args, &block)
     trigger_task(false, action, *args, &block).tap do |task|
-      raise TaskError.new(task) if task.execution_plan.error?
+      raise TaskError.new(task) if task.execution_plan.error? || task.execution_plan.result == :warning
     end
   end
 

data/lib/foreman_tasks/engine.rb

@@ -1,3 +1,4 @@
+require 'foreman_tasks_core'
 require 'fast_gettext'
 require 'gettext_i18n_rails'
 
@@ -107,12 +108,24 @@ module ForemanTasks
       end
     end
 
-    # to enable async Foreman operations using Dynflow
-    if ENV['FOREMAN_TASKS_MONKEYS'] == 'true'
-      initializer "foreman_tasks.require_dynflow", :before => "foreman_tasks.initialize_dynflow" do |app|
-        ForemanTasks.dynflow.require!
+    initializer "foreman_tasks.require_dynflow", :before => "foreman_tasks.initialize_dynflow" do |app|
+      ForemanTasks.dynflow.require!
+      ::ForemanTasks.dynflow.config.on_init do |world|
+        ForemanTasksCore.dynflow_setup(world)
       end
+    end
 
+    initializer 'foreman_tasks.set_core_settings' do
+      ForemanTasksCore::SettingsLoader.settings_registry.keys.each do |settings_keys|
+        settings = settings_keys.inject({}) do |h, settings_key|
+          h.merge(SETTINGS[settings_key] || {})
+        end
+        ForemanTasksCore::SettingsLoader.setup_settings(settings_keys.first, settings)
+      end
+    end
+
+    # to enable async Foreman operations using Dynflow
+    if ENV['FOREMAN_TASKS_MONKEYS'] == 'true'
       config.to_prepare do
         ::Api::V2::HostsController.send :include, ForemanTasks::Concerns::HostsControllerExtension
         ::PuppetclassesController.send :include, ForemanTasks::Concerns::EnvironmentsExtension

data/lib/foreman_tasks/tasks/cleanup.rake

@@ -50,7 +50,7 @@ DESC
     desc 'Show the current configuration for auto-cleanup'
     task :config => 'environment' do
       if ForemanTasks::Cleaner.cleanup_settings[:after]
-        puts _('The tasks will be deleted after %{after}') % ForemanTasks::Cleaner.cleanup_settings[:after]
+        puts _('The tasks will be deleted after %{after}') % { :after => ForemanTasks::Cleaner.cleanup_settings[:after] }
       else
         puts _('Global period for cleaning up tasks is not set')
       end

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
 end

data/lib/foreman_tasks_core.rb

@@ -0,0 +1,19 @@
+# The goal of ForemanTasksCore is to collect parts of foreman-tasks
+# that can be shared by the Foreman server and Foreman proxy
+
+require 'foreman_tasks_core/settings_loader'
+
+module ForemanTasksCore
+  def self.dynflow_world
+    raise "Dynflow world not set. Call initialize first" unless @dynflow_world
+    @dynflow_world
+  end
+
+  def self.dynflow_present?
+    defined? Dynflow
+  end
+
+  def self.dynflow_setup(dynflow_world)
+    @dynflow_world = dynflow_world
+  end
+end

data/lib/foreman_tasks_core/continuous_output.rb

@@ -0,0 +1,50 @@
+module ForemanTasksCore
+  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/foreman_tasks_core/runner.rb

@@ -0,0 +1,9 @@
+module ForemanTasksCore
+  module Runner
+  end
+end
+
+require 'foreman_tasks_core/runner/update'
+require 'foreman_tasks_core/runner/base'
+require 'foreman_tasks_core/runner/dispatcher'
+require 'foreman_tasks_core/runner/action'

data/lib/foreman_tasks_core/runner/action.rb

@@ -0,0 +1,69 @@
+require 'foreman_tasks_core/shareable_action'
+module ForemanTasksCore
+  module Runner
+    class Action < ::ForemanTasksCore::ShareableAction
+      include ::Dynflow::Action::Cancellable
+
+      def run(event = nil)
+        case event
+        when nil
+          init_run
+        when Runner::Update
+          process_update(event)
+        when ::Dynflow::Action::Cancellable::Cancel
+          kill_run
+        else
+          raise "Unexpected event #{event.inspect}"
+        end
+      rescue => e
+        action_logger.error(e)
+        process_update(Runner::Update.encode_exception("Proxy error", e))
+      end
+
+      def finalize
+        # To mark the task as a whole as failed
+        error! "Script execution failed" if 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
+        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_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/foreman_tasks_core/runner/base.rb

@@ -0,0 +1,60 @@
+module ForemanTasksCore
+  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_accessor :logger
+
+      def initialize(*args)
+        @id = SecureRandom.uuid
+        @continuous_output = ::ForemanTasksCore::ContinuousOutput.new
+      end
+
+      def logger
+        @logger ||= Logger.new(STDERR)
+      end
+
+      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
+      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 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"))
+        @continuous_output.add_exception(context, exception)
+        publish_exit_status('EXCEPTION') if fatal
+      end
+
+      def publish_exit_status(status)
+        @exit_status = status
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/runner/command_runner.rb

@@ -0,0 +1,41 @@
+require 'io/wait'
+require 'pty'
+
+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($?.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/dispatcher.rb

@@ -0,0 +1,158 @@
+module ForemanTasksCore
+  module Runner
+    class Dispatcher
+      def self.instance
+        return @instance if @instance
+        @instance = self.new(ForemanTasksCore.dynflow_world.clock,
+                             ForemanTasksCore.dynflow_world.logger)
+      end
+
+      class RunnerActor < ::Dynflow::Actor
+        def initialize(dispatcher, suspended_action, runner, clock, logger, options = {})
+          @dispatcher = dispatcher
+          @clock = clock
+          @logger = logger
+          @suspended_action = suspended_action
+          @runner = runner
+          @finishing = false
+          @refresh_interval = options[:refresh_interval] || 1
+        end
+
+        def on_envelope(*args)
+          super
+        rescue => e
+          handle_exception(e)
+        end
+
+        def start_runner
+          @logger.debug("start runner #{@runner.id}")
+          @runner.start
+          refresh_runner
+        ensure
+          plan_next_refresh
+        end
+
+        def refresh_runner
+          @logger.debug("refresh runner #{@runner.id}")
+          if update = @runner.run_refresh
+            @suspended_action << update
+            finish if update.exit_status
+          end
+        ensure
+          @refresh_planned = false
+          plan_next_refresh
+        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
+
+        private
+
+        def plan_next_refresh
+          if !@finishing && !@refresh_planned
+            @logger.debug("planning to refresh #{@runner.id}")
+            @clock.ping(reference, Time.now + @refresh_interval, :refresh_runner)
+            @refresh_planned = true
+          end
+        end
+
+        def handle_exception(exception, fatal = true)
+          @dispatcher.handle_command_exception(@runner.id, exception, fatal)
+        end
+      end
+
+      def initialize(clock, logger)
+        @mutex = Mutex.new
+        @clock = clock
+        @logger = logger
+        @runner_actors = {}
+        @runner_suspended_actions = {}
+      end
+
+      def synchronize(&block)
+        @mutex.synchronize(&block)
+      end
+
+      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
+        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
+        end
+      end
+
+      def finish(runner_id)
+        synchronize do
+          begin
+            _finish(runner_id)
+          rescue => exception
+            _handle_command_exception(runner_id, exception, false)
+          end
+        end
+      end
+
+      def handle_command_exception(*args)
+        synchronize { _handle_command_exception(*args) }
+      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.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/foreman_tasks_core/runner/update.rb

@@ -0,0 +1,21 @@
+require 'foreman_tasks_core/continuous_output'
+
+module ForemanTasksCore
+  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 = ::ForemanTasksCore::ContinuousOutput.new
+        continuous_output.add_exception(context, exception)
+        return self.new(continuous_output, fatal ? 'EXCEPTION' : nil)
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/settings_loader.rb

@@ -0,0 +1,53 @@
+module ForemanTasksCore
+  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/foreman_tasks_core/shareable_action.rb

@@ -0,0 +1,19 @@
+module ForemanTasksCore
+  class ShareableAction < ::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 defined?(SmartProxyDynflowCore::Callback) && callback
+        plan_action(SmartProxyDynflowCore::Callback::Action, callback, planned_action.output)
+      end
+    end
+  end
+end

data/lib/foreman_tasks_core/version.rb

@@ -0,0 +1,3 @@
+module ForemanTasksCore
+  VERSION = '0.1.0'
+end

data/test/controllers/api/tasks_controller_test.rb

@@ -26,7 +26,10 @@ module ForemanTasks
         it 'passes the data to the corresponding action' do
           Support::DummyProxyAction.reset
 
-          triggered = ForemanTasks.trigger(Support::DummyProxyAction, Support::DummyProxyAction.proxy, 'foo' => 'bar')
+          triggered = ForemanTasks.trigger(Support::DummyProxyAction,
+                                           Support::DummyProxyAction.proxy,
+                                           'Proxy::DummyAction',
+                                           'foo' => 'bar')
           Support::DummyProxyAction.proxy.task_triggered.wait(5)
 
           task = ForemanTasks::Task.where(:external_id => triggered.id).first

data/test/helpers/foreman_tasks/tasks_helper_test.rb

@@ -40,7 +40,5 @@ module ForemanTasks
         format_task_input(@task, true).must_equal("Create #{response}")
       end
     end
-
-   end 
   end
 end

data/test/support/dummy_proxy_action.rb

@@ -24,12 +24,14 @@ module Support
       end
     end
 
-    def proxy
-      self.class.proxy
+    class ProxySelector < ::ForemanTasks::ProxySelector
+      def available_proxies
+        { :global => [DummyProxyAction.proxy] }
+      end
     end
 
-    def proxy_action_name
-      'Proxy::DummyAction'
+    def proxy
+      self.class.proxy
     end
 
     def task

data/test/unit/actions/proxy_action_test.rb

@@ -8,18 +8,24 @@ module ForemanTasks
 
       before do
         Support::DummyProxyAction.reset
-        @action = create_and_plan_action(Support::DummyProxyAction, Support::DummyProxyAction.proxy, 'foo' => 'bar')
+        @action = create_and_plan_action(Support::DummyProxyAction,
+                                         Support::DummyProxyAction.proxy,
+                                         'Proxy::DummyAction',
+                                         'foo' => 'bar')
         @action = run_action(@action)
       end
 
       describe 'first run' do
         it 'triggers the corresponding action on the proxy' do
           proxy_call = Support::DummyProxyAction.proxy.log[:trigger_task].first
-          proxy_call.must_equal(["Proxy::DummyAction",
-                                 { "foo" => "bar",
-                                   "connection_options" => { "retry_interval" => 15, "retry_count" => 4, "timeout" => 60 },
-                                   "proxy_url" => "proxy.example.com",
-                                   "callback" => { "task_id" => "123", "step_id" => @action.run_step_id }}])
+          expected_call = ['Proxy::DummyAction',
+                           { 'foo' => 'bar',
+                             'connection_options' =>
+                                 { 'retry_interval' => 15, 'retry_count' => 4, 'timeout' => 60 },
+                             'proxy_url' => 'proxy.example.com',
+                             'proxy_action_name'=>'Proxy::DummyAction',
+                             'callback' => { 'task_id' => '123', 'step_id' => @action.run_step_id } }]
+          proxy_call.must_equal(expected_call)
         end
       end
 
@@ -64,7 +70,10 @@ module ForemanTasks
       end
 
       it 'handles connection errors' do
-        action = create_and_plan_action(Support::DummyProxyAction, Support::DummyProxyAction.proxy, { :foo => 'bar' })
+        action = create_and_plan_action(Support::DummyProxyAction,
+                                        Support::DummyProxyAction.proxy,
+                                         'Proxy::DummyAction',
+                                        { :foo => 'bar' })
         run_stubbed_action = lambda do |lambda_action|
           run_action lambda_action do |block_action|
             block_action.expects(:trigger_proxy_task).raises(Errno::ECONNREFUSED.new('Connection refused'))

data/test/unit/proxy_selector_test.rb

@@ -0,0 +1,59 @@
+require "foreman_tasks_test_helper"
+
+describe ForemanTasks::ProxySelector do
+  let(:proxy_selector) { ForemanTasks::ProxySelector.new }
+
+  before do
+    ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.stubs(:tasks_count).returns(0)
+  end
+
+  describe '#select_by_jobs_count' do
+    it 'load balances' do
+      count = 3
+      ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.expects(:tasks_count).raises.
+          then.times(count - 1).returns(0)
+      proxies = FactoryGirl.create_list(:smart_proxy, count)
+
+      available = proxies.reduce([]) do |found, _|
+        found << proxy_selector.select_by_jobs_count(proxies)
+      end
+
+      available.count.must_equal count
+      available.uniq.count.must_equal count - 1
+      proxy_selector.offline.count.must_equal 1
+    end
+
+    it 'returns nil for if no proxy is available' do
+      proxy_selector.select_by_jobs_count([]).must_be_nil
+    end
+  end
+
+  describe '#determine_proxy' do
+    it 'returns :not_defined when avialable proxies returns empty hash' do
+      proxy_selector.stubs(:available_proxies => [])
+      proxy_selector.determine_proxy.must_equal :not_defined
+      proxy_selector.stubs(:available_proxies => { :global => [] })
+      proxy_selector.determine_proxy.must_equal :not_defined
+    end
+
+    it 'returns :not_available when proxies are set but offline' do
+      count = 3
+      ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.expects(:tasks_count).times(count).raises
+      proxy_selector.stubs(:available_proxies =>
+                           { :global => FactoryGirl.create_list(:smart_proxy, count) })
+      proxy_selector.determine_proxy.must_equal :not_available
+    end
+
+    it 'returns first available proxy, prioritizing by strategy' do
+      ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.expects(:tasks_count).returns(0)
+      fallback_proxy = FactoryGirl.build(:smart_proxy)
+      global_proxy = FactoryGirl.build(:smart_proxy)
+      ForemanTasks::ProxySelector.any_instance.stubs(:available_proxies =>
+                                                     { :fallback => [fallback_proxy],
+                                                       :global => [global_proxy] })
+      ForemanTasks::ProxySelector.new.determine_proxy.must_equal fallback_proxy
+      ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.expects(:tasks_count).raises.then.returns(0)
+      ForemanTasks::ProxySelector.new.determine_proxy.must_equal global_proxy
+    end
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-12 00:00:00.000000000 Z
+date: 2016-09-07 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: foreman-tasks-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: dynflow
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +136,8 @@ files:
 - app/lib/actions/helpers/args_serialization.rb
 - app/lib/actions/helpers/humanizer.rb
 - app/lib/actions/helpers/lock.rb
+- app/lib/actions/helpers/with_continuous_output.rb
+- app/lib/actions/helpers/with_delegated_action.rb
 - app/lib/actions/middleware/inherit_task_groups.rb
 - app/lib/actions/middleware/keep_current_user.rb
 - app/lib/actions/middleware/recurring_logic.rb
@@ -144,6 +160,7 @@ files:
 - app/models/foreman_tasks/task_groups/recurring_logic_task_group.rb
 - app/models/foreman_tasks/triggering.rb
 - app/models/setting/foreman_tasks.rb
+- app/services/foreman_tasks/proxy_selector.rb
 - app/views/common/_trigger_form.html.erb
 - app/views/foreman_tasks/api/recurring_logics/base.json.rabl
 - app/views/foreman_tasks/api/recurring_logics/index.json.rabl
@@ -187,6 +204,7 @@ files:
 - deploy/foreman-tasks.service
 - deploy/foreman-tasks.sysconfig
 - extra/dynflow-executor.example
+- foreman-tasks-core.gemspec
 - foreman-tasks.gemspec
 - lib/foreman-tasks.rb
 - lib/foreman_tasks.rb
@@ -205,6 +223,17 @@ files:
 - lib/foreman_tasks/test_extensions.rb
 - lib/foreman_tasks/triggers.rb
 - lib/foreman_tasks/version.rb
+- lib/foreman_tasks_core.rb
+- lib/foreman_tasks_core/continuous_output.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_runner.rb
+- lib/foreman_tasks_core/runner/dispatcher.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/version.rb
 - lib/tasks/gettext.rake
 - locale/Makefile
 - locale/action_names.rb
@@ -224,6 +253,7 @@ files:
 - test/unit/actions/proxy_action_test.rb
 - test/unit/cleaner_test.rb
 - test/unit/dynflow_console_authorizer_test.rb
+- test/unit/proxy_selector_test.rb
 - test/unit/recurring_logic_test.rb
 - test/unit/task_groups_test.rb
 - test/unit/task_test.rb
@@ -265,6 +295,7 @@ test_files:
 - test/unit/actions/proxy_action_test.rb
 - test/unit/cleaner_test.rb
 - test/unit/dynflow_console_authorizer_test.rb
+- test/unit/proxy_selector_test.rb
 - test/unit/recurring_logic_test.rb
 - test/unit/task_groups_test.rb
 - test/unit/task_test.rb