dynflow 0.8.1 → 0.8.2

data/lib/dynflow/world.rb

@@ -7,31 +7,37 @@ module Dynflow
     attr_reader :id, :client_dispatcher, :executor_dispatcher, :executor, :connector,
         :transaction_adapter, :logger_adapter, :coordinator,
         :persistence, :action_classes, :subscription_index,
-        :middleware, :auto_rescue, :clock, :meta
+        :middleware, :auto_rescue, :clock, :meta, :scheduler, :auto_validity_check, :validity_check_timeout
 
     def initialize(config)
-      @id                   = SecureRandom.uuid
-      @clock                = spawn_and_wait(Clock, 'clock')
-      config_for_world      = Config::ForWorld.new(config, self)
+      @id                     = SecureRandom.uuid
+      @clock                  = spawn_and_wait(Clock, 'clock')
+      config_for_world        = Config::ForWorld.new(config, self)
       config_for_world.validate
-      @logger_adapter       = config_for_world.logger_adapter
-      @transaction_adapter  = config_for_world.transaction_adapter
-      @persistence          = Persistence.new(self, config_for_world.persistence_adapter)
-      @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    = config_for_world.exit_on_terminate
-      @connector            = config_for_world.connector
-      @middleware           = Middleware::World.new
-      @client_dispatcher    = spawn_and_wait(Dispatcher::ClientDispatcher, "client-dispatcher", self)
-      @meta                 = config_for_world.meta
+      @logger_adapter         = config_for_world.logger_adapter
+      @transaction_adapter    = config_for_world.transaction_adapter
+      @persistence            = Persistence.new(self, config_for_world.persistence_adapter)
+      @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      = config_for_world.exit_on_terminate
+      @connector              = config_for_world.connector
+      @middleware             = Middleware::World.new
+      @client_dispatcher      = spawn_and_wait(Dispatcher::ClientDispatcher, "client-dispatcher", self)
+      @meta                   = config_for_world.meta
+      @auto_validity_check    = config_for_world.auto_validity_check
+      @validity_check_timeout = config_for_world.validity_check_timeout
       calculate_subscription_index
 
       if executor
         @executor_dispatcher = spawn_and_wait(Dispatcher::ExecutorDispatcher, "executor-dispatcher", self)
         executor.initialized.wait
       end
+      self.worlds_validity_check if auto_validity_check
+      @scheduler            = try_spawn_scheduler(config_for_world)
+      @meta                 = config_for_world.meta
+      @meta['scheduler']    = true if @scheduler
       coordinator.register_world(registered_world)
       @termination_barrier = Mutex.new
       @before_termination_hooks = Queue.new
@@ -43,6 +49,7 @@ module Dynflow
         end
       end
       self.auto_execute if config_for_world.auto_execute
+      @scheduler.start if @scheduler
     end
 
     def before_termination(&block)
@@ -90,16 +97,22 @@ module Dynflow
       # ExecutionPlan is executed.
       Triggered       = type { fields! execution_plan_id: String, future: Concurrent::Edge::Future }
 
-      variants PlaningFailed, Triggered
+      Scheduled       = type { fields! execution_plan_id: String }
+
+      variants PlaningFailed, Triggered, Scheduled
     end
 
     module TriggerResult
       def planned?
-        match self, PlaningFailed => false, Triggered => true
+        match self, PlaningFailed => false, Triggered => true, Scheduled => false
       end
 
       def triggered?
-        match self, PlaningFailed => false, Triggered => true
+        match self, PlaningFailed => false, Triggered => true, Scheduled => false
+      end
+
+      def scheduled?
+        match self, PlaningFailed => false, Triggered => false, Scheduled => true
       end
 
       def id
@@ -133,6 +146,20 @@ module Dynflow
       end
     end
 
+    def schedule(action_class, schedule_options, *args)
+      raise 'No action_class given' if action_class.nil?
+      execution_plan = ExecutionPlan.new self
+      execution_plan.schedule(action_class, {}, schedule_options, *args)
+      scheduled_plan = ScheduledPlan.new(self,
+                                         execution_plan.id,
+                                         schedule_options[:start_at],
+                                         schedule_options.fetch(:start_before, nil),
+                                         args,
+                                         execution_plan.entry_action.serializer)
+      persistence.save_scheduled_plan(scheduled_plan)
+      Scheduled[execution_plan.id]
+    end
+
     def plan(action_class, *args)
       ExecutionPlan.new(self).tap do |execution_plan|
         execution_plan.prepare(action_class)
