dynflow 0.8.30 → 0.8.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d71060f0924aa889e0426c476d6b7cf9366475d3
-  data.tar.gz: 6008428d10eff1655d8554526e139a46ec2b68c4
+  metadata.gz: e4b6b017069b69e85804fc7f3b3256522835a536
+  data.tar.gz: c63330ee0e91061d41ba967f923e8eff2d094288
 SHA512:
-  metadata.gz: bd3c82ba611cb82460817d6c5e3ac985a859b4dfb6499ab11508209e1d87605f4dee57340ac67825fb4ca78c7f49d00b66b71f2d7137d83292595fc4110f42ac
-  data.tar.gz: 5fda41ada7581f1601f407cfe093ed6f3e4d902923fdf27dbe6dbcc73a69f18ffcfd5db4afd105d88537e90e7ee38bd546eaed8caa40609b3ce184bb067ab590
+  metadata.gz: f7cc6ca73e1f6157745476f3d2877fa80a0cfccd46b2597eff68ec2eb5933dbfebcf051684ffdc77dc6f09aeb30a82846913ebdb3bdec9b1853b23df0760cdff
+  data.tar.gz: 818a9763732ec3ca9baedb652610c1111054756cd32f1f2eae22a9a0ce6946651c364964a8632dd19e5c50d6265466013002ea34b704b7f17a48c40330bab4a2

data/examples/singletons.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+example_description = <<DESC
+
+  Sub Plans Example
+  ===================
+
+  This example shows, how singleton actions can be used for making sure
+  there is only one instance of the action running at a time.
+
+  Singleton actions try to obtain a lock at the beggining of their plan
+  phase and fail if they can't do so. In run phase they check if they
+  have the lock and try to acquire it again if they don't. These actions
+  release the lock at the end of their finalize phase.
+
+DESC
+
+require_relative 'example_helper'
+
+class SingletonExample < Dynflow::Action
+  include Dynflow::Action::Singleton
+
+  def run
+    sleep 10
+  end
+end
+
+class SingletonExampleA < SingletonExample; end
+class SingletonExampleB < SingletonExample; end
+
+if $0 == __FILE__
+  ExampleHelper.world.action_logger.level = Logger::INFO
+  ExampleHelper.world
+  t1 = ExampleHelper.world.trigger(SingletonExampleA)
+  t2 = ExampleHelper.world.trigger(SingletonExampleA)
+  ExampleHelper.world.trigger(SingletonExampleA) unless SingletonExampleA.singleton_locked?(ExampleHelper.world)
+  t3 = ExampleHelper.world.trigger(SingletonExampleB)
+  db = ExampleHelper.world.persistence.adapter.db
+
+  puts example_description
+  puts <<-MSG.gsub(/^.*\|/, '')
+    |  3 execution plans were triggered:
+    |  #{t1.id} should finish successfully
+    |  #{t3.id} should finish successfully because it is a singleton of different class
+    |  #{t2.id} should fail because #{t1.id} holds the lock
+    |
+    |  You can see the details at
+    |    http://localhost:4567/#{t1.id}
+    |    http://localhost:4567/#{t2.id}
+    |    http://localhost:4567/#{t3.id}
+    |
+  MSG
+  ExampleHelper.run_web_console
+end

data/lib/dynflow/action.rb

@@ -21,6 +21,7 @@ module Dynflow
 
     require 'dynflow/action/polling'
     require 'dynflow/action/cancellable'
+    require 'dynflow/action/singleton'
     require 'dynflow/action/with_sub_plans'
     require 'dynflow/action/with_bulk_sub_plans'
     require 'dynflow/action/with_polling_sub_plans'
@@ -302,6 +303,10 @@ module Dynflow
       @serializer
     end
 
+    def holds_singleton_lock?
+      false
+    end
+
     protected
 
     def state=(state)
@@ -549,6 +554,16 @@ module Dynflow
     def root_action?
       @triggering_action.nil?
     end
+
+    # An action must be a singleton and have a singleton lock
+    def self.singleton_locked?(world)
+      if self.ancestors.include? ::Dynflow::Action::Singleton
+        lock_class = ::Dynflow::Coordinator::SingletonActionLock
+        world.coordinator.find_locks(lock_class.unique_filter(self.name)).any?
+      else
+        false
+      end
+    end
   end
   # rubocop:enable Metrics/ClassLength
 end

