dynflow 1.3.0 → 1.4.0

data/test/testing_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -13,11 +14,11 @@ module Dynflow
         input  = { 'input' => 'input' }
         action = create_and_plan_action Support::DummyExample::WeightedPolling, input
 
-        action.must_be_kind_of Support::DummyExample::WeightedPolling
-        action.phase.must_equal Action::Plan
-        action.input.must_equal input
-        action.execution_plan.must_be_kind_of Testing::DummyExecutionPlan
-        action.state.must_equal :success
+        _(action).must_be_kind_of Support::DummyExample::WeightedPolling
+        _(action.phase).must_equal Action::Plan
+        _(action.input).must_equal input
+        _(action.execution_plan).must_be_kind_of Testing::DummyExecutionPlan
+        _(action.state).must_equal :success
         assert_run_phase action
         assert_finalize_phase action
         assert_action_planned action, Support::DummyExample::Polling
@@ -31,13 +32,13 @@ module Dynflow
         end
         plan_action(action, {})
         stubbed_action = action.execution_plan.planned_plan_steps.first
-        stubbed_action.test.must_equal "test"
+        _(stubbed_action.test).must_equal "test"
       end
 
       specify '#create_action_presentation' do
         action = create_action_presentation(Support::DummyExample::WeightedPolling)
         action.output['message'] = 'make the world a better place'
-        action.humanized_output.must_equal 'You should make the world a better place'
+        _(action.humanized_output).must_equal 'You should make the world a better place'
       end
 
       specify '#run_action without suspend' do
@@ -45,12 +46,12 @@ module Dynflow
         plan   = create_and_plan_action Support::DummyExample::WeightedPolling, input
         action = run_action plan
 
-        action.must_be_kind_of Support::DummyExample::WeightedPolling
-        action.phase.must_equal Action::Run
-        action.input.must_equal input
-        action.world.must_equal plan.world
-        action.run_step_id.wont_equal action.plan_step_id
-        action.state.must_equal :success
+        _(action).must_be_kind_of Support::DummyExample::WeightedPolling
+        _(action.phase).must_equal Action::Run
+        _(action.input).must_equal input
+        _(action.world).must_equal plan.world
+        _(action.run_step_id).wont_equal action.plan_step_id
+        _(action.state).must_equal :success
       end
 
       specify '#run_action with suspend' do
@@ -58,25 +59,25 @@ module Dynflow
         plan   = create_and_plan_action Support::DummyExample::Polling, input
         action = run_action plan
 
-        action.output.must_equal 'task' => { 'progress' => 0, 'done' => false }
-        action.run_progress.must_equal 0
+        _(action.output).must_equal 'task' => { 'progress' => 0, 'done' => false }
+        _(action.run_progress).must_equal 0
 
         3.times { progress_action_time action }
