synapse-core 0.5.6 → 0.6.0

data/lib/synapse/common/concurrency/identifier_lock_manager.rb

@@ -0,0 +1,164 @@
+module Synapse
+  # Generic lock manager that can be used to lock identifiers for exclusive access
+  class IdentifierLockManager
+    @mutex = Mutex.new
+    @instances = Ref::WeakKeyMap.new
+
+    class << self
+      # @api private
+      # @return [Array]
+      def instances
+        @mutex.synchronize do
+          @instances.keys
+        end
+      end
+
+      # @api private
+      # @param [IdentifierLockManager] instance
+      # @return [undefined]
+      def add(instance)
+        @mutex.synchronize do
+          @instances[instance] = true
+        end
+      end
+
+      # @api private
+      # @param [Thread] thread
+      # @return [Set]
+      def waiters_for_locks_owned_by(thread)
+        stack = Array.new
+        waiters = Set.new
+
+        find_waiters thread, instances, waiters, stack
+
+        waiters
+      end
+
+    private
+
+      # @param [Thread] thread
+      # @param [Array] managers
+      # @param [Set] waiters
+      # @param [Array] stack
+      # @return [undefined]
+      def find_waiters(thread, managers, waiters, stack)
+        stack.push thread
+
+        for manager in managers
+          for lock in manager.internal_locks
+            next unless lock.owned_by? thread
+
+            for waiter in lock.waiters
+              # Avoid infinite recursion in the case of an imminent deadlock
+              next if stack.include? waiter
+
+              # Skip waiters that are already known
+              next unless waiters.add? waiter
+
+              # Recursively find waiters for locks
+              find_waiters waiter, managers, waiters, stack
+            end
+          end
+        end
+
+        stack.pop
+      end
+    end
+
+    # @return [undefined]
+    def initialize
+      @locks = Hash.new
+      @mutex = Mutex.new
+
+      IdentifierLockManager.add self
+    end
+
+    # Returns true if the calling thread holds the lock for the given identifier
+    #
+    # @param [Object] identifier
+    # @return [Boolean]
+    def owned?(identifier)
+      lock_available?(identifier) && lock_for(identifier).owned?
+    end
+
+
+    # Obtains a lock for the given identifier, blocking until the lock is obtained
+    #
+    # @param [Object] identifier
+    # @return [undefined]
+    def obtain_lock(identifier)
+      loop do
+        lock = lock_for identifier
+
+        return if lock.lock
+        remove_lock identifier, lock
+      end
+    end
+
+    # Releases a lock for the given identifier
+    #
+    # @raise [RuntimeError] If no lock was ever obtained for the identifier
+    # @param [Object] identifier
+    # @return [undefined]
+    def release_lock(identifier)
+      unless lock_available? identifier
+        raise RuntimeError
+      end
+
+      lock = lock_for identifier
+      lock.unlock
+
+      try_dispose identifier, lock
+    end
+
+    # @api private
+    # @return [Array]
+    def internal_locks
+      @mutex.synchronize do
+        @locks.values
+      end
+    end
+
+  private
+
+    # @param [Object] identifier
+    # @param [DisposableLock] lock
+    # @return [undefined]
+    def try_dispose(identifier, lock)
+      if lock.try_close
+        remove_lock identifier, lock
+      end
+    end
+
+    # @param [Object] identifier
+    # @param [DisposableLock] lock
+    # @return [undefined]
+    def remove_lock(identifier, lock)
+      @mutex.synchronize do
+        @locks.delete_if do |i, l|
+          i == identifier && l == lock
+        end
+      end
+    end
+
+    # @param [Object] identifier
+    # @return [DisposableLock]
+    def lock_for(identifier)
+      @mutex.synchronize do
+        if @locks.has_key? identifier
+          @locks.fetch identifier
+        else
+          @locks.store identifier, DisposableLock.new
+        end
+      end
+    end
+
+    # @param [Object] identifier
+    # @return [Boolean]
+    def lock_available?(identifier)
+      @mutex.synchronize do
+        @locks.has_key? identifier
+      end
+    end
+  end # IdentifierLockManager
+end

data/lib/synapse/common/duplication.rb

@@ -6,7 +6,7 @@ module Synapse
   class DuplicationRecorder
     def initialize
       @recorded = Hash.new
-      @lock = Mutex.new
+      @mutex = Mutex.new
     end
 
     # Records the given message so that duplicates can be ignored
@@ -15,7 +15,7 @@ module Synapse
     # @param [Message] message
     # @return [undefined]
     def record(message)
-      @lock.synchronize do
+      @mutex.synchronize do
         if @recorded.has_key? message.id
           raise DuplicationError
         end
@@ -37,7 +37,7 @@ module Synapse
     # @param [Message] message
     # @return [undefined]
     def forget(message)