data/lib/dynflow/action/singleton.rb

@@ -0,0 +1,43 @@
+module Dynflow
+  class Action
+    module Singleton
+      def self.included(base)
+        base.middleware.use ::Dynflow::Middleware::Common::Singleton
+      end
+
+      def validate_singleton_lock!
+        singleton_lock! unless holds_singleton_lock?
+      end
+
+      def singleton_lock!
+        world.coordinator.acquire(singleton_lock)
+      rescue Dynflow::Coordinator::LockError
+        fail "Action #{self.class.name} is already active"
+      end
+
+      def singleton_unlock!
+        world.coordinator.release(singleton_lock) if holds_singleton_lock?
+      end
+
+      def holds_singleton_lock?
+        # Get locks for this action, there should be none or one
+        lock_filter = singleton_lock_class.unique_filter(self.class.name)
+        present_locks = world.coordinator.find_locks lock_filter
+        !present_locks.empty? && present_locks.first.owner_id == execution_plan_id
+      end
+
+      def singleton_lock_class
+        ::Dynflow::Coordinator::SingletonActionLock
+      end
+
+      def singleton_lock
+        singleton_lock_class.new(self.class.name, execution_plan_id)
+      end
+
+      def error!(*args)
+        singleton_unlock!
+        super
+      end
+    end
+  end
+end

data/lib/dynflow/coordinator.rb

@@ -220,6 +220,28 @@ module Dynflow
       end
     end
 
+    # Used when there should be only one execution plan for a given action class
+    class SingletonActionLock < Lock
+      def initialize(action_class, execution_plan_id)
+        super
+        @data[:owner_id] = "execution-plan:#{execution_plan_id}"
+        @data[:execution_plan_id] = execution_plan_id
+        @data[:id] = self.class.lock_id(action_class)
+      end
+
+      def owner_id
+        @data[:execution_plan_id]
+      end
+
+      def self.unique_filter(action_class)
+        { :class => self.name, :id => self.lock_id(action_class) }
+      end
+
+      def self.lock_id(action_class)
+        'singleton-action:' + action_class
+      end
+    end
+
     class ExecutionLock < LockByWorld
       def initialize(world, execution_plan_id, client_world_id, request_id)
         super(world)

data/lib/dynflow/dispatcher.rb

@@ -15,14 +15,20 @@ module Dynflow
         fields! receiver_id: String
       end
 
-      variants Event, Execution, Ping
+      Status = type do
+        fields! receiver_id: String,
+                execution_plan_id: type { variants String, NilClass }
+      end
+
+      variants Event, Execution, Ping, Status
     end
 
     Response = Algebrick.type do
       variants Accepted = atom,
                Failed   = type { fields! error: String },
                Done     = atom,
-               Pong     = atom
+               Pong     = atom,
+               ExecutionStatus = type { fields! execution_status: Hash }
     end
 
     Envelope = Algebrick.type do

data/lib/dynflow/dispatcher/client_dispatcher.rb

@@ -58,7 +58,7 @@ module Dynflow
                             (on ~Event do |event|
                                find_executor(event.execution_plan_id)
                              end),
-                            (on Ping.(~any) do |receiver_id|
+                            (on Ping.(~any) | Status.(~any, ~any) do |receiver_id, _|
                                receiver_id
                              end)
         envelope = Envelope[request_id, client_world_id, executor_id, request]
@@ -82,6 +82,9 @@ module Dynflow
                end),
               (on Done | Pong do
                  resolve_tracked_request(envelope.request_id)
+               end),
+              (on ExecutionStatus.(~any) do |steps|
+                 @tracked_requests.delete(envelope.request_id).success! steps
                end)
       end
 

data/lib/dynflow/dispatcher/executor_dispatcher.rb

@@ -9,7 +9,8 @@ module Dynflow
       def handle_request(envelope)
         match(envelope.message,
               on(Execution) { perform_execution(envelope, envelope.message) },
-              on(Event)     { perform_event(envelope, envelope.message) })
+              on(Event)     { perform_event(envelope, envelope.message) },
+              on(Status)    { get_execution_status(envelope, envelope.message) })
       end
 
       protected
