dynflow 0.8.37 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07d302583997706186e5c5a55185a32b35757971615e5e42b73d9121cab2d23d
-  data.tar.gz: 9b5f20a8788784b95f4f52d66f3af1b7b1425f077a370b51a2e2ca2aed2b1c10
+  metadata.gz: 111e155822b2ec8d00a8f0e249ce1333f6d4e826bb10247e172a523e7212a9d6
+  data.tar.gz: 4969844384cd6ea8add967e10495cc534bee36dbbe4fe5a9b978ecd8c09d802c
 SHA512:
-  metadata.gz: 3cd1c9ca74ab31c3afead86db86af7565c2f34e71c48d608d0dcac3ba105f0113fed48f9560865a3acced8545dd0daa55f7149311b91d81387b8ab00e2132aa8
-  data.tar.gz: 6fbf67d06c58b64076178aed4cd271d07d1ac89b5a6d962360dd140a63324c738552e74586d9d350e08216963ffa925cacffa53be45fb932ad9a982ada1b6bae
+  metadata.gz: 65b612808157a76872102e4070bbb0b0ca8e23d9eba4f032a7881d67b884f33be74dc0fc7fbbcd458d15be675e33f10ba00c0fb24e4c3e237a69e7ae27558104
+  data.tar.gz: 66c6e35276566b7d239a25c5f95e8b52331e70aa32f36a36027c3fbf64d64069f611b8ffaab3caac5a89bf370a4c6fadc3bb5736de8bde9d3b7f50bf7a962149

data/doc/pages/source/documentation/index.md

@@ -940,6 +940,45 @@ Solutions are:
 -   **Offloading computation** - CPU heavy parts can be offloaded to different services
     notifying the suspended actions when the computation is done.
 
+### Multiple queues support
+
+By default, a single queue and a pool of workers is used to process
+all the actions in the system. This can cause some actions to block
+execution of some higher-priority ones in the system.
+
+To address this case, it's possible to define additional queues tied
+to additional pool of workers dedicated for it. This way, they can be
+processed more independently from the default queue.
+
+To use the queue, one needs to register additional queues when defining
+the executor world:
+
+```ruby
+config = Dynflow::Config.new
+config.queues.add(:slow, :pool_size => 5)
+world = Dynflow::World.new(config)
+```
+
+The action to use the queue just needs to override the `queue` method like this:
+
+
+```ruby
+class MyAction < Dynflow::Action
+  def queue
+    :slow
+  end
+
+  def run
+    sleep 60
+  end
+end
+```
+
+In the current implementation, it's expected all the executors would
+have the same set of queues defined. In the future implementation it
+should be possible to have dedicated executors with just a subset of
+queues
+
 ### Middleware
 
 Each action class has chain of middlewares which wrap phases of the action execution.

data/examples/orchestrate.rb

@@ -71,6 +71,10 @@ module Orchestrate
 
   class PrepareDisk < Base
 
+    def queue
+      :slow
+    end
+
     input_format do
       param :name
     end
@@ -144,6 +148,10 @@ module Orchestrate
 end
 
 if $0 == __FILE__
+  world = ExampleHelper.create_world do |config|
+    config.queues.add(:slow, :pool_size => 3)
+  end
+  ExampleHelper.set_world(world)
   ExampleHelper.world.action_logger.level = Logger::INFO
   ExampleHelper.something_should_fail!
   ExampleHelper.world.trigger(Orchestrate::CreateInfrastructure)

data/lib/dynflow/action.rb

@@ -180,6 +180,7 @@ module Dynflow
       @from_subscription = Type! from_subscription, TrueClass, FalseClass
     end
 
+    # action that caused this action to be planned. Available only in planning phase
     def triggering_action
       phase! Plan
       @triggering_action
@@ -316,6 +317,12 @@ module Dynflow
       false
     end
 
+    # @override define what pool should the action be run in. The
+    # queue defined here will also be used as the default queue for
+    # all the steps planned under this action, unless overrided by sub-action
+    def queue
+    end
+
     protected
 
     def state=(state)

data/lib/dynflow/active_job/queue_adapter.rb

@@ -23,9 +23,14 @@ module Dynflow
       end
 
       class JobWrapper < Dynflow::Action
+        def queue
+          input[:queue].to_sym
+        end
+
         def plan(attributes)
           input[:job_class] = attributes['job_class']
           input[:job_arguments] = attributes['arguments']
+          input[:queue] = attributes['queue_name']
           plan_self
         end
 

data/lib/dynflow/config.rb

@@ -32,15 +32,51 @@ module Dynflow
         @config.validate(self)
       end
 
+      def queues
+        @queues ||= @config.queues.finalized_config(self)
+      end
+
       def method_missing(name)
         return @cache[name] if @cache.key?(name)
         value = @config.send(name)
         value = value.call(@world, self) if value.is_a? Proc
-        @config.send("validate_#{ name }!", value)
+        validation_method = "validate_#{ name }!"
+        @config.send(validation_method, value) if @config.respond_to?(validation_method)
         @cache[name] = value
       end
     end
 