-      @lock.synchronize do
+      @mutex.synchronize do
         @recorded.delete message.id
       end
     end
@@ -47,7 +47,7 @@ module Synapse
     # @param [Time] threshold
     # @return [undefined]
     def forget_older_than(threshold)
-      @lock.synchronize do
+      @mutex.synchronize do
         @recorded.delete_if do |message_id, timestamp|
           timestamp <= threshold
         end

data/lib/synapse/common/errors.rb

@@ -10,4 +10,9 @@ module Synapse
 
   # Raised when an error has occured that might be resolved by retrying the operation
   class TransientError < SynapseError; end
+
+  # Raised when an imminent deadlock is detected
+  #
+  # It is typically safe to retry an operation if it resulted in this exception
+  class DeadlockError < TransientError; end
 end

data/lib/synapse/configuration/container.rb

@@ -40,7 +40,7 @@ module Synapse
         end
       end
 
-      alias [] resolve
+      alias_method :[], :resolve
 
       # Resolves any definitions that have the given tag
       #

data/lib/synapse/configuration/container_builder.rb

@@ -4,7 +4,7 @@ module Synapse
     # @see Synapse#build
     class ContainerBuilder
       # Registered initializers that will be executed upon instantiation
-      # @return [Array]
+      # @return [Array<Proc>]
       class_attribute :initializers
 
       # Registers a block that will be executed upon instantiation of a container builder

data/lib/synapse/configuration/definition.rb

@@ -3,7 +3,7 @@ module Synapse
     # Represents a definition for a service being provided by the container
     # @see DefinitionBuilder
     class Definition
-      # @return [Set] Symbols that this definition is tagged with
+      # @return [Set<Symbol>] Symbols that this definition is tagged with
       attr_reader :tags
 
       # @param [Set] tags

data/lib/synapse/domain/aggregate_root.rb

@@ -21,7 +21,7 @@ module Synapse
       # @return [Boolean] True if this aggregate has been marked for deletion
       attr_reader :deleted
 
-      alias deleted? deleted
+      alias_method :deleted?, :deleted
 
       # @return [Object] The identifier of this aggregate
       attr_reader :id

data/lib/synapse/domain/simple_stream.rb

@@ -9,14 +9,13 @@ module Synapse
         @next_index = 0
       end
 
-      # Returns true if the end of the stream has been reached
+      # @api public
       # @return [Boolean]
       def end?
         @next_index >= @events.size
       end
 
-      # Returns the next event in the stream and moves the stream's pointer forward
-      #
+      # @api public
       # @raise [EndOfStreamError] If the end of the stream has been reached
       # @return [DomainEventMessage]
       def next_event
@@ -28,8 +27,7 @@ module Synapse
         event
       end
 
-      # Returns the next event in the stream without moving the stream's pointer forward
-      #
+      # @api public
       # @raise [EndOfStreamError] If the end of the stream has been reached
       # @return [DomainEventMessage]
       def peek

data/lib/synapse/domain/stream.rb

@@ -3,13 +3,13 @@ module Synapse
     # Represents a historical stream of domain events in chronological order
     #
     # @example
-    #   stream = InMemoryDomainEventStream.new events
+    #   stream = SimpleDomainEventStream.new events
     #   until stream.end?
     #     puts stream.next_event
     #   end
     #
     # @example
-    #   stream = InMemoryDomainEventStream.new events
+    #   stream = SimpleDomainEventStream.new events
     #   stream.each do |event|
     #     puts event
     #   end

data/lib/synapse/event_bus/event_bus.rb

@@ -22,7 +22,7 @@ module Synapse
       # Subscribes the given listener to this event bus
       #
       # @abstract
-      # @raise [SubscriptionFailedError] If subscription of an event listener failed
+      # @raise [SubscriptionError] If subscription of an event listener failed
       # @param [EventListener] listener
       # @return [undefined]
       def subscribe(listener)
@@ -41,6 +41,6 @@ module Synapse
 
     # Raised when the subscription of an event listener has not succeeded. Generally, this means that
     # some precondition set by an event bus implementation for the listener have not been met.
-    class SubscriptionFailedError < NonTransientError; end
+    class SubscriptionError < NonTransientError; end
   end
 end

data/lib/synapse/event_bus/simple_event_bus.rb

@@ -17,8 +17,7 @@ module Synapse
         events.flatten!
         events.each do |event|
           @listeners.each do |listener|
-            @logger.debug 'Dispatching event [%s] to listener [%s]' %
-              [event.payload_type, listener.class]
+            @logger.debug "Publishing event {#{event.payload_type}} to {#{listener.class}}"
 
             listener.notify event
           end
@@ -39,9 +38,9 @@ module Synapse
       # @return [undefined]
       def subscribe(listener)
         if @listeners.add? listener
