dynflow 0.8.3 → 0.8.4

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.8.3'
+  VERSION = '0.8.4'
 end

data/lib/dynflow/web/console_helpers.rb

@@ -133,7 +133,7 @@ module Dynflow
       end
 
       def updated_url(new_params)
-        url(request.path_info + "?" + Rack::Utils.build_nested_query(params.merge(new_params.stringify_keys)))
+        url(request.path_info + "?" + Rack::Utils.build_nested_query(params.merge(Utils.stringify_keys(new_params))))
       end
 
       def paginated_url(delta)

data/lib/dynflow/web/filtering_helpers.rb

@@ -20,16 +20,16 @@ module Dynflow
           filters = params[:filters]
         elsif supported_filter?('state')
           excluded_states = show_all ? [] : ['stopped']
-          filters = { 'state' => ExecutionPlan.states.map(&:to_s) - excluded_states }          
+          filters = { 'state' => ExecutionPlan.states.map(&:to_s) - excluded_states }
         else
           filters = {}
         end
-        @filtering_options = { filters: filters }.with_indifferent_access
+        @filtering_options = Utils.indifferent_hash(filters: filters)
         return @filtering_options
       end
 
       def find_execution_plans_options(show_all = false)
-        options = HashWithIndifferentAccess.new
+        options = Utils.indifferent_hash({})
         options.merge!(filtering_options(show_all))
         options.merge!(pagination_options)
         options.merge!(ordering_options)

data/lib/dynflow/world.rb

@@ -7,7 +7,7 @@ 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, :scheduler, :auto_validity_check, :validity_check_timeout
+        :middleware, :auto_rescue, :clock, :meta, :delayed_executor, :auto_validity_check, :validity_check_timeout
 
     def initialize(config)
       @id                     = SecureRandom.uuid
@@ -35,9 +35,9 @@ module Dynflow
         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
+      @delayed_executor         = try_spawn_delayed_executor(config_for_world)
+      @meta                     = config_for_world.meta
+      @meta['delayed_executor'] = true if @delayed_executor
       coordinator.register_world(registered_world)
       @termination_barrier = Mutex.new
       @before_termination_hooks = Queue.new
@@ -49,7 +49,7 @@ module Dynflow
         end
       end
       self.auto_execute if config_for_world.auto_execute
-      @scheduler.start if @scheduler
+      @delayed_executor.start if @delayed_executor
     end
 
     def before_termination(&block)
@@ -81,7 +81,7 @@ module Dynflow
       # TODO what happens with newly loaded classes
       @action_classes = @action_classes.map do |klass|
         begin
-          klass.to_s.constantize
+          Utils.constantize(klass.to_s)
         rescue NameError
           nil # ignore missing classes
         end
@@ -146,10 +146,10 @@ module Dynflow
       end
     end
 
-    def schedule(action_class, schedule_options, *args)
+    def delay(action_class, delay_options, *args)
       raise 'No action_class given' if action_class.nil?
       execution_plan = ExecutionPlan.new self
-      execution_plan.schedule(action_class, schedule_options, *args)
+      execution_plan.delay(action_class, delay_options, *args)
       Scheduled[execution_plan.id]
     end
 
@@ -199,9 +199,9 @@ module Dynflow
           begin
             run_before_termination_hooks
 
-            if scheduler
-              logger.info "start terminating scheduler..."
-              scheduler.terminate.wait
+            if delayed_executor
+              logger.info "start terminating delayed_executor..."
+              delayed_executor.terminate.wait
             end
 
             if executor
@@ -337,10 +337,10 @@ 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
+    def try_spawn_delayed_executor(config_for_world)
+      return nil if !executor || config_for_world.delayed_executor.nil?
+      coordinator.acquire(Coordinator::DelayedExecutorLock.new(self))
+      config_for_world.delayed_executor
     rescue Coordinator::LockError => e
       nil
     end