+    class QueuesConfig
+      attr_reader :queues
+
+      def initialize
+        @queues = {:default => {}}
+      end
+
+      # Add a new queue to the configuration
+      #
+      # @param [Hash] queue_options
+      # @option queue_options :pool_size The amount of workers available for the queue.
+      #   By default, it uses global pool_size config option.
+      def add(name, queue_options = {})
+        Utils.validate_keys!(queue_options, :pool_size)
+        name = name.to_sym
+        raise ArgumentError, "Queue #{name} is already defined" if @queues.key?(name)
+        @queues[name] = queue_options
+      end
+
+      def finalized_config(config_for_world)
+        @queues.values.each do |queue_options|
+          queue_options[:pool_size] ||= config_for_world.pool_size
+        end
+        @queues
+      end
+    end
+
+    def queues
+      @queues ||= QueuesConfig.new
+    end
+
     config_attr :logger_adapter, LoggerAdapters::Abstract do
       LoggerAdapters::Simple.new
     end
@@ -62,7 +98,7 @@ module Dynflow
     end
 
     config_attr :executor, Executors::Abstract, FalseClass do |world, config|
-      Executors::Parallel.new(world, config.pool_size)
+      Executors::Parallel.new(world, config.queues)
     end
 
     config_attr :executor_semaphore, Semaphores::Abstract, FalseClass do |world, config|
@@ -126,7 +162,7 @@ module Dynflow
       Action.all_children
     end
 
-    config_attr :meta do
+    config_attr :meta do |world, config|
       { 'hostname' => Socket.gethostname, 'pid' => Process.pid }
     end
 
@@ -140,17 +176,18 @@ module Dynflow
 
     def validate(config_for_world)
       if defined? ::ActiveRecord::Base
-        ar_pool_size = ::ActiveRecord::Base.connection_pool.instance_variable_get(:@size)
-        if (config_for_world.pool_size / 2.0) > ar_pool_size
-          config_for_world.world.logger.warn 'Consider increasing ActiveRecord::Base.connection_pool size, ' +
-                                             "it's #{ar_pool_size} but there is #{config_for_world.pool_size} " +
-                                             'threads in Dynflow pool.'
+        begin
+          ar_pool_size = ::ActiveRecord::Base.connection_pool.instance_variable_get(:@size)
+          if (config_for_world.pool_size / 2.0) > ar_pool_size
+            config_for_world.world.logger.warn 'Consider increasing ActiveRecord::Base.connection_pool size, ' +
+                                               "it's #{ar_pool_size} but there is #{config_for_world.pool_size} " +
+                                               'threads in Dynflow pool.'
+          end
+        rescue ActiveRecord::ConnectionNotEstablished # rubocop:disable Lint/HandleExceptions
+          # If in tests or in an environment where ActiveRecord doesn't have a
+          # real DB connection, we want to skip AR configuration altogether
         end
       end
-
-    rescue ActiveRecord::ConnectionNotEstablished # rubocop:disable Lint/HandleExceptions
-      # If in tests or in an environment where ActiveRecord doesn't have a
-      # real DB connection, we want to skip AR configuration altogether
     end
   end
 end

data/lib/dynflow/coordinator.rb

@@ -89,6 +89,10 @@ module Dynflow
       def meta
         @data[:meta]
       end
+
+      def executor?
+        raise NotImplementedError
+      end
     end
 
     class ExecutorWorld < WorldRecord
@@ -105,9 +109,16 @@ module Dynflow
         Type! value, Algebrick::Types::Boolean
         @data[:active] = value
       end
+
+      def executor?
+        true
+      end
     end
 
     class ClientWorld < WorldRecord
+      def executor?
+        false
+      end
     end
 
     class Lock < Record

data/lib/dynflow/director.rb

@@ -19,10 +19,11 @@ module Dynflow
     UnprocessableEvent = Class.new(Dynflow::Error)
 
     class WorkItem
-      attr_reader :execution_plan_id
+      attr_reader :execution_plan_id, :queue
 
-      def initialize(execution_plan_id)
+      def initialize(execution_plan_id, queue)
         @execution_plan_id = execution_plan_id
+        @queue = queue
       end
 
       def execute
@@ -33,8 +34,8 @@ module Dynflow
     class StepWorkItem < WorkItem
       attr_reader :step
 
-      def initialize(execution_plan_id, step)
-        super(execution_plan_id)
+      def initialize(execution_plan_id, step, queue)
+        super(execution_plan_id, queue)
         @step = step
       end
 
@@ -46,8 +47,8 @@ module Dynflow
     class EventWorkItem < StepWorkItem
       attr_reader :event
 
-      def initialize(execution_plan_id, step, event)
-        super(execution_plan_id, step)
+      def initialize(execution_plan_id, step, event, queue)
+        super(execution_plan_id, step, queue)
         @event = event
       end
 
@@ -57,8 +58,8 @@ module Dynflow
     end
 
     class FinalizeWorkItem < WorkItem
-      def initialize(execution_plan_id, sequential_manager)
-        super(execution_plan_id)
+      def initialize(execution_plan_id, sequential_manager, queue)
+        super(execution_plan_id, queue)
         @sequential_manager = sequential_manager
       end
 

data/lib/dynflow/director/execution_plan_manager.rb