@@ -179,6 +206,10 @@ module Dynflow
           begin
             run_before_termination_hooks
 
+            if scheduler
+              logger.info "start terminating scheduler..."
+              scheduler.terminate.wait
+            end
 
             if executor
               connector.stop_receiving_new_work(self)
@@ -229,13 +260,15 @@ module Dynflow
     def invalidate(world)
       Type! world, Coordinator::ClientWorld, Coordinator::ExecutorWorld
       coordinator.acquire(Coordinator::WorldInvalidationLock.new(self, world)) do
-        old_execution_locks = coordinator.find_locks(class: Coordinator::ExecutionLock.name,
-                                                     owner_id: "world:#{world.id}")
+        if world.is_a? Coordinator::ExecutorWorld
+          old_execution_locks = coordinator.find_locks(class: Coordinator::ExecutionLock.name,
+                                                       owner_id: "world:#{world.id}")
 
-        coordinator.deactivate_world(world)
+          coordinator.deactivate_world(world)
 
-        old_execution_locks.each do |execution_lock|
-          invalidate_execution_lock(execution_lock)
+          old_execution_locks.each do |execution_lock|
+            invalidate_execution_lock(execution_lock)
+          end
         end
 
         coordinator.delete_world(world)
@@ -267,6 +300,40 @@ module Dynflow
       logger.error "failed to write data while invalidating execution lock #{execution_lock}"
     end
 
+    def worlds_validity_check(auto_invalidate = true, worlds_filter = {})
+      worlds = coordinator.find_worlds(false, worlds_filter)
+
+      world_checks = worlds.reduce({}) do |hash, world|
+        hash.update(world => ping(world.id, self.validity_check_timeout))
+      end
+      world_checks.values.each(&:wait)
+
+      results = {}
+      world_checks.each do |world, check|
+        if check.success?
+          result = :valid
+        else
+          if auto_invalidate
+            begin
+              invalidate(world)
+              result = :invalidated
+            rescue => e
+              result = e.message
+            end
+          else
+            result = :invalid
+          end
+        end
+        results[world.id] = result
+      end
+
+      unless results.values.all? { |result| result == :valid }
+        logger.error "invalid worlds found #{results.inspect}"
+      end
+
+      return results
+    end
+
     # executes plans that are planned/paused and haven't reported any error yet (usually when no executor
     # was available by the time of planning or terminating)
     def auto_execute
@@ -277,6 +344,14 @@ module Dynflow
       end
     end
 
+    def try_spawn_scheduler(config_for_world)
+      return nil if !executor || config_for_world.scheduler.nil?
+      coordinator.acquire(Coordinator::SchedulerLock.new(self))
+      config_for_world.scheduler
+    rescue Coordinator::LockError => e
+      nil
+    end
+
     private
 
     def calculate_subscription_index

data/test/abnormal_states_recovery_test.rb

@@ -146,6 +146,70 @@ module Dynflow
           plan.execution_history.map { |h| [h.name, h.world_id] }.must_equal(expected_history)
         end
       end