-          @logger.debug 'Event listener [%s] subscribed' % listener.class
+          @logger.debug "Event listener {#{listener.class}} subscribed"
         else
-          @logger.info 'Event listener [%s] not added, was already subscribed' % listener.class
+          @logger.info "Event listener {#{listener.class}} is already subscribed"
         end
       end
 
@@ -50,9 +49,9 @@ module Synapse
       # @return [undefined]
       def unsubscribe(listener)
         if @listeners.delete? listener
-          @logger.debug 'Event listener [%s] unsubscribed' % listener.class
+          @logger.debug "Event listener {#{listener.class}} unsubscribed"
         else
-          @logger.info 'Event listener [%s] not removed, was not subscribed' % listener.class
+          @logger.info "Event listener {#{listener.class}} is not subscribed"
         end
       end
     end # SimpleEventBus

data/lib/synapse/event_sourcing/caching.rb

@@ -38,7 +38,7 @@ module Synapse
 
       # @param [AggregateRoot] aggregate
       # @return [undefined]
-      def save_aggregate(aggregate)
+      def save_aggregate_with_lock(aggregate)
         super aggregate
         @cache.write aggregate.id, aggregate
       end

data/lib/synapse/event_sourcing/entity.rb

@@ -25,8 +25,10 @@ module Synapse
       # @param [AggregateRoot] aggregate_root
       # @return [undefined]
       def aggregate_root=(aggregate_root)
-        if @aggregate_root and !@aggregate_root.equal? aggregate_root
-          raise 'Entity is registered to a different aggregate root'
+        if @aggregate_root
+          unless @aggregate_root === aggregate_root
+            raise 'Entity is registered to a different aggregate root'
+          end
         end
 
         @aggregate_root = aggregate_root

data/lib/synapse/event_sourcing/repository.rb

@@ -65,7 +65,7 @@ module Synapse
           raise AggregateDeletedError.new type_identifier, aggregate_id
         end
 
-        if expected_version and @conflict_resolver.nil?
+        if expected_version && @conflict_resolver.nil?
           assert_version_expected aggregate, expected_version
         end
 
@@ -75,7 +75,7 @@ module Synapse
       # @param [AggregateRoot] aggregate
       # @return [undefined]
       def post_registration(aggregate)
-        if @snapshot_policy and @snapshot_taker
+        if @snapshot_policy && @snapshot_taker
           listener =
             SnapshotUnitOfWorkListener.new type_identifier, aggregate, @snapshot_policy, @snapshot_taker
 
@@ -85,17 +85,13 @@ module Synapse
 
       # @param [AggregateRoot] aggregate
       # @return [undefined]
-      def delete_aggregate(aggregate)
-        save_aggregate aggregate
+      def delete_aggregate_with_lock(aggregate)
+        save_aggregate_with_lock aggregate
       end
 
       # @param [AggregateRoot] aggregate
       # @return [undefined]
-      def save_aggregate(aggregate)
-        if aggregate.version and !@lock_manager.validate_lock aggregate
-          raise Repository::ConflictingModificationError
-        end
-
+      def save_aggregate_with_lock(aggregate)
         stream = aggregate.uncommitted_events
         @stream_decorators.reverse_each do |decorator|
           stream = decorator.decorate_for_append type_identifier, aggregate, stream
@@ -122,7 +118,7 @@ module Synapse
       # @param [Integer] expected_version
       # @return [DomainEventStream]
       def add_conflict_resolution(stream, aggregate, expected_version)
-        unless expected_version and @conflict_resolver
+        unless expected_version && @conflict_resolver
           return stream
         end
 
@@ -135,7 +131,7 @@ module Synapse
 
         stream
       end
-    end
+    end # EventSourcingRepository
 
     # Raised when an aggregate has been found but it was marked for deletion
     class AggregateDeletedError < Repository::AggregateNotFoundError
@@ -145,6 +141,6 @@ module Synapse
       def initialize(type_identifier, aggregate_id)
         super 'Aggregate marked for deletion [%s] [%s]' % [type_identifier, aggregate_id]
       end
-    end
-  end
+    end # AggregateDeletedError
+  end # EventSourcing
 end

data/lib/synapse/event_sourcing/snapshot/taker.rb

@@ -30,7 +30,7 @@ module Synapse
           first_sequence_number = stream.peek.sequence_number
           snapshot = create_snapshot type_identifier, aggregate_id, stream
 
-          if snapshot and snapshot.sequence_number > first_sequence_number
+          if snapshot && snapshot.sequence_number > first_sequence_number
             @event_store.append_snapshot_event type_identifier, snapshot
           end
         end

data/lib/synapse/mapping/mapping.rb

@@ -54,7 +54,7 @@ module Synapse
           @type == other.type
       end
 
-      alias eql? ==
+      alias_method :eql?, :==
 
       # TODO Is this a good hash function? Probs not
       # @return [Integer]