@@ -25,7 +25,7 @@ module Dynflow
       end
 
       def prepare_next_step(step)
-        StepWorkItem.new(execution_plan.id, step).tap do |work|
+        StepWorkItem.new(execution_plan.id, step, step.queue).tap do |work|
           @running_steps_manager.add(step, work)
         end
       end
@@ -93,7 +93,7 @@ module Dynflow
         return if execution_plan.finalize_flow.empty?
         raise 'finalize phase already started' if @finalize_manager
         @finalize_manager = SequentialManager.new(@world, execution_plan)
-        [FinalizeWorkItem.new(execution_plan.id, @finalize_manager)]
+        [FinalizeWorkItem.new(execution_plan.id, @finalize_manager, execution_plan.finalize_steps.first.queue)]
       end
 
       def finish

data/lib/dynflow/director/running_steps_manager.rb

@@ -69,7 +69,7 @@ module Dynflow
         end
 
         can_run_event = @events.empty?(step.id)
-        work          = EventWorkItem.new(event.execution_plan_id, step, event)
+        work          = EventWorkItem.new(event.execution_plan_id, step, event, step.queue)
         @events.push(step.id, work)
         next_work_items << work if can_run_event
         next_work_items

data/lib/dynflow/execution_plan.rb

@@ -389,7 +389,7 @@ module Dynflow
 
     def add_run_step(action)
       add_step(Steps::RunStep, action.class, action.id).tap do |step|
-        step.progress_weight = action.run_progress_weight
+        step.update_from_action(action)
         @dependency_graph.add_dependencies(step, action)
         current_run_flow.add_and_resolve(@dependency_graph, Flows::Atom.new(step.id))
       end
@@ -397,7 +397,7 @@ module Dynflow
 
     def add_finalize_step(action)
       add_step(Steps::FinalizeStep, action.class, action.id).tap do |step|
-        step.progress_weight = action.finalize_progress_weight
+        step.update_from_action(action)
         finalize_flow << Flows::Atom.new(step.id)
       end
     end

data/lib/dynflow/execution_plan/steps/abstract.rb

@@ -5,9 +5,10 @@ module Dynflow
       include Stateful
 
       attr_reader :execution_plan_id, :id, :state, :action_class, :action_id, :world, :started_at,
-                  :ended_at, :execution_time, :real_time
+                  :ended_at, :execution_time, :real_time, :queue
       attr_accessor :error
 
+      # rubocop:disable Metrics/ParameterLists
       def initialize(execution_plan_id,
                      id,
                      state,
@@ -20,7 +21,8 @@ module Dynflow
                      execution_time  = 0.0,
                      real_time       = 0.0,
                      progress_done   = nil,
-                     progress_weight = nil)
+                     progress_weight = nil,
+                     queue           = nil)
 
         @id                = id || raise(ArgumentError, 'missing id')
         @execution_plan_id = Type! execution_plan_id, String
@@ -34,6 +36,8 @@ module Dynflow
         @progress_done     = Type! progress_done, Numeric, NilClass
         @progress_weight   = Type! progress_weight, Numeric, NilClass
 
+        @queue             = Type! queue, Symbol, NilClass
+
         self.state = state.to_sym
 
         Child! action_class, Action
@@ -41,6 +45,7 @@ module Dynflow
 
         @action_id = action_id || raise(ArgumentError, 'missing action_id')
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def action_logger
         @world.action_logger
@@ -87,7 +92,8 @@ module Dynflow
                           execution_time:      execution_time,
                           real_time:           real_time,
                           progress_done:       progress_done,
-                          progress_weight:     progress_weight
+                          progress_weight:     progress_weight,
+                          queue:               queue
       end
 
       def progress_done
@@ -132,7 +138,7 @@ module Dynflow
 
       def self.new_from_hash(hash, execution_plan_id, world)
         check_class_matching hash
-        new execution_plan_id,
+        new(execution_plan_id,
             hash[:id],
             hash[:state],
             Action.constantize(hash[:action_class]),
@@ -144,7 +150,8 @@ module Dynflow
             hash[:execution_time].to_f,
             hash[:real_time].to_f,
             hash[:progress_done].to_f,
-            hash[:progress_weight].to_f
+            hash[:progress_weight].to_f,
+            (hash[:queue] && hash[:queue].to_sym))
       end
 
       private

data/lib/dynflow/execution_plan/steps/abstract_flow_step.rb

@@ -2,6 +2,14 @@ module Dynflow
   module ExecutionPlan::Steps
     class AbstractFlowStep < Abstract
 
+      # Method called when initializing the step to customize the behavior based on the
+      # action definition during the planning phase
+      def update_from_action(action)
+        @queue = action.queue
+        @queue ||= action.triggering_action.queue if action.triggering_action
+        @queue ||= :default
+      end
+
       def execute(*args)
         return self if [:skipped, :success].include? self.state
         open_action do |action|

data/lib/dynflow/execution_plan/steps/finalize_step.rb

@@ -13,6 +13,11 @@ module Dynflow
         }
       end
 
+      def update_from_action(action)
+        super
+        self.progress_weight = action.finalize_progress_weight
+      end
+
       def phase
         Action::Finalize
       end

data/lib/dynflow/execution_plan/steps/run_step.rb