+
+      describe '#worlds_validity_check' do
+        describe 'the auto_validity_check is enabled' do
+          let :invalid_world do
+            Coordinator::ClientWorld.new(OpenStruct.new(id: '123', meta: {}))
+          end
+
+          let :invalid_world_2 do
+            Coordinator::ClientWorld.new(OpenStruct.new(id: '456', meta: {}))
+          end
+
+          let :client_world do
+            create_world(false)
+          end
+
+          let :world_with_auto_validity_check do
+            create_world do |config|
+              config.auto_validity_check = true
+              config.validity_check_timeout = 0.2
+            end
+          end
+
+          it 'performs the validity check on world creation if auto_validity_check enabled' do
+            client_world.coordinator.register_world(invalid_world)
+            client_world.coordinator.find_worlds(false, id: invalid_world.id).wont_be_empty
+            world_with_auto_validity_check
+            client_world.coordinator.find_worlds(false, id: invalid_world.id).must_be_empty
+          end
+
+          it 'by default, the auto_validity_check is enabled only for executor words' do
+            create_world(false).auto_validity_check.must_equal false
+            create_world(true).auto_validity_check.must_equal true
+          end
+
+          it 'reports the validation status' do
+            client_world.coordinator.register_world(invalid_world)
+            results = client_world.worlds_validity_check
+            client_world.coordinator.find_worlds(false, id: invalid_world.id).must_be_empty
+
+            results[invalid_world.id].must_equal :invalidated
+
+            results[client_world.id].must_equal :valid
+          end
+
+          it 'allows checking only, without actual invalidation' do
+            client_world.coordinator.register_world(invalid_world)
+            results = client_world.worlds_validity_check(false)
+            client_world.coordinator.find_worlds(false, id: invalid_world.id).wont_be_empty
+
+            results[invalid_world.id].must_equal :invalid
+          end
+
+          it 'allows to filter the worlds to run the check on' do
+            client_world.coordinator.register_world(invalid_world)
+            client_world.coordinator.register_world(invalid_world_2)
+            client_world.coordinator.find_worlds(false, id: [invalid_world.id, invalid_world_2.id]).size.must_equal 2
+
+            results = client_world.worlds_validity_check(true, :id => invalid_world.id)
+            results.must_equal(invalid_world.id =>  :invalidated)
+            client_world.coordinator.find_worlds(false, id: [invalid_world.id, invalid_world_2.id]).size.must_equal 1
+          end
+        end
+      end
+
     end
   end
 end

data/test/future_execution_test.rb

@@ -0,0 +1,114 @@
+require_relative 'test_helper'
+
+module Dynflow
+  module FutureExecutionTest
+    describe 'Future Execution' do
+      include PlanAssertions
+      include Dynflow::Testing::Assertions
+      include Dynflow::Testing::Factories
+
+      describe 'action scheduling' do
+
+        before do
+          world.persistence.delete_scheduled_plans(:execution_plan_uuid => [])
+        end
+
+        let(:world) { WorldFactory.create_world }
+        let(:plan) do
+          scheduled = world.schedule(::Support::DummyExample::Dummy, { :start_at => @start_at })
+          scheduled.must_be :scheduled?
+          world.persistence.load_scheduled_plan(scheduled.execution_plan_id)
+        end
+        let(:history_names) do
+          ->(execution_plan) { execution_plan.execution_history.map(&:name) }
+        end
+        let(:execution_plan) { plan.execution_plan }
+
+        it 'schedules the action' do
+          @start_at = Time.now.utc + 180
+          execution_plan.steps.count.must_equal 1
+          plan.start_at.inspect.must_equal (@start_at).inspect
+          history_names.call(execution_plan).must_equal ['schedule']
+        end
+
+        it 'finds scheduled plans' do
+          @start_at = Time.now.utc - 100
+          plan
+          past_scheduled_plans = world.persistence.find_past_scheduled_plans(@start_at + 10)
+          past_scheduled_plans.length.must_equal 1
+          past_scheduled_plans.first.execution_plan_uuid.must_equal execution_plan.id
+        end
+
+        it 'scheduled plans can be planned and executed' do
+          @start_at = Time.now.utc + 180
+          execution_plan.state.must_equal :scheduled
+          plan.plan
+          execution_plan.state.must_equal :planned
+          execution_plan.result.must_equal :pending
+          assert_planning_success execution_plan
+          history_names.call(execution_plan).must_equal ['schedule']
+          executed = plan.execute
+          executed.wait
+          executed.value.state.must_equal :stopped
+          executed.value.result.must_equal :success
+          executed.value.execution_history.count.must_equal 3
+        end
+
+        it 'expired plans can be failed' do
+          @start_at = Time.now.utc + 180
+          plan.timeout
+          execution_plan.state.must_equal :stopped
+          execution_plan.result.must_equal :error
+          execution_plan.errors.first.message.must_match /could not be started before set time/
+          history_names.call(execution_plan).must_equal %W(schedule timeout)
+        end
+
+      end
+
+      describe 'polling scheduler' do
+        let(:dummy_world) { Dynflow::Testing::DummyWorld.new }
+        let(:persistence) { MiniTest::Mock.new }
+        let(:options) { { :poll_interval => 15, :time_source => -> { dummy_world.clock.current_time } } }
+        let(:scheduler) { Schedulers::Polling.new(dummy_world, options) }
+        let(:klok) { dummy_world.clock }
+
+        it 'checks for scheduled plans in regular intervals' do
+          start_time = klok.current_time
+          persistence.expect(:find_past_scheduled_plans, [], [start_time])
+          persistence.expect(:find_past_scheduled_plans, [], [start_time + options[:poll_interval]])
+          dummy_world.stub :persistence, persistence do
+            klok.pending_pings.length.must_equal 0
+            scheduler.start.wait
+            klok.pending_pings.length.must_equal 1
+            klok.pending_pings.first.who.ref.must_be_same_as scheduler.core
+            klok.pending_pings.first.when.must_equal start_time + options[:poll_interval]
+            klok.progress
+            scheduler.terminate.wait
+            klok.pending_pings.length.must_equal 1
+            klok.pending_pings.first.who.ref.must_be_same_as scheduler.core
+            klok.pending_pings.first.when.must_equal start_time + 2 * options[:poll_interval]
+            klok.progress
+            klok.pending_pings.length.must_equal 0
+          end
+        end
+      end
+
+      describe 'serializers' do
+        let(:save_and_load) do
+          ->(thing) { MultiJson.load(MultiJson.dump(thing)) }
+        end
+        let(:simulated_use) do
+          lambda do |serializer_class, input|
+            serializer = serializer_class.new
+            serializer.deserialize(save_and_load.call(serializer.serialize *input))
+          end
+        end
+
+        it 'noop serializer [de]serializes correctly for simple types' do
+          input = [1, 2.0, 'three', ['four-1', 'four-2'], { 'five' => 5 }]
+          simulated_use.call(Dynflow::Serializers::Noop, input).must_equal input
+        end
+      end
+    end
+  end
+end