-        action.output.must_equal('task' => { 'progress' => 30, 'done' => false } ,
+        _(action.output).must_equal('task' => { 'progress' => 30, 'done' => false } ,
                                  'poll_attempts' => {'total' => 2, 'failed'=> 0 })
-        action.run_progress.must_equal 0.3
+        _(action.run_progress).must_equal 0.3
 
         run_action action, Dynflow::Action::Polling::Poll
         run_action action, Dynflow::Action::Polling::Poll
-        action.output.must_equal('task' => { 'progress' => 50, 'done' => false },
+        _(action.output).must_equal('task' => { 'progress' => 50, 'done' => false },
                                  'poll_attempts' => {'total' => 4, 'failed' => 0 })
-        action.run_progress.must_equal 0.5
+        _(action.run_progress).must_equal 0.5
 
         5.times { progress_action_time action }
 
-        action.output.must_equal('task' => { 'progress' => 100, 'done' => true },
+        _(action.output).must_equal('task' => { 'progress' => 100, 'done' => true },
                                  'poll_attempts' => {'total' => 9, 'failed' => 0 })
-        action.run_progress.must_equal 1
+        _(action.run_progress).must_equal 1
       end
 
       specify '#finalize_action' do
@@ -86,15 +87,15 @@ module Dynflow
         $dummy_heavy_progress = false
         action                = finalize_action run
 
-        action.must_be_kind_of Support::DummyExample::WeightedPolling
-        action.phase.must_equal Action::Finalize
-        action.input.must_equal input
-        action.output.must_equal run.output
-        action.world.must_equal plan.world
-        action.finalize_step_id.wont_equal action.run_step_id
-        action.state.must_equal :success
+        _(action).must_be_kind_of Support::DummyExample::WeightedPolling
+        _(action.phase).must_equal Action::Finalize
+        _(action.input).must_equal input
+        _(action.output).must_equal run.output
+        _(action.world).must_equal plan.world
+        _(action.finalize_step_id).wont_equal action.run_step_id
+        _(action.state).must_equal :success
 
-        $dummy_heavy_progress.must_equal 'dummy_heavy_progress'
+        _($dummy_heavy_progress).must_equal 'dummy_heavy_progress'
       end
     end
 
@@ -104,7 +105,7 @@ module Dynflow
         it 'plans' do
           action = create_and_plan_action CWE::Commit, sha = 'commit-sha'
 
-          action.input.must_equal({})
+          _(action.input).must_equal({})
           refute_run_phase action
           refute_finalize_phase action
 
@@ -123,15 +124,15 @@ module Dynflow
         let(:runned_action) { run_action planned_action }
 
         it 'plans' do
-          planned_action.input.must_equal Utils.stringify_keys(input)
+          _(planned_action.input).must_equal Utils.stringify_keys(input)
           assert_run_phase planned_action, { commit: "sha", reviewer: "name", result: true}
           refute_finalize_phase planned_action
 
-          planned_action.execution_plan.planned_plan_steps.must_be_empty
+          _(planned_action.execution_plan.planned_plan_steps).must_be_empty
         end
 
         it 'runs' do
-          runned_action.output.fetch(:passed).must_equal runned_action.input.fetch(:result)
+          _(runned_action.output.fetch(:passed)).must_equal runned_action.input.fetch(:result)
         end
       end
 
@@ -143,15 +144,15 @@ module Dynflow
 
         it 'plans' do
           assert_run_phase planned_action do |input|
-            input[:commit].must_equal "sha"
+            _(input[:commit]).must_equal "sha"
           end
           refute_finalize_phase planned_action
 
-          planned_action.execution_plan.planned_plan_steps.must_be_empty
+          _(planned_action.execution_plan.planned_plan_steps).must_be_empty
         end
 
         it 'runs' do
-          runned_action.output.fetch(:passed).must_equal true
+          _(runned_action.output.fetch(:passed)).must_equal true
         end
 
         describe 'when something fails' do
@@ -160,7 +161,7 @@ module Dynflow
           end
 
           it 'runs' do
-            runned_action.output.fetch(:passed).must_equal false
+            _(runned_action.output.fetch(:passed)).must_equal false
           end
         end
       end
@@ -196,7 +197,7 @@ module Dynflow
         f.wait
 
         f.value.tap do |plan|
-          plan.state.must_equal :stopped
+          _(plan.state).must_equal :stopped
         end
       end
     end
@@ -228,7 +229,7 @@ module Dynflow
       let :failed_execution_plan do
         plan = world.plan(Support::CodeWorkflowExample::IncomingIssues, failing_issues_data)
         plan = world.execute(plan.id).value
-        plan.state.must_equal :paused
+        _(plan.state).must_equal :paused
         plan
       end
 
@@ -238,19 +239,19 @@ module Dynflow
 
       it "is able to execute plans inside the thread" do
         world.execute(execution_plan.id).value.tap do |plan|
-          plan.state.must_equal :stopped
+          _(plan.state).must_equal :stopped
         end
       end
 
       it "is able to handle errors in the plan" do
         world.execute(failed_execution_plan.id).value.tap do |plan|
-          plan.state.must_equal :paused
+          _(plan.state).must_equal :paused
         end
       end
 
       it "is able to handle when events" do
         world.execute(polling_execution_plan.id).value.tap do |plan|
-          plan.state.must_equal :stopped
+          _(plan.state).must_equal :stopped
         end
       end
 
@@ -268,8 +269,8 @@ module Dynflow
           end
 
           it 'skips the action and continues automatically' do
-            execution_plan.state.must_equal :stopped
-            execution_plan.result.must_equal :warning
+            _(execution_plan.state).must_equal :stopped
+            _(execution_plan.result).must_equal :warning
           end
         end
       end

data/test/utils_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -7,49 +8,49 @@ module Dynflow
 
       it 'can insert elements' do
         queue.push 1
-        queue.top.must_equal 1
+        _(queue.top).must_equal 1
         queue.push 2
-        queue.top.must_equal 2
+        _(queue.top).must_equal 2
         queue.push 3
-        queue.top.must_equal 3
-        queue.to_a.must_equal [1, 2, 3]
+        _(queue.top).must_equal 3
+        _(queue.to_a).must_equal [1, 2, 3]
       end
 
       it 'can override the comparator' do
         queue = Utils::PriorityQueue.new { |a, b| b <=> a }
         queue.push 1
-        queue.top.must_equal 1
+        _(queue.top).must_equal 1
         queue.push 2
-        queue.top.must_equal 1
+        _(queue.top).must_equal 1
         queue.push 3
-        queue.top.must_equal 1
-        queue.to_a.must_equal [3, 2, 1]
+        _(queue.top).must_equal 1
+        _(queue.to_a).must_equal [3, 2, 1]
       end
 
       it 'can inspect top element without removing it' do
-        queue.top.must_be_nil
+        assert_nil queue.top
         queue.push(1)
-        queue.top.must_equal 1
+        _(queue.top).must_equal 1
         queue.push(3)
-        queue.top.must_equal 3
+        _(queue.top).must_equal 3
         queue.push(2)
-        queue.top.must_equal 3
+        _(queue.top).must_equal 3
       end
 
       it 'can report size' do
         count = 5
         count.times { queue.push 1 }
-        queue.size.must_equal count
+        _(queue.size).must_equal count
       end
 
       it 'pops elements in correct order' do
         queue.push 1
         queue.push 3
         queue.push 2
-        queue.pop.must_equal 3
-        queue.pop.must_equal 2
-        queue.pop.must_equal 1
-        queue.pop.must_equal nil
+        _(queue.pop).must_equal 3
+        _(queue.pop).must_equal 2
+        _(queue.pop).must_equal 1
+        assert_nil queue.pop
       end
     end
   end

data/test/web_console_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 ENV['RACK_ENV'] = 'test'

data/test/world_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 require 'fileutils'
 
@@ -11,14 +12,14 @@ module Dynflow
         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.delete('last_seen')
-          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['fast'].must_equal true
+          _(registered_world.meta['fast']).must_equal true
         end
       end
 
@@ -29,24 +30,24 @@ module Dynflow
         end
 
         it 'retrieves correct execution items count' do
-          world.get_execution_status(world.id, nil, 5).value!.must_equal(base)
+          _(world.get_execution_status(world.id, nil, 5).value!).must_equal(base)
           id = 'something like uuid'
           expected = base.dup
           expected[:default][:queue_size] = 0
           expected[:slow][:queue_size] =  0
-          world.get_execution_status(world.id, id, 5).value!.must_equal(expected)
+          _(world.get_execution_status(world.id, id, 5).value!).must_equal(expected)
         end
       end
 
       describe '#terminate' do
         it 'fires an event after termination' do
           terminated_event = world.terminated
-          terminated_event.resolved?.must_equal false
+          _(terminated_event.resolved?).must_equal false
           world.terminate
           # wait for termination process to finish, but don't block
           # the test from running.
           terminated_event.wait(10)
-          terminated_event.resolved?.must_equal true
+          _(terminated_event.resolved?).must_equal true
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Ivan Necas
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-15 00:00:00.000000000 Z
+date: 2019-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -232,6 +232,7 @@ files:
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".travis.yml"
+- Dockerfile
 - Gemfile
 - MIT-LICENSE
 - README.md
@@ -369,6 +370,7 @@ files:
 - doc/pages/source/index.md
 - doc/pages/source/media/index.md
 - doc/pages/source/projects/index.md
+- docker-compose.yml
 - dynflow.gemspec
 - examples/clock_benchmark.rb
 - examples/example_helper.rb
@@ -420,10 +422,10 @@ files:
 - lib/dynflow/director.rb
 - lib/dynflow/director/execution_plan_manager.rb
 - lib/dynflow/director/flow_manager.rb
+- lib/dynflow/director/queue_hash.rb
 - lib/dynflow/director/running_steps_manager.rb
 - lib/dynflow/director/sequence_cursor.rb
 - lib/dynflow/director/sequential_manager.rb
-- lib/dynflow/director/work_queue.rb
 - lib/dynflow/dispatcher.rb
 - lib/dynflow/dispatcher/abstract.rb
 - lib/dynflow/dispatcher/client_dispatcher.rb
@@ -442,11 +444,17 @@ files:
 - lib/dynflow/execution_plan/steps/plan_step.rb
 - lib/dynflow/execution_plan/steps/run_step.rb
 - lib/dynflow/executors.rb
-- lib/dynflow/executors/abstract.rb
+- lib/dynflow/executors/abstract/core.rb
 - lib/dynflow/executors/parallel.rb
 - lib/dynflow/executors/parallel/core.rb
 - lib/dynflow/executors/parallel/pool.rb
 - lib/dynflow/executors/parallel/worker.rb
+- lib/dynflow/executors/sidekiq/core.rb
+- lib/dynflow/executors/sidekiq/internal_job_base.rb
+- lib/dynflow/executors/sidekiq/orchestrator_jobs.rb
+- lib/dynflow/executors/sidekiq/redis_locking.rb
+- lib/dynflow/executors/sidekiq/serialization.rb
+- lib/dynflow/executors/sidekiq/worker_jobs.rb
 - lib/dynflow/flows.rb
 - lib/dynflow/flows/abstract.rb
 - lib/dynflow/flows/abstract_composed.rb
@@ -489,6 +497,7 @@ files:
 - lib/dynflow/persistence_adapters/sequel_migrations/016_add_step_queue.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/017_add_delayed_plan_frozen.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/018_add_uuid_column.rb
+- lib/dynflow/persistence_adapters/sequel_migrations/019_update_mysql_time_precision.rb
 - lib/dynflow/rails.rb
 - lib/dynflow/rails/configuration.rb
 - lib/dynflow/rails/daemon.rb

data/lib/dynflow/executors/abstract.rb

@@ -1,40 +0,0 @@
-module Dynflow
-  module Executors
-    class Abstract
-      include Algebrick::TypeCheck
-      attr_reader :world, :logger
-
-      def initialize(world)
-        @world  = Type! world, World
-        @logger = world.logger
-      end
-
-      # @param execution_plan_id [String] id of execution plan
-      # @param finished [Concurrent::Promises::ResolvableFuture]
-      # @param wait_for_acceptance [TrueClass|FalseClass] should the executor confirm receiving
-      # the event, disable if calling executor from within executor
-      # @return [Concurrent::Promises::ResolvableFuture]
-      # @raise when execution_plan_id is not accepted
-      def execute(execution_plan_id, finished = Concurrent::Promises.resolvable_future, wait_for_acceptance = true)
-        raise NotImplementedError
-      end
-
-      def event(execution_plan_id, step_id, event, future = Concurrent::Promises.resolvable_future)
-        raise NotImplementedError
-      end
-
-      def terminate(future = Concurrent::Promises.resolvable_future)
-        raise NotImplementedError
-      end
-
-      def execution_status(execution_plan_id = nil)
-        raise NotImplementedError
-      end
-
-      # @return [Concurrent::Promises::ResolvableFuture]
-      def initialized
-        raise NotImplementedError
-      end
-    end
-  end
-end