@@ -14,6 +14,11 @@ module Dynflow
         }
       end
 
+      def update_from_action(action)
+        super
+        self.progress_weight = action.run_progress_weight
+      end
+
       def phase
         Action::Run
       end

data/lib/dynflow/executors/parallel.rb

@@ -5,10 +5,10 @@ module Dynflow
       require 'dynflow/executors/parallel/pool'
       require 'dynflow/executors/parallel/worker'
 
-      def initialize(world, pool_size = 10)
+      def initialize(world, queues_options = { :default => { :pool_size => 5 }})
         super(world)
         @core = Core.spawn name:        'parallel-executor-core',
-                           args:        [world, pool_size],
+                           args:        [world, queues_options],
                            initialized: @core_initialized = Concurrent.future
       end
 

data/lib/dynflow/executors/parallel/core.rb

@@ -1,16 +1,28 @@
 module Dynflow
   module Executors
     class Parallel < Abstract
-
       class Core < Actor
         attr_reader :logger
 
-        def initialize(world, pool_size)
-          @logger     = world.logger
-          @world      = Type! world, World
-          @pool       = Pool.spawn('pool', reference, pool_size, world.transaction_adapter)
-          @terminated = nil
-          @director   = Director.new(@world)
+        def initialize(world, queues_options)
+          @logger         = world.logger
+          @world          = Type! world, World
+          @queues_options = queues_options
+          @pools          = {}
+          @terminated     = nil
+          @director       = Director.new(@world)
+
+          initialize_queues
+        end
+
+        def initialize_queues
+          default_pool_size = @queues_options[:default][:pool_size]
+          @queues_options.each do |(queue_name, queue_options)|
+            queue_pool_size = queue_options.fetch(:pool_size, default_pool_size)
+            @pools[queue_name] = Pool.spawn("pool #{queue_name}", reference,
+                                            queue_name, queue_pool_size,
+                                            @world.transaction_adapter)
+          end
         end
 
         def handle_execution(execution_plan_id, finished)
@@ -43,14 +55,17 @@ module Dynflow
 
         def start_termination(*args)
           super
-          logger.info 'shutting down Dynflow Core ...'
-          @pool.tell([:start_termination, Concurrent.future])
+          logger.info 'shutting down Core ...'
+          @pools.values.each { |pool| pool.tell([:start_termination, Concurrent.future]) }
         end
 
-        def finish_termination
+        def finish_termination(pool_name)
+          @pools.delete(pool_name)
+          # we expect this message from all worker pools
+          return unless @pools.empty?
           @director.terminate
-          logger.error '... Dynflow Core has shut down.'
-          super
+          logger.error '... core terminated.'
+          super()
         end
 
         def dead_letter_routing
@@ -58,7 +73,9 @@ module Dynflow
         end
 
         def execution_status(execution_plan_id = nil)
-          @pool.ask!([:execution_status, execution_plan_id])
+          @pools.each_with_object({}) do |(pool_name, pool), hash|
+            hash[pool_name] = pool.ask!([:execution_status, execution_plan_id])
+          end
         end
 
         private
@@ -74,7 +91,18 @@ module Dynflow
           return if work_items.nil?
           work_items = [work_items] if work_items.is_a? Director::WorkItem
           work_items.all? { |i| Type! i, Director::WorkItem }
-          work_items.each { |new_work| @pool.tell([:schedule_work, new_work]) }
+          work_items.each do |new_work|
+            pool = @pools[new_work.queue]
+            unless pool
+              logger.error("Pool is not available for queue #{new_work.queue}, falling back to #{fallback_queue}")
+              pool = @pools[fallback_queue]
+            end
+            pool.tell([:schedule_work, new_work])
+          end
+        end
+
+        def fallback_queue
+          :default
         end
       end
     end

data/lib/dynflow/executors/parallel/pool.rb

@@ -46,7 +46,8 @@ module Dynflow
           end
         end
 
-        def initialize(core, pool_size, transaction_adapter)
+        def initialize(core, name, pool_size, transaction_adapter)
+          @name = name
           @executor_core = core
           @pool_size     = pool_size
           @free_workers  = Array.new(pool_size) { |i| Worker.spawn("worker-#{i}", reference, transaction_adapter) }
@@ -84,7 +85,7 @@ module Dynflow
         def try_to_terminate
           if terminating? && @free_workers.size == @pool_size
             @free_workers.map { |worker| worker.ask(:terminate!) }.map(&:wait)
-            @executor_core.tell(:finish_termination)
+            @executor_core.tell([:finish_termination, @name])
             finish_termination
           end
         end

data/lib/dynflow/persistence_adapters/sequel.rb

@@ -33,7 +33,7 @@ module Dynflow
       META_DATA = { execution_plan:      %w(label state result started_at ended_at real_time execution_time root_plan_step_id class),
                     action:              %w(caller_execution_plan_id caller_action_id class plan_step_id run_step_id finalize_step_id),
                     step:                %w(state started_at ended_at real_time execution_time action_id progress_done progress_weight
-                                            class action_class execution_plan_uuid),
+                                            class action_class execution_plan_uuid queue),
                     envelope:            %w(receiver_id),
                     coordinator_record:  %w(id owner_id class),
                     delayed:             %w(execution_plan_uuid start_at start_before args_serializer)}