data/test/middleware_test.rb

@@ -12,8 +12,14 @@ module Dynflow
       end
 
       it "wraps the action method calls" do
-        world.trigger(Support::MiddlewareExample::LoggingAction, {}).finished.wait
-        log.must_equal %w[LogMiddleware::before_plan_phase
+        schedule = world.schedule(Support::MiddlewareExample::LoggingAction, { :start_at => Time.now.utc - 60 }, {})
+        plan = world.persistence.load_scheduled_plan schedule.execution_plan_id
+        plan.plan
+        plan.execute.wait
+        log.must_equal %w[LogMiddleware::before_schedule
+                          schedule
+                          LogMiddleware::after_schedule
+                          LogMiddleware::before_plan_phase
                           LogMiddleware::before_plan
                           plan
                           LogMiddleware::after_plan

data/test/support/middleware_example.rb

@@ -14,6 +14,12 @@ module Support
         LogMiddleware.log << "#{self.class.name[/\w+$/]}::#{message}"
       end
 
+      def schedule(*args)
+        log 'before_schedule'
+        pass *args
+        log 'after_schedule'
+      end
+
       def plan(args)
         log 'before_plan'
         pass(args)
@@ -72,6 +78,11 @@ module Support
         LogMiddleware.log << message
       end
 
+      def schedule(schedule_options, *args)
+        log 'schedule'
+        Dynflow::Serializers::Noop.new
+      end
+
       def plan(input)
         log 'plan'
         plan_self(input)

data/test/test_helper.rb

@@ -88,6 +88,7 @@ module WorldFactory
     config.persistence_adapter = persistence_adapter
     config.logger_adapter      = logger_adapter
     config.coordinator_adapter = coordinator_adapter
+    config.scheduler           = nil
     config.auto_rescue         = false
     config.exit_on_terminate   = false
     config.auto_execute        = false

data/web/views/show.erb

@@ -11,6 +11,17 @@
   <%= h(@plan.result) %>
 </p>
 
+<% if @plan.state == :scheduled %>
+  <p>
+    <b>Start at:</b>
+    <%= h(@plan.schedule_record.start_at) %>
+  </p>
+  <p>
+    <b>Start before:</b>
+    <%= h(@plan.schedule_record.start_before || "-") %>
+  </p>
+<% end %>
+
 <p>
   <b>Started at:</b>
   <%= h(@plan.started_at) %>