@@ -63,6 +64,11 @@ module Dynflow
         end
       end
 
+      def get_execution_status(envelope, envelope_message)
+        items = @world.executor.execution_status envelope_message.execution_plan_id
+        respond(envelope, ExecutionStatus[execution_status: items])
+      end
+
       private
 
       def allocate_executor(execution_plan_id, client_world_id, request_id)

data/lib/dynflow/execution_plan.rb

@@ -117,6 +117,9 @@ module Dynflow
         @ended_at       = Time.now
         @real_time      = @ended_at - @started_at unless @started_at.nil?
         @execution_time = compute_execution_time
+        unlock_all_singleton_locks!
+      when :paused
+        unlock_all_singleton_locks!
       else
         # ignore
       end
@@ -254,6 +257,7 @@ module Dynflow
       if @run_flow.size == 1
         @run_flow = @run_flow.sub_flows.first
       end
+
       steps.values.each(&:save)
       update_state(error? ? :stopped : :planned)
     end
@@ -505,6 +509,14 @@ module Dynflow
       end
     end
 
+    def unlock_all_singleton_locks!
+      filter = { :owner_id => 'execution-plan:' + self.id,
+                 :class => Dynflow::Coordinator::SingletonActionLock.to_s }
+      world.coordinator.find_locks(filter).each do |lock|
+        world.coordinator.release(lock)
+      end
+    end
+
     private_class_method :steps_from_hash
   end
 end

data/lib/dynflow/executors/abstract.rb

@@ -27,6 +27,10 @@ module Dynflow
         raise NotImplementedError
       end
 
+      def execution_status(execution_plan_id = nil)
+        raise NotImplementedError
+      end
+
       # @return [Concurrent::Edge::Future]
       def initialized
         raise NotImplementedError

data/lib/dynflow/executors/parallel.rb

@@ -35,6 +35,10 @@ module Dynflow
         future
       end
 
+      def execution_status(execution_plan_id = nil)
+        @core.ask!([:execution_status, execution_plan_id])
+      end
+
       def initialized
         @core_initialized
       end

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

@@ -57,6 +57,10 @@ module Dynflow
           @world.dead_letter_handler
         end
 
+        def execution_status(execution_plan_id = nil)
+          @pool.ask!([:execution_status, execution_plan_id])
+        end
+
         private
 
         def on_message(message)

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

@@ -23,6 +23,17 @@ module Dynflow
             @jobs.empty?
           end
 
+          def execution_status(execution_plan_id = nil)
+            source = if execution_plan_id.nil?
+                       @jobs
+                     else
+                       { execution_plan_id => @jobs.fetch(execution_plan_id, []) }
+                     end
+            source.reduce({}) do |acc, (plan_id, work_items)|
+              acc.update(plan_id => work_items.count)
+            end
+          end
+
           private
 
           def tracked?(work)
@@ -62,6 +73,12 @@ module Dynflow
           try_to_terminate
         end
 
+        def execution_status(execution_plan_id = nil)
+          { :pool_size => @pool_size,
+            :free_workers => @free_workers.count,
+            :execution_status => @jobs.execution_status(execution_plan_id) }
+        end
+
         private
 
         def try_to_terminate

data/lib/dynflow/middleware.rb

@@ -5,6 +5,7 @@ module Dynflow
     require 'dynflow/middleware/resolver'
     require 'dynflow/middleware/stack'
     require 'dynflow/middleware/common/transaction'
+    require 'dynflow/middleware/common/singleton'
 
     include Algebrick::TypeCheck
 

data/lib/dynflow/middleware/common/singleton.rb

@@ -0,0 +1,19 @@
+module Dynflow
+  module Middleware::Common
+    class Singleton < Middleware
+      # Each action tries to acquire its own lock before the action's #plan starts
+      def plan(*args)
+        action.singleton_lock!
+        pass(*args)
+      end
+
+      # At the start of #run we try to acquire action's lock unless it already holds it
+      # At the end the action tries to unlock its own lock if the execution plan has no
+      #   finalize phase
+      def run(*args)
+        action.singleton_lock! unless action.holds_singleton_lock?
+        pass(*args)
+      end
+    end
+  end
+end

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.8.30'
+  VERSION = '0.8.31'
 end