data/lib/dynflow/persistence_adapters/sequel_migrations/016_add_step_queue.rb

@@ -0,0 +1,7 @@
+Sequel.migration do
+  change do
+    alter_table(:dynflow_steps) do
+      add_column :queue, String
+    end
+  end
+end

data/lib/dynflow/rails.rb

@@ -38,6 +38,7 @@ module Dynflow
         @world = world
 
         unless config.remote?
+          config.increase_db_pool_size(world)
           config.run_on_init_hooks(world)
           # leave this just for long-running executors
           unless config.rake_task_with_executor?

data/lib/dynflow/rails/configuration.rb

@@ -7,7 +7,8 @@ module Dynflow
       # the number of threads in the pool handling the execution
       attr_accessor :pool_size
 
-      # the size of db connection pool
+      # the size of db connection pool, if not set, it's calculated
+      # from the amount of workers in the pool
       attr_accessor :db_pool_size
 
       # set true if the executor runs externally (by default true in procution, othewise false)
@@ -32,7 +33,6 @@ module Dynflow
 
       def initialize
         self.pool_size                = 5
-        self.db_pool_size             = pool_size + 5
         self.remote                   = ::Rails.env.production?
         self.transaction_adapter      = ::Dynflow::TransactionAdapters::ActiveRecord.new
         self.eager_load_paths         = []
@@ -83,13 +83,24 @@ module Dynflow
       end
 
       def increase_db_pool_size?
-        !::Rails.env.test?
+        !::Rails.env.test? && !remote?
+      end
+
+      def calculate_db_pool_size(world)
+        self.db_pool_size || world.config.queues.values.inject(5) do |pool_size, pool_options|
+          pool_size += pool_options[:pool_size]
+        end
       end
 
       # To avoid pottential timeouts on db connection pool, make sure
       # we have the pool bigger than the thread pool
-      def increase_db_pool_size
+      def increase_db_pool_size(world = nil)
+        if world.nil?
+          warn 'Deprecated: using `increase_db_pool_size` outside of Dynflow code is not needed anymore'
+          return
+        end
         if increase_db_pool_size?
+          db_pool_size = calculate_db_pool_size(world)
           ::ActiveRecord::Base.connection_pool.disconnect!
 
           config = ::ActiveRecord::Base.configurations[::Rails.env]
@@ -100,11 +111,11 @@ module Dynflow
 
       # generates the options hash consumable by the Dynflow's world
       def world_config
-        ::Dynflow::Config.new.tap do |config|
+        @world_config ||= ::Dynflow::Config.new.tap do |config|
           config.auto_rescue         = true
           config.logger_adapter      = ::Dynflow::LoggerAdapters::Delegator.new(action_logger, dynflow_logger)
           config.pool_size           = 5
-          config.persistence_adapter = initialize_persistence
+          config.persistence_adapter = ->(world, _) { initialize_persistence(world) }
           config.transaction_adapter = transaction_adapter
           config.executor            = ->(world, _) { initialize_executor(world) }
           config.connector           = ->(world, _) { initialize_connector(world) }
@@ -115,13 +126,18 @@ module Dynflow
         end
       end
 
+      # expose the queues definition to Rails developers
+      def queues
+        world_config.queues
+      end
+
       protected
 
-      def default_sequel_adapter_options
+      def default_sequel_adapter_options(world)
         db_config            = ::ActiveRecord::Base.configurations[::Rails.env].dup
         db_config['adapter'] = db_config['adapter'].gsub(/_?makara_?/, '')
         db_config['adapter'] = 'postgres' if db_config['adapter'] == 'postgresql'
-        db_config['max_connections'] = db_pool_size if increase_db_pool_size?
+        db_config['max_connections'] = calculate_db_pool_size(world) if increase_db_pool_size?
 
         if db_config['adapter'] == 'sqlite3'
           db_config['adapter'] = 'sqlite'
@@ -139,7 +155,7 @@ module Dynflow
         if remote?
           false
         else
-          ::Dynflow::Executors::Parallel.new(world, pool_size)
+          ::Dynflow::Executors::Parallel.new(world, world.config.queues)
         end
       end
 
@@ -147,9 +163,13 @@ module Dynflow
         ::Dynflow::Connectors::Database.new(world)
       end
 
+      def persistence_class
+        ::Dynflow::PersistenceAdapters::Sequel
+      end
+
       # Sequel adapter based on Rails app database.yml configuration
-      def initialize_persistence
-        ::Dynflow::PersistenceAdapters::Sequel.new(default_sequel_adapter_options)
+      def initialize_persistence(world)
+        persistence_class.new(default_sequel_adapter_options(world))
       end
     end
   end

data/lib/dynflow/utils.rb

@@ -1,6 +1,16 @@
 module Dynflow
   module Utils
 
