dynflow 0.2.0 → 0.3.0

data/test/middleware_test.rb

@@ -0,0 +1,109 @@
+require_relative 'test_helper'
+
+module Dynflow
+  module MiddlewareTest
+
+    describe 'Middleware' do
+      let(:world) { WorldInstance.world }
+      let(:log) { Support::MiddlewareExample::LogMiddleware.log }
+
+      before do
+        Support::MiddlewareExample::LogMiddleware.reset_log
+      end
+
+      it "wraps the action method calls" do
+        world.trigger(Support::MiddlewareExample::LoggingAction, {}).finished.wait
+        log.must_equal %w[LogMiddleware::before_plan_phase
+                          LogMiddleware::before_plan
+                          plan
+                          LogMiddleware::after_plan
+                          LogMiddleware::after_plan_phase
+                          LogMiddleware::before_run
+                          run
+                          LogMiddleware::after_run
+                          LogMiddleware::before_finalize_phase
+                          LogMiddleware::before_finalize
+                          finalize
+                          LogMiddleware::after_finalize
+                          LogMiddleware::after_finalize_phase]
+      end
+
+      it "inherits the middleware" do
+        world.trigger(Support::MiddlewareExample::SubAction, {}).finished.wait
+        log.must_equal %w[LogRunMiddleware::before_run
+                          AnotherLogRunMiddleware::before_run
+                          run
+                          AnotherLogRunMiddleware::after_run
+                          LogRunMiddleware::after_run]
+      end
+
+      describe "world.middleware" do
+        let(:world_with_middleware) do
+          WorldInstance.create_world.tap do |world|
+            world.middleware.use(Support::MiddlewareExample::AnotherLogRunMiddleware)
+          end
+        end
+
+        it "puts the middleware to the beginning of the stack" do
+            world_with_middleware.trigger(Support::MiddlewareExample::Action, {}).finished.wait
+            log.must_equal %w[AnotherLogRunMiddleware::before_run
+                              LogRunMiddleware::before_run
+                              run
+                              LogRunMiddleware::after_run
+                              AnotherLogRunMiddleware::after_run]
+        end
+      end
+
+      describe "rules" do
+        describe "before" do
+          specify do
+            world.trigger(Support::MiddlewareExample::SubActionBeforeRule, {}).finished.wait
+            log.must_equal %w[AnotherLogRunMiddleware::before_run
+                              LogRunMiddleware::before_run
+                              run
+                              LogRunMiddleware::after_run
+                              AnotherLogRunMiddleware::after_run]
+          end
+        end
+
+        describe "after" do
+          let(:world_with_middleware) do
+            WorldInstance.create_world.tap do |world|
+              world.middleware.use(Support::MiddlewareExample::AnotherLogRunMiddleware,
+                                   after: Support::MiddlewareExample::LogRunMiddleware)
+
+            end
+          end
+
+          specify do
+            world_with_middleware.trigger(Support::MiddlewareExample::Action, {}).finished.wait
+            log.must_equal %w[LogRunMiddleware::before_run
+                              AnotherLogRunMiddleware::before_run
+                              run
+                              AnotherLogRunMiddleware::after_run
+                              LogRunMiddleware::after_run]
+          end
+        end
+
+        describe "replace" do
+          specify do
+            world.trigger(Support::MiddlewareExample::SubActionReplaceRule, {}).finished.wait
+            log.must_equal %w[AnotherLogRunMiddleware::before_run
+                              run
+                              AnotherLogRunMiddleware::after_run]
+          end
+        end
+      end
+
+      it "allows access the running action" do
+        world = WorldInstance.create_world
+        world.middleware.use(Support::MiddlewareExample::ObservingMiddleware,
+                             replace: Support::MiddlewareExample::LogRunMiddleware)
+        world.trigger(Support::MiddlewareExample::Action, message: 'hello').finished.wait
+        log.must_equal %w[input#message:hello
+                          run
+                          output#message:finished]
+      end
+    end
+  end
+end

data/test/remote_via_socket_test.rb

@@ -0,0 +1,166 @@
+require_relative 'test_helper'
+
+describe 'remote communication' do
+
+  let(:persistence_adapter) { Dynflow::PersistenceAdapters::Sequel.new('sqlite:/') }
+
+  module Helpers
+    def socket_path
+      @socket_path ||= Dir.tmpdir + "/dynflow_remote_#{rand(1e30)}"
+    end
+
+    def logger_adapter
+      WorldInstance.logger_adapter
+    end
+
+    def create_world
+      Dynflow::SimpleWorld.new logger_adapter:      logger_adapter,
+                               auto_terminate:      false,
+                               persistence_adapter: persistence_adapter
+    end
+
+    def create_remote_world
+      Dynflow::SimpleWorld.new(
+          logger_adapter:      logger_adapter,
+          auto_terminate:      false,
+          persistence_adapter: persistence_adapter,
+          executor:            -> remote_world do
+            Dynflow::Executors::RemoteViaSocket.new(remote_world, socket_path)
+          end)
+    end
+
+    def create_listener(world)
+      Dynflow::Listeners::Socket.new world, socket_path, 0.05
+    end
+
+    def terminate(*terminable)
+      terminable.each { |t| t.terminate.wait }
+    end
+  end
+
+  include Helpers
+
+  it 'raises when not connected' do
+    remote_world = create_remote_world
+    result       = remote_world.trigger Support::CodeWorkflowExample::Commit, 'sha'
+    result.planned.must_equal true
+    -> { result.finished.value! }.must_raise Dynflow::Error
+
+    terminate remote_world
+  end
+
+  describe 'execute_planned_execution_plans' do
+    specify do
+      remote_world = create_remote_world
+      result       = remote_world.trigger Support::CodeWorkflowExample::Commit, 'sha'
+      result.planned.must_equal true
+      -> { result.finished.value! }.must_raise Dynflow::Error
+
+      remote_world.persistence.load_execution_plan(result.id).state.must_equal :planned
+
+      world    = create_world
+      listener = create_listener(world)
+
+      # waiting until it starts executing
+      assert(10.times do |i|
+        state = world.persistence.load_execution_plan(result.id).state
+        break :ok if [:running, :stopped].include? state
+        puts 'retry'
+        sleep 0.01 * i
+      end == :ok)
+
+      terminate remote_world, listener, world
+    end
+  end
+
+  describe 'shutting down' do
+    [:remote_world, :world, :listener].permutation.each do |order|
+      it "works when in order #{order}" do
+        objects = { world:        w = create_world,
+                    listener:     create_listener(w),
+                    remote_world: remote_world = create_remote_world }
+
+        result = remote_world.trigger Support::CodeWorkflowExample::Commit, 'sha'
+        result.planned.must_equal true
+        result.finished.value!.must_be_kind_of Dynflow::ExecutionPlan
+
+        terminate *objects.values_at(*order)
+        assert true, 'it has to reach this'
+      end
+    end
+
+    it 'allows to work others' do
+      world    = create_world
+      listener = create_listener(world)
+      rmw1     = create_remote_world
+      rmw2     = create_remote_world
+
+      [rmw1.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished,
+       rmw2.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished].
+          each(&:value!)
+
+      terminate rmw1
+
+      -> { rmw1.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished.value! }.
+          must_raise Dynflow::Error
+      rmw2.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished.value!
+
+      terminate rmw2, listener, world
+    end
+
+    it 'raises when disconnected while executing' do
+      world        = create_world
+      listener     = create_listener(world)
+      remote_world = create_remote_world
+
+      result = remote_world.trigger(Support::CodeWorkflowExample::Slow, 2)
+      result.planned.must_equal true
+
+      terminate listener
+
+      -> { result.finished.value! }.must_raise Dynflow::Future::FutureFailed
+      terminate remote_world, world
+    end
+
+  end
+
+  it 'restarts' do
+    world        = create_world
+    listener     = create_listener(world)
+    remote_world = create_remote_world
+
+    remote_world.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished.value!
+
+    terminate listener
+    Thread.pass while remote_world.executor.connected?
+    listener = create_listener world
+    Thread.pass until remote_world.executor.connected?
+
+    remote_world.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished.value!
+
+    terminate listener, world
+    Thread.pass while remote_world.executor.connected?
+    world    = create_world
+    listener = create_listener world
+    Thread.pass until remote_world.executor.connected?
+
+    remote_world.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished.value!
+
+    terminate listener, world, remote_world
+  end
+
+  describe '#connected?' do
+    specify do
+      remote_world = create_remote_world
+
+      remote_world.executor.connected?.must_equal false
+
+      world    = create_world
+      listener = create_listener world
+
+      remote_world.executor.connected?.must_equal true
+
+      terminate listener, world, remote_world
+    end
+  end
+end

data/test/{code_workflow_example.rb → support/code_workflow_example.rb}

@@ -1,9 +1,9 @@
 require 'logger'
 
-module Dynflow
+module Support
   module CodeWorkflowExample
 
-    class IncomingIssues < Action
+    class IncomingIssues < Dynflow::Action
 
       def plan(issues)
         issues.each do |issue|
@@ -25,7 +25,7 @@ module Dynflow
 
       def summary
         triages   = all_actions.find_all do |action|
-          action.is_a? Dynflow::CodeWorkflowExample::Triage
+          action.is_a? Triage
         end
         assignees = triages.map do |triage|
           triage.output[:classification] &&
@@ -36,7 +36,7 @@ module Dynflow
 
     end
 
-    class Slow < Action
+    class Slow < Dynflow::Action
       def plan(seconds)
         plan_self interval: seconds
       end
@@ -49,7 +49,7 @@ module Dynflow
       end
     end
 
-    class IncomingIssue < Action
+    class IncomingIssue < Dynflow::Action
 
       def plan(issue)
         plan_self(issue)
@@ -63,7 +63,7 @@ module Dynflow
 
     end
 
-    class Triage < Action
+    class Triage < Dynflow::Action
 
       def plan(issue)
         triage = plan_self(issue)
@@ -100,7 +100,7 @@ module Dynflow
 
     end
 
-    class UpdateIssue < Action
+    class UpdateIssue < Dynflow::Action
 
       input_format do
         param :author, String
@@ -113,7 +113,7 @@ module Dynflow
       end
     end
 
-    class NotifyAssignee < Action
+    class NotifyAssignee < Dynflow::Action
 
       def self.subscribe
         Triage
@@ -135,7 +135,7 @@ module Dynflow
       end
     end
 
-    class Commit < Action
+    class Commit < Dynflow::Action
       input_format do
         param :sha, String
       end
@@ -157,7 +157,7 @@ module Dynflow
       end
     end
 
-    class FastCommit < Action
+    class FastCommit < Dynflow::Action
 
       def plan(commit)
         sequence do
@@ -179,7 +179,7 @@ module Dynflow
 
     end
 
-    class Ci < Action
+    class Ci < Dynflow::Action
 
       input_format do
         param :commit, Commit.input_format
@@ -194,7 +194,7 @@ module Dynflow
       end
     end
 
-    class Review < Action
+    class Review < Dynflow::Action
 
       input_format do
         param :reviewer, String
@@ -214,7 +214,7 @@ module Dynflow
       end
     end
 
-    class Merge < Action
+    class Merge < Dynflow::Action
 
       input_format do
         param :commit, Commit.input_format
@@ -227,22 +227,22 @@ module Dynflow
       end
     end
 
-    class Dummy < Action
+    class Dummy < Dynflow::Action
     end
 
-    class DummyWithFinalize < Action
+    class DummyWithFinalize < Dynflow::Action
       def finalize
         TestExecutionLog.finalize << self
       end
     end
 
-    class DummyTrigger < Action
+    class DummyTrigger < Dynflow::Action
     end
 
-    class DummyAnotherTrigger < Action
+    class DummyAnotherTrigger < Dynflow::Action
     end
 
-    class DummySubscribe < Action
+    class DummySubscribe < Dynflow::Action
 
       def self.subscribe
         DummyTrigger
@@ -253,7 +253,7 @@ module Dynflow
 
     end
 
-    class DummyMultiSubscribe < Action
+    class DummyMultiSubscribe < Dynflow::Action
 
       def self.subscribe
         [DummyTrigger, DummyAnotherTrigger]
@@ -264,7 +264,7 @@ module Dynflow
 
     end
 
-    class CancelableSuspended < Action
+    class CancelableSuspended < Dynflow::Action
       include Dynflow::Action::CancellablePolling
 
       Cancel = Dynflow::Action::CancellablePolling::Cancel
@@ -274,15 +274,24 @@ module Dynflow
       end
 
       def poll_external_task
-        progress = external_task[:progress] + 10
-        if progress > 25 && input[:text] =~ /cancel/
-          world.event execution_plan_id, run_step_id, Cancel
-        end
-        { progress: progress }
+        progress     = external_task[:progress]
+        new_progress = if progress == 30
+                         if input[:text] =~ /cancel-external/
+                           progress
+                         elsif input[:text] =~ /cancel-self/
+                           world.event execution_plan_id, run_step_id, Cancel
+                           progress
+                         else
+                           progress + 10
+                         end
+                       else
+                         progress + 10
+                       end
+        { progress: new_progress }
       end
 
       def cancel_external_task
-        if input[:text] !~ /cancel fail/
+        if input[:text] !~ /cancel-fail/
           { cancelled: true }
         else
           error! 'action cancelled'
@@ -302,7 +311,7 @@ module Dynflow
       end
 
       def poll_interval
-        0.1
+        0.01
       end
 
       def run_progress
@@ -310,8 +319,8 @@ module Dynflow
       end
     end
 
-    class DummySuspended < Action
-      include Action::Polling
+    class DummySuspended < Dynflow::Action
+      include Dynflow::Action::Polling
 
       def invoke_external_task
         error! 'Trolling detected' if input[:text] == 'troll setup'
@@ -353,7 +362,7 @@ module Dynflow
       end
     end
 
-    class DummyHeavyProgress < Action
+    class DummyHeavyProgress < Dynflow::Action
 
       def plan(input)
         sequence do