data/lib/dynflow/web/console.rb

@@ -37,6 +37,16 @@ module Dynflow
         erb :worlds
       end
 
+      post('/worlds/execution_status') do
+        @worlds = world.coordinator.find_worlds(true)
+        @worlds.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)
+        end
+        erb :worlds
+      end
+
       post('/worlds/check') do
         @worlds = world.coordinator.find_worlds
         @validation_results = world.worlds_validity_check(params[:invalidate])

data/lib/dynflow/world.rb

@@ -198,6 +198,10 @@ module Dynflow
       publish_request(Dispatcher::Ping[world_id], done, false, timeout)
     end
 
+    def get_execution_status(world_id, execution_plan_id, timeout, done = Concurrent.future)
+      publish_request(Dispatcher::Status[world_id, execution_plan_id], done, false, timeout)
+    end
+
     def publish_request(request, done, wait_for_accepted, timeout = nil)
       accepted = Concurrent.future
       accepted.rescue do |reason|
@@ -299,11 +303,13 @@ module Dynflow
           logger.error "unexpected error when invalidating execution plan #{execution_lock.execution_plan_id}, skipping"
         end
         coordinator.release(execution_lock)
+        coordinator.release_by_owner(execution_lock.execution_plan_id)
         return
       end
       unless plan.valid?
         logger.error "invalid plan #{plan.id}, skipping"
         coordinator.release(execution_lock)
+        coordinator.release_by_owner(execution_lock.execution_plan_id)
         return
       end
       plan.execution_history.add('terminate execution', execution_lock.world_id)

data/test/action_test.rb

@@ -1,4 +1,5 @@
 require_relative 'test_helper'
+require 'mocha/mini_test'
 
 module Dynflow
   describe 'action' do
@@ -671,6 +672,146 @@ module Dynflow
             clock.pending_pings.count.must_equal 0
           end
         end