+    def self.validate_keys!(hash, *valid_keys)
+      valid_keys.flatten!
+      unexpected_options = hash.keys - valid_keys - valid_keys.map(&:to_s)
+      unless unexpected_options.empty?
+        raise ArgumentError, "Unexpected options #{unexpected_options.inspect}. "\
+            "Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+      end
+      hash
+    end
+
     def self.symbolize_keys(hash)
       return hash.symbolize_keys if hash.respond_to?(:symbolize_keys)
       hash.reduce({}) do |new_hash, (key, value)|

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.8.37'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/lib/dynflow/web/console.rb

@@ -33,28 +33,30 @@ module Dynflow
       end
 
       get('/worlds') do
-        @worlds = world.coordinator.find_worlds
+        load_worlds
         erb :worlds
       end
 
       post('/worlds/execution_status') do
-        @worlds = world.coordinator.find_worlds(true)
-        @worlds.each do |w|
+        load_worlds
+        @executors.each do |w|
           hash = world.get_execution_status(w.data['id'], nil, 5).value!
-          hash[:execution_status] = hash[:execution_status].values.reduce(:+) || 0
-          w.data.update(hash)
+          hash.each do |_queue_name, info|
+            info[:queue_size] = info[:execution_status].values.reduce(:+) || 0
+          end
+          w.data.update(:status => hash)
         end
         erb :worlds
       end
 
       post('/worlds/check') do
-        @worlds = world.coordinator.find_worlds
+        load_worlds
         @validation_results = world.worlds_validity_check(params[:invalidate])
         erb :worlds
       end
 
       post('/worlds/:id/check') do |id|
-        @worlds = world.coordinator.find_worlds
+        load_worlds
         @validation_results = world.worlds_validity_check(params[:invalidate], id: params[:id])
         erb :worlds
       end

data/lib/dynflow/web/console_helpers.rb

@@ -9,6 +9,22 @@ module Dynflow
         end
       end
 
+      def value_field(key, value)
+        strip_heredoc(<<-HTML)
+          <p>
+            <b>#{key}:</b>
+            #{h(value)}
+          </p>
+        HTML
+      end
+
+      def strip_heredoc(str)
+        strip_size = str.lines.reject { |l| l =~ /^\s*$/ }.map { |l| l[/^\s*/].length }.min
+        str.lines.map do |line|
+          line[strip_size..-1] || ''
+        end.join
+      end
+
       def prettify_value(value)
         YAML.dump(value)
       end

data/lib/dynflow/web/filtering_helpers.rb

@@ -28,6 +28,11 @@ module Dynflow
         return @filtering_options
       end
 
+      def load_worlds(executors_only = false)
+        @worlds = world.coordinator.find_worlds(executors_only)
+        @executors, @clients = @worlds.partition(&:executor?)
+      end
+
       def find_execution_plans_options(show_all = false)
         options = Utils.indifferent_hash({})
         options.merge!(filtering_options(show_all))

data/lib/dynflow/world.rb

@@ -4,7 +4,7 @@ module Dynflow
     include Algebrick::TypeCheck
     include Algebrick::Matching
 
-    attr_reader :id, :client_dispatcher, :executor_dispatcher, :executor, :connector,
+    attr_reader :id, :config, :client_dispatcher, :executor_dispatcher, :executor, :connector,
                 :transaction_adapter, :logger_adapter, :coordinator,
                 :persistence, :action_classes, :subscription_index,
                 :middleware, :auto_rescue, :clock, :meta, :delayed_executor, :auto_validity_check, :validity_check_timeout, :throttle_limiter,
@@ -13,53 +13,53 @@ module Dynflow
     def initialize(config)
       @id                     = SecureRandom.uuid
       @clock                  = spawn_and_wait(Clock, 'clock')
-      config_for_world        = Config::ForWorld.new(config, self)
-      @logger_adapter         = config_for_world.logger_adapter
-      config_for_world.validate
-      @transaction_adapter    = config_for_world.transaction_adapter
-      @persistence            = Persistence.new(self, config_for_world.persistence_adapter,
-                                                :backup_deleted_plans => config_for_world.backup_deleted_plans,
-                                                :backup_dir => config_for_world.backup_dir)
-      @coordinator            = Coordinator.new(config_for_world.coordinator_adapter)
-      @executor               = config_for_world.executor
-      @action_classes         = config_for_world.action_classes
-      @auto_rescue            = config_for_world.auto_rescue
-      @exit_on_terminate      = Concurrent::AtomicBoolean.new(config_for_world.exit_on_terminate)
-      @connector              = config_for_world.connector
+      @config                 = Config::ForWorld.new(config, self)
+      @logger_adapter         = @config.logger_adapter
+      @config.validate
+      @transaction_adapter    = @config.transaction_adapter
+      @persistence            = Persistence.new(self, @config.persistence_adapter,
+                                                :backup_deleted_plans => @config.backup_deleted_plans,
+                                                :backup_dir => @config.backup_dir)
+      @coordinator            = Coordinator.new(@config.coordinator_adapter)
+      @executor               = @config.executor
+      @action_classes         = @config.action_classes
+      @auto_rescue            = @config.auto_rescue
+      @exit_on_terminate      = Concurrent::AtomicBoolean.new(@config.exit_on_terminate)
+      @connector              = @config.connector
       @middleware             = Middleware::World.new
       @middleware.use Middleware::Common::Transaction if @transaction_adapter
       @client_dispatcher      = spawn_and_wait(Dispatcher::ClientDispatcher, "client-dispatcher", self)