@@ -352,7 +352,7 @@ module Dynflow
           action_classes.each_with_object(Hash.new { |h, k| h[k] = [] }) do |klass, index|
             next unless klass.subscribe
             Array(klass.subscribe).each do |subscribed_class|
-              index[subscribed_class.to_s.constantize] << klass
+              index[Utils.constantize(subscribed_class.to_s)] << klass
             end
           end.tap { |o| o.freeze }
     end

data/test/action_test.rb

@@ -392,14 +392,16 @@ module Dynflow
       specify "it saves the information about number for sub plans in the output" do
         execution_plan.entry_action.output.must_equal('total_count'   => 2,
                                                       'failed_count'  => 0,
-                                                      'success_count' => 2)
+                                                      'success_count' => 2,
+                                                      'pending_count' => 0)
       end
 
       specify "when a sub plan fails, the caller action fails as well" do
         FailureSimulator.fail_in_child_run = true
         execution_plan.entry_action.output.must_equal('total_count'   => 2,
                                                       'failed_count'  => 2,
-                                                      'success_count' => 0)
+                                                      'success_count' => 0,
+                                                      'pending_count' => 0)
         execution_plan.state.must_equal :paused
         execution_plan.result.must_equal :error
       end

data/test/future_execution_test.rb

@@ -11,19 +11,19 @@ module Dynflow
 
         before do
           @start_at = Time.now.utc + 180
-          world.persistence.delete_scheduled_plans(:execution_plan_uuid => [])
+          world.persistence.delete_delayed_plans(:execution_plan_uuid => [])
         end
 
         let(:world) { WorldFactory.create_world }
-        let(:scheduled_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)
+        let(:delayed_plan) do
+          delayed_plan = world.delay(::Support::DummyExample::Dummy, { :start_at => @start_at })
+          delayed_plan.must_be :scheduled?
+          world.persistence.load_delayed_plan(delayed_plan.execution_plan_id)
         end
         let(:history_names) do
           ->(execution_plan) { execution_plan.execution_history.map(&:name) }
         end
-        let(:execution_plan) { scheduled_plan.execution_plan }
+        let(:execution_plan) { delayed_plan.execution_plan }
 
         it 'returns the progress as 0' do
           execution_plan.progress.must_equal 0
@@ -31,45 +31,45 @@ module Dynflow
 
         it 'marks the plan as failed when issues in serialied phase' do
           world.persistence.delete_execution_plans({})
-          e = proc { world.schedule(::Support::DummyExample::DummyCustomScheduleSerializer, { :start_at => @start_at }, :fail) }.must_raise RuntimeError
+          e = proc { world.delay(::Support::DummyExample::DummyCustomDelaySerializer, { :start_at => @start_at }, :fail) }.must_raise RuntimeError
           e.message.must_equal 'Enforced serializer failure'
           plan = world.persistence.find_execution_plans(page: 0, per_page: 1, order_by: :ended_at, desc: true).first
           plan.state.must_equal :stopped
           plan.result.must_equal :error
         end
 
-        it 'schedules the action' do
+        it 'delays the action' do
           execution_plan.steps.count.must_equal 1
-          scheduled_plan.start_at.inspect.must_equal (@start_at).inspect
-          history_names.call(execution_plan).must_equal ['schedule']
+          delayed_plan.start_at.inspect.must_equal (@start_at).inspect
+          history_names.call(execution_plan).must_equal ['delay']
         end
 
-        it 'allows cancelling the scheduled plan' do
+        it 'allows cancelling the delayed plan' do
           execution_plan.state.must_equal :scheduled
           execution_plan.cancellable?.must_equal true
           execution_plan.cancel.each(&:wait)
           execution_plan = world.persistence.load_execution_plan(self.execution_plan.id)
           execution_plan.state.must_equal :stopped
           execution_plan.result.must_equal :error
-          execution_plan.schedule_record.must_equal nil
+          execution_plan.delay_record.must_equal nil
         end
 