+
+        describe ::Dynflow::Action::Singleton do
+          include TestHelpers
+
+          let(:clock) { Dynflow::Testing::ManagedClock.new }
+
+          class SingletonAction < ::Dynflow::Action
+            include ::Dynflow::Action::Singleton
+          end
+
+          class SingletonActionWithRun < SingletonAction
+            def run; end
+          end
+
+          class SingletonActionWithFinalize < SingletonAction
+            def finalize; end
+          end
+
+          class SuspendedSingletonAction < SingletonAction
+            def run(event = nil)
+              unless output[:suspended]
+                output[:suspended] = true
+                suspend
+              end
+            end
+          end
+
+          class BadAction < SingletonAction
+            def plan(break_locks = false)
+              plan_self :break_locks => break_locks
+              singleton_unlock! if break_locks
+            end
+
+            def run
+              singleton_unlock! if input[:break_locks]
+            end
+          end
+
+          it 'unlocks the locks after #plan if no #run or #finalize' do
+            plan = world.plan(SingletonAction)
+            plan.state.must_equal :planned
+            lock_filter = ::Dynflow::Coordinator::SingletonActionLock
+                            .unique_filter plan.entry_action.class.name
+            world.coordinator.find_locks(lock_filter).count.must_equal 1
+            plan = world.execute(plan.id).wait!.value
+            plan.state.must_equal :stopped
+            plan.result.must_equal :success
+            world.coordinator.find_locks(lock_filter).count.must_equal 0
+          end
+
+          it 'unlocks the locks after #finalize' do
+            plan = world.plan(SingletonActionWithFinalize)
+            plan.state.must_equal :planned
+            lock_filter = ::Dynflow::Coordinator::SingletonActionLock
+                              .unique_filter plan.entry_action.class.name
+            world.coordinator.find_locks(lock_filter).count.must_equal 1
+            plan = world.execute(plan.id).wait!.value
+            plan.state.must_equal :stopped
+            plan.result.must_equal :success
+            world.coordinator.find_locks(lock_filter).count.must_equal 0
+          end
+
+          it 'does not unlock when getting suspended' do
+            plan = world.plan(SuspendedSingletonAction)
+            plan.state.must_equal :planned
+            lock_filter = ::Dynflow::Coordinator::SingletonActionLock
+                              .unique_filter plan.entry_action.class.name
+            world.coordinator.find_locks(lock_filter).count.must_equal 1
+            future = world.execute(plan.id)
+            wait_for do
+              plan = world.persistence.load_execution_plan(plan.id)
+              plan.state == :running && plan.result == :pending
+            end
+            world.coordinator.find_locks(lock_filter).count.must_equal 1
+            world.event(plan.id, 2, nil)
+            plan = future.wait!.value
+            plan.state.must_equal :stopped
+            plan.result.must_equal :success
+            world.coordinator.find_locks(lock_filter).count.must_equal 0
+          end
+
+          it 'can be triggered only once' do
+            # plan1 acquires the lock in plan phase
+            plan1 = world.plan(SingletonActionWithRun)
+            plan1.state.must_equal :planned
+            plan1.result.must_equal :pending
+
+            # plan2 tries to acquire the lock in plan phase and fails
+            plan2 = world.plan(SingletonActionWithRun)
+            plan2.state.must_equal :stopped
+            plan2.result.must_equal :error
+            plan2.errors.first.message.must_equal 'Action Dynflow::SingletonActionWithRun is already active'
+
+            # Simulate some bad things happening
+            plan1.entry_action.send(:singleton_unlock!)
+
+            # plan3 acquires the lock in plan phase
+            plan3 = world.plan(SingletonActionWithRun)
+
+            # plan1 tries to relock on run
+            # This should fail because the lock was taken by plan3
+            plan1 = world.execute(plan1.id).wait!.value
+            plan1.state.must_equal :paused
+            plan1.result.must_equal :error
+
+            # plan3 can finish successfully because it holds the lock
+            plan3 = world.execute(plan3.id).wait!.value
+            plan3.state.must_equal :stopped
+            plan3.result.must_equal :success
+
+            # The lock was released when plan3 stopped
+            lock_filter = ::Dynflow::Coordinator::SingletonActionLock
+                              .unique_filter plan3.entry_action.class.name
+            world.coordinator.find_locks(lock_filter).must_be :empty?
+          end
+
+          it 'cannot be unlocked by another action' do
+            # plan1 doesn't keep its locks
+            plan1 = world.plan(BadAction, true)
+            plan1.state.must_equal :planned
+            lock_filter = ::Dynflow::Coordinator::SingletonActionLock
+                              .unique_filter plan1.entry_action.class.name
+            world.coordinator.find_locks(lock_filter).count.must_equal 0
+            plan2 = world.plan(BadAction, false)
+            plan2.state.must_equal :planned
+            world.coordinator.find_locks(lock_filter).count.must_equal 1
+
+            # The locks held by plan2 can't be unlocked by plan1
+            plan1.entry_action.singleton_unlock!
+            world.coordinator.find_locks(lock_filter).count.must_equal 1
+
+            plan1 = world.execute(plan1.id).wait!.value
+            plan1.state.must_equal :paused
+            plan1.result.must_equal :error
+
+            plan2 = world.execute(plan2.id).wait!.value
+            plan2.state.must_equal :stopped
+            plan2.result.must_equal :success
+          end
+        end
       end
     end
   end

data/test/execution_plan_test.rb

@@ -341,6 +341,42 @@ module Dynflow
         end
 
       end
+
+      describe 'with singleton actions' do
+        class SingletonAction < ::Dynflow::Action
+          include ::Dynflow::Action::Singleton
+
+          def run
+            if input[:fail]
+              raise "Controlled Failure"
+            end
+          end
+        end
+
+        it 'unlocks the locks on transition to stopped' do
+          plan = world.plan(SingletonAction)
+          plan.state.must_equal :planned
+          lock_filter = ::Dynflow::Coordinator::SingletonActionLock
+                          .unique_filter plan.entry_action.class.name
+          world.coordinator.find_locks(lock_filter).count.must_equal 1
+          plan = world.execute(plan.id).wait!.value
+          plan.state.must_equal :stopped
+          plan.result.must_equal :success
+          world.coordinator.find_locks(lock_filter).count.must_equal 0
+        end
+
+        it 'unlocks the locks on transition to paused' do
+          plan = world.plan(SingletonAction, :fail => true)
+          plan.state.must_equal :planned
+          lock_filter = ::Dynflow::Coordinator::SingletonActionLock
+                          .unique_filter plan.entry_action.class.name
+          world.coordinator.find_locks(lock_filter).count.must_equal 1
+          plan = world.execute(plan.id).wait!.value
+          plan.state.must_equal :paused
+          plan.result.must_equal :error
+          world.coordinator.find_locks(lock_filter).count.must_equal 0
+        end
+      end
     end
   end
 end

data/test/executor_test.rb

@@ -580,10 +580,12 @@ module Dynflow
         let(:storage) { Dynflow::Executors::Parallel::Pool::JobStorage.new }
         it do
           storage.must_be_empty
+          storage.execution_status.must_equal({})
           storage.pop.must_be_nil
           storage.pop.must_be_nil
 
           storage.add s = FakeStep.new(1)
+          storage.execution_status.must_equal(1 => 1)
           storage.pop.must_equal s
           storage.must_be_empty
           storage.pop.must_be_nil
@@ -595,6 +597,10 @@ module Dynflow
           storage.add s22 = FakeStep.new(2)
           storage.add s31 = FakeStep.new(3)
 
+          storage.execution_status(1).must_equal(1 => 3)
+          storage.execution_status(4).must_equal(4 => 0)
+          storage.execution_status.must_equal({1 => 3, 2 => 2, 3 => 1})
+
           storage.pop.must_equal s21
           storage.pop.must_equal s31
           storage.pop.must_equal s11
@@ -603,6 +609,7 @@ module Dynflow
           storage.pop.must_equal s13
 
           storage.must_be_empty
+          storage.execution_status.must_equal({})
           storage.pop.must_be_nil
         end
       end

data/test/world_test.rb

@@ -19,6 +19,19 @@ module Dynflow
         end
       end
 
+      describe '#get_execution_status' do
+        let(:base) do
+          { :pool_size => 5, :free_workers => 5, :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 })
+          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

data/web/views/worlds.erb

@@ -3,6 +3,7 @@
 <ul>
   <li><a href="<%= url("/worlds/check") %>" class="postlink">check status</a>: see potentially invalid worlds</li>
   <li><a href="<%= url("/worlds/check?invalidate=true") %>" class="postlink">check and invalidate</a>: invalidate the worlds that don't respond</li>
+  <li><a href="<%= url("/worlds/execution_status") %>" class="postlink">load execution items counts</a>: see counts of execution items per world</li>
 </ul>
 
 <table class="table">
@@ -11,6 +12,8 @@
       <th>Id</th>
       <th>Meta</th>
       <th>Executor?</th>
+      <th>Execution items</th>
+      <th>Free/Total workers</th>
       <th></th>
     </tr>
   </thead>
@@ -20,6 +23,8 @@
     <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 %>
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 0.8.30
+  version: 0.8.31
 platform: ruby
 authors:
 - Ivan Necas
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-15 00:00:00.000000000 Z
+date: 2017-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -377,6 +377,7 @@ files:
 - examples/orchestrate.rb
 - examples/orchestrate_evented.rb
 - examples/remote_executor.rb
+- examples/singletons.rb
 - examples/sub_plan_concurrency_control.rb
 - examples/sub_plans.rb
 - lib/dynflow.rb
@@ -387,6 +388,7 @@ files:
 - lib/dynflow/action/polling.rb
 - lib/dynflow/action/progress.rb
 - lib/dynflow/action/rescue.rb
+- lib/dynflow/action/singleton.rb
 - lib/dynflow/action/suspended.rb
 - lib/dynflow/action/timeouts.rb
 - lib/dynflow/action/with_bulk_sub_plans.rb
@@ -455,6 +457,7 @@ files:
 - lib/dynflow/logger_adapters/formatters/exception.rb
 - lib/dynflow/logger_adapters/simple.rb
 - lib/dynflow/middleware.rb
+- lib/dynflow/middleware/common/singleton.rb
 - lib/dynflow/middleware/common/transaction.rb
 - lib/dynflow/middleware/register.rb
 - lib/dynflow/middleware/resolver.rb