-      @dead_letter_handler    = spawn_and_wait(DeadLetterSilencer, 'default_dead_letter_handler', config_for_world.silent_dead_letter_matchers)
-      @meta                   = config_for_world.meta
-      @auto_validity_check    = config_for_world.auto_validity_check
-      @validity_check_timeout = config_for_world.validity_check_timeout
-      @throttle_limiter       = config_for_world.throttle_limiter
+      @dead_letter_handler    = spawn_and_wait(DeadLetterSilencer, 'default_dead_letter_handler', @config.silent_dead_letter_matchers)
+      @auto_validity_check    = @config.auto_validity_check
+      @validity_check_timeout = @config.validity_check_timeout
+      @throttle_limiter       = @config.throttle_limiter
       @terminated             = Concurrent.event
-      @termination_timeout    = config_for_world.termination_timeout
+      @termination_timeout    = @config.termination_timeout
       calculate_subscription_index
 
       if executor
-        @executor_dispatcher = spawn_and_wait(Dispatcher::ExecutorDispatcher, "executor-dispatcher", self, config_for_world.executor_semaphore)
+        @executor_dispatcher = spawn_and_wait(Dispatcher::ExecutorDispatcher, "executor-dispatcher", self, @config.executor_semaphore)
         executor.initialized.wait
       end
       perform_validity_checks if auto_validity_check
 
-      @delayed_executor         = try_spawn(config_for_world, :delayed_executor, Coordinator::DelayedExecutorLock)
-      @execution_plan_cleaner   = try_spawn(config_for_world, :execution_plan_cleaner, Coordinator::ExecutionPlanCleanerLock)
-      @meta                     = config_for_world.meta
+      @delayed_executor         = try_spawn(:delayed_executor, Coordinator::DelayedExecutorLock)
+      @execution_plan_cleaner   = try_spawn(:execution_plan_cleaner, Coordinator::ExecutionPlanCleanerLock)
+      @meta                     = @config.meta
+      @meta['queues']           = @config.queues if @executor
       @meta['delayed_executor'] = true if @delayed_executor
       @meta['execution_plan_cleaner'] = true if @execution_plan_cleaner
       coordinator.register_world(registered_world)
       @termination_barrier = Mutex.new
       @before_termination_hooks = Queue.new
 
-      if config_for_world.auto_terminate
+      if @config.auto_terminate
         at_exit do
           @exit_on_terminate.make_false # make sure we don't terminate twice
           self.terminate.wait
         end
       end
-      self.auto_execute if config_for_world.auto_execute
+      self.auto_execute if @config.auto_execute
       @delayed_executor.start if @delayed_executor
     end
 
@@ -402,9 +402,9 @@ module Dynflow
       []
     end
 
-    def try_spawn(config_for_world, what, lock_class = nil)
+    def try_spawn(what, lock_class = nil)
       object = nil
-      return nil if !executor || (object = config_for_world.public_send(what)).nil?
+      return nil if !executor || (object = @config.public_send(what)).nil?
 
       coordinator.acquire(lock_class.new(self)) if lock_class
       object.spawn.wait

data/test/activejob_adapter_test.rb

@@ -4,6 +4,8 @@ require 'dynflow/active_job/queue_adapter'
 
 module Dynflow
   class SampleJob < ::ActiveJob::Base
+    queue_as :slow
+
     def perform(msg)
       puts "This job says #{msg}"
     end
@@ -20,8 +22,10 @@ module Dynflow
       rails_app_mock .expect(:dynflow, dynflow_mock)
       rails_mock = Minitest::Mock.new
       rails_mock.expect(:application, rails_app_mock)
-      @original_rails = ::Rails
-      Object.send(:remove_const, 'Rails')
+      if defined? ::Rails
+        @original_rails = ::Rails
+        Object.send(:remove_const, 'Rails')
+      end
       Object.const_set('Rails', rails_mock)
     end
 

data/test/support/dummy_example.rb

@@ -38,6 +38,10 @@ module Support
         $slow_actions_done ||= 0
         $slow_actions_done +=1
       end
+
+      def queue
+        :slow
+      end
     end
 
     class Polling < Dynflow::Action

data/test/test_helper.rb

@@ -95,6 +95,7 @@ module WorldFactory
     config.auto_terminate       = false
     config.backup_deleted_plans = false
     config.backup_dir           = nil
+    config.queues.add(:slow, :pool_size => 1)
     yield config if block_given?
     return config
   end

data/test/world_test.rb

@@ -10,24 +10,29 @@ module Dynflow
       describe '#meta' do
         it 'by default informs about the hostname and the pid running the world' do
           registered_world = world.coordinator.find_worlds(false, id: world.id).first
-          registered_world.meta.must_equal('hostname' => Socket.gethostname, 'pid' => Process.pid)
+          registered_world.meta.must_equal('hostname' => Socket.gethostname, 'pid' => Process.pid,
+                                           'queues' => { 'default' => { 'pool_size' => 5 },
+                                                         'slow' => { 'pool_size' => 1 }})
         end
 
         it 'is configurable' do
           registered_world = world.coordinator.find_worlds(false, id: world_with_custom_meta.id).first