-        it 'finds scheduled plans' do
+        it 'finds delayed plans' do
           @start_at = Time.now.utc - 100
-          scheduled_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
+          delayed_plan
+          past_delayed_plans = world.persistence.find_past_delayed_plans(@start_at + 10)
+          past_delayed_plans.length.must_equal 1
+          past_delayed_plans.first.execution_plan_uuid.must_equal execution_plan.id
         end
 
-        it 'scheduled plans can be planned and executed' do
+        it 'delayed plans can be planned and executed' do
           execution_plan.state.must_equal :scheduled
-          scheduled_plan.plan
+          delayed_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 = scheduled_plan.execute
+          history_names.call(execution_plan).must_equal ['delay']
+          executed = delayed_plan.execute
           executed.wait
           executed.value.state.must_equal :stopped
           executed.value.result.must_equal :success
@@ -77,36 +77,36 @@ module Dynflow
         end
 
         it 'expired plans can be failed' do
-          scheduled_plan.timeout
+          delayed_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)
+          history_names.call(execution_plan).must_equal %W(delay timeout)
         end
 
       end
 
-      describe 'polling scheduler' do
+      describe 'polling delayed executor' 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(:delayed_executor) { DelayedExecutors::Polling.new(dummy_world, options) }
         let(:klok) { dummy_world.clock }
 
-        it 'checks for scheduled plans in regular intervals' do
+        it 'checks for delayed 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]])
+          persistence.expect(:find_past_delayed_plans, [], [start_time])
+          persistence.expect(:find_past_delayed_plans, [], [start_time + options[:poll_interval]])
           dummy_world.stub :persistence, persistence do
             klok.pending_pings.length.must_equal 0
-            scheduler.start.wait
+            delayed_executor.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.who.ref.must_be_same_as delayed_executor.core
             klok.pending_pings.first.when.must_equal start_time + options[:poll_interval]
             klok.progress
-            scheduler.terminate.wait
+            delayed_executor.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.who.ref.must_be_same_as delayed_executor.core
             klok.pending_pings.first.when.must_equal start_time + 2 * options[:poll_interval]
             klok.progress
             klok.pending_pings.length.must_equal 0

data/test/middleware_test.rb

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

data/test/persistence_test.rb

@@ -148,7 +148,7 @@ module Dynflow
             prepare_action('plan1')
             loaded_action = adapter.load_action('plan1', action_id)
             loaded_action[:id].must_equal action_id
-            loaded_action.must_equal(action_data.stringify_keys)
+            loaded_action.must_equal(Utils.stringify_keys(action_data))
 
             adapter.save_action('plan1', action_id, nil)
             -> { adapter.load_action('plan1', action_id) }.must_raise KeyError
@@ -164,7 +164,7 @@ module Dynflow
             prepare_step('plan1')
             loaded_step = adapter.load_step('plan1', step_id)
             loaded_step[:id].must_equal step_id
-            loaded_step.must_equal(step_data.stringify_keys)
+            loaded_step.must_equal(Utils.stringify_keys(step_data))
           end
         end
       end
@@ -189,7 +189,7 @@ module Dynflow
         it "supports connector's needs for exchaning envelopes" do
           client_world_id   = '5678'
           executor_world_id = '1234'
-          envelope_hash = ->(envelope) { Dynflow.serializer.dump(envelope).with_indifferent_access }
+          envelope_hash = ->(envelope) { Dynflow::Utils.indifferent_hash(Dynflow.serializer.dump(envelope)) }
           executor_envelope = envelope_hash.call(Dispatcher::Envelope[123, client_world_id, executor_world_id, Dispatcher::Execution['111']])
           client_envelope   = envelope_hash.call(Dispatcher::Envelope[123, executor_world_id, client_world_id, Dispatcher::Accepted])
           envelopes         = [client_envelope, executor_envelope]

data/test/support/dummy_example.rb

@@ -19,8 +19,8 @@ module Support
       end
     end
 
-    class DummyCustomScheduleSerializer < Dynflow::Action
-      def schedule(schedule_options, *args)
+    class DummyCustomDelaySerializer < Dynflow::Action
+      def delay(delay_options, *args)
         MySerializer.new(args)
       end
       def run; end

data/test/support/middleware_example.rb

@@ -14,10 +14,10 @@ module Support
         LogMiddleware.log << "#{self.class.name[/\w+$/]}::#{message}"
       end
 
-      def schedule(*args)
-        log 'before_schedule'
+      def delay(*args)
+        log 'before_delay'
         pass *args
-        log 'after_schedule'
+        log 'after_delay'
       end
 
       def plan(args)
@@ -78,8 +78,8 @@ module Support
         LogMiddleware.log << message
       end
 
-      def schedule(schedule_options, *args)
-        log 'schedule'
+      def delay(delay_options, *args)
+        log 'delay'
         Dynflow::Serializers::Noop.new(args)
       end
 

data/test/test_helper.rb

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

data/test/testing_test.rb

@@ -118,7 +118,7 @@ module Dynflow
         let(:runned_action) { run_action planned_action }
 
         it 'plans' do
-          planned_action.input.must_equal input.stringify_keys
+          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
 

data/web/views/show.erb

@@ -14,14 +14,14 @@
   <%= h(@plan.result) %>
 </p>
 
-<% if @plan.state == :scheduled && @plan.schedule_record %>
+<% if @plan.state == :scheduled && @plan.delay_record %>
   <p>
     <b>Start at:</b>
-    <%= h(@plan.schedule_record.start_at) %>
+    <%= h(@plan.delay_record.start_at) %>
   </p>
   <p>
     <b>Start before:</b>
-    <%= h(@plan.schedule_record.start_before || "-") %>
+    <%= h(@plan.delay_record.start_before || "-") %>
   </p>
 <% end %>
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.4
 platform: ruby
 authors:
 - Ivan Necas
@@ -9,22 +9,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-13 00:00:00.000000000 Z
+date: 2015-08-14 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  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: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -369,6 +355,11 @@ files:
 - lib/dynflow/coordinator_adapters.rb
 - lib/dynflow/coordinator_adapters/abstract.rb
 - lib/dynflow/coordinator_adapters/sequel.rb
+- lib/dynflow/delayed_executors.rb
+- lib/dynflow/delayed_executors/abstract.rb
+- lib/dynflow/delayed_executors/abstract_core.rb
+- lib/dynflow/delayed_executors/polling.rb
+- lib/dynflow/delayed_plan.rb
 - lib/dynflow/dispatcher.rb
 - lib/dynflow/dispatcher/abstract.rb
 - lib/dynflow/dispatcher/client_dispatcher.rb
@@ -426,12 +417,8 @@ files:
 - lib/dynflow/persistence_adapters/sequel_migrations/005_envelopes.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/006_fix_data_length.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/007_future_execution.rb
+- lib/dynflow/persistence_adapters/sequel_migrations/008_rename_scheduled_plans_to_delayed_plans.rb
 - lib/dynflow/round_robin.rb
-- lib/dynflow/scheduled_plan.rb
-- lib/dynflow/schedulers.rb
-- lib/dynflow/schedulers/abstract.rb
-- lib/dynflow/schedulers/abstract_core.rb
-- lib/dynflow/schedulers/polling.rb
 - lib/dynflow/serializable.rb
 - lib/dynflow/serializer.rb
 - lib/dynflow/serializers.rb
@@ -452,6 +439,7 @@ files:
 - lib/dynflow/transaction_adapters/abstract.rb
 - lib/dynflow/transaction_adapters/active_record.rb
 - lib/dynflow/transaction_adapters/none.rb
+- lib/dynflow/utils.rb
 - lib/dynflow/version.rb
 - lib/dynflow/web.rb
 - lib/dynflow/web/console.rb