-          registered_world.meta.must_equal('fast' => true)
+          registered_world.meta['fast'].must_equal true
         end
       end
 
       describe '#get_execution_status' do
         let(:base) do
-          { :pool_size => 5, :free_workers => 5, :execution_status => {} }
+          { :default => { :pool_size => 5, :free_workers => 5, :execution_status => {} },
+            :slow => { :pool_size=> 1, :free_workers=> 1, :execution_status=> {}} }
         end
 
         it 'retrieves correct execution items count' do
           world.get_execution_status(world.id, nil, 5).value!.must_equal(base)
           id = 'something like uuid'
-          expected = base.merge(:execution_status => { id => 0 })
+          expected = base.dup
+          expected[:default][:execution_status] = { id => 0 }
+          expected[:slow][:execution_status] = { id => 0 }
           world.get_execution_status(world.id, id, 5).value!.must_equal(expected)
         end
       end

data/web/views/world_validation_result.erb

@@ -0,0 +1,15 @@
+<% validation_result = @validation_results[world.id] if @validation_results %>
+
+<% unless validation_result == :invalidated %>
+  <a href="<%= url("/worlds/#{world.id}/check") %>" class="postlink">check</a>
+<% end %>
+
+<% if validation_result %>
+  <% if validation_result == :invalid %>
+    <a href="<%= url("/worlds/#{world.id}/check?invalidate=true") %>" class="postlink">invalidate</a>
+  <% end %>
+
+  <span class="label label-<%= validation_result_css_class(validation_result) %>">
+    <%= h(validation_result) %>
+  </span>
+<% end %>

data/web/views/worlds.erb

@@ -6,41 +6,48 @@
   <li><a href="<%= url("/worlds/execution_status") %>" class="postlink">load execution items counts</a>: see counts of execution items per world</li>
 </ul>
 
+<h3>Executors</h3>
+<% @executors.each do |world| %>
+  <%= value_field('Id', world.id) %>
+  <%= value_field('Metadata', world.meta) %>
+  <p>
+    <b>Status:</b>
+    <%= erb :world_validation_result, locals: { world: world } %>
+  </p>
+  <% if world.data[:status] %>
+    <table class="table">
+      <thead>
+        <tr>
+          <th>Queue name</th>
+          <th>Queue size</th>
+          <th>Free/Total workers</th>
+        </tr>
+      </thead>
+    <% world.data[:status].each do |queue_name, info| %>
+      <tr>
+        <td><%= h(queue_name) %></td>
+        <td><%= h(info[:queue_size]) %></td>
+        <td><%= h(info[:free_workers]) %>/<%= h(info[:pool_size]) %></td>
+      </tr>
+    <% end %>
+    </table>
+  <% end %>
+<% end %>
+<h3>Clients</h3>
 <table class="table">
   <thead>
     <tr>
       <th>Id</th>
       <th>Meta</th>
-      <th>Executor?</th>
-      <th>Execution items</th>
-      <th>Free/Total workers</th>
       <th></th>
     </tr>
   </thead>
-
-<% @worlds.each do |world| %>
+<% @clients.each do |world| %>
   <tr>
     <td><%= h(world.id) %></td>
     <td><%= h(world.meta) %></td>
-    <td><%= "true" if world.is_a? Dynflow::Coordinator::ExecutorWorld %></td>
-    <td><%= h(world.data['execution_status'] || 'N/A') %></td>
-    <td><%= world.data.key?('free_workers') ? "#{world.data['free_workers']}/#{world.data[:pool_size]}" : 'N/A' %></td>
     <td>
-      <% validation_result = @validation_results[world.id] if @validation_results %>
-
-      <% unless validation_result == :invalidated %>
-        <a href="<%= url("/worlds/#{world.id}/check") %>" class="postlink">check</a>
-      <% end %>
-
-      <% if validation_result %>
-        <% if validation_result == :invalid %>
-          <a href="<%= url("/worlds/#{world.id}/check?invalidate=true") %>" class="postlink">invalidate</a>
-        <% end %>
-
-        <span class="label label-<%= validation_result_css_class(validation_result) %>">
-          <%= h(validation_result) %>
-        </span>
-      <% end %>
+      <%= erb :world_validation_result, locals: { world: world } %>
     </td>
   </tr>
 <% end %>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 0.8.37
+  version: 1.0.0
 platform: ruby
 authors:
 - Ivan Necas
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-12 00:00:00.000000000 Z
+date: 2018-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -482,6 +482,7 @@ files:
 - lib/dynflow/persistence_adapters/sequel_migrations/013_add_action_columns.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/014_add_step_columns.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/015_add_execution_plan_columns.rb
+- lib/dynflow/persistence_adapters/sequel_migrations/016_add_step_queue.rb
 - lib/dynflow/rails.rb
 - lib/dynflow/rails/configuration.rb
 - lib/dynflow/rails/daemon.rb
@@ -579,6 +580,7 @@ files:
 - web/views/layout.erb
 - web/views/plan_step.erb
 - web/views/show.erb
+- web/views/world_validation_result.erb
 - web/views/worlds.erb
 homepage: http://github.com/Dynflow/dynflow
 licenses: