synapse-core 0.2.0 → 0.4.0

data/lib/synapse.rb

@@ -10,6 +10,9 @@ require 'synapse/common/identifier'
 require 'synapse/common/message'
 require 'synapse/common/message_builder'
 
+require 'synapse/common/concurrency/identifier_lock'
+require 'synapse/common/concurrency/public_lock'
+
 module Synapse
   extend ActiveSupport::Autoload
 

data/lib/synapse/command/simple_command_bus.rb

@@ -18,7 +18,7 @@ module Synapse
         @handlers = Hash.new
         @filters = Array.new
         @interceptors = Array.new
-        @logger = Logging.logger.new self.class
+        @logger = Logging.logger[self.class]
         @rollback_policy = RollbackOnAnyExceptionPolicy.new
         @unit_factory = unit_factory
       end
@@ -100,7 +100,7 @@ module Synapse
         chain = InterceptorChain.new unit, @interceptors, handler
 
         begin
-          @logger.debug 'Dispatching command [%s] [%s] to handler [%s]' %
+          @logger.info 'Dispatching command [%s] [%s] to handler [%s]' %
             [command.id, command.payload_type, handler.class]
 
           result = chain.proceed command

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

@@ -0,0 +1,71 @@
+module Synapse
+  # @todo Deadlock detection
+  class IdentifierLock
+    # @return [undefined]
+    def initialize
+      @identifiers = Hash.new
+      @lock = Mutex.new
+    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) and 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)
+      lock_for(identifier).lock
+    end
+
+    # Releases a lock for the given identifier
+    #
+    # @raise [ThreadError] If no lock was ever obtained for the identifier
+    # @param [Object] identifier
+    # @return [undefined]
+    def release_lock(identifier)
+      unless lock_available? identifier
+        raise ThreadError, 'No lock for this identifier was ever obtained'
+      end
+
+      lock_for(identifier).unlock
+      dispose_if_unused(identifier)
+    end
+
+  private
+
+    def lock_for(identifier)
+      @lock.synchronize do
+        if @identifiers.has_key? identifier
+          @identifiers[identifier]
+        else
+          @identifiers[identifier] = PublicLock.new
+        end
+      end
+    end
+
+    def lock_available?(identifier)
+      @identifiers.has_key? identifier
+    end
+
+    # Disposes of the lock for the given identifier if it has no threads waiting for it
+    #
+    # @param [String] identifier
+    # @return [undefined]
+    def dispose_if_unused(identifier)
+      lock = lock_for identifier
+      if lock.try_lock
+        @lock.synchronize do
+          @identifiers.delete identifier
+        end
+
+        lock.unlock
+      end
+    end
+  end # IdentifierLock
+end # Synapse

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

@@ -0,0 +1,96 @@
+require 'monitor'
+
+module Synapse
+  class PublicLock
+    # @return [Thread] The current owner of the thread, if any
+    attr_reader :owner
+
+    # @return [Array] The list of threads waiting for this lock
+    attr_reader :waiting
+
+    # @return [undefined]
+    def initialize
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @waiting = Array.new
+    end
+
+    # Returns true if the calling thread owns this lock
+    #
+    # @see Mutex#owned?
+    # @return [Boolean]
+    def owned?
+      @owner == Thread.current
+    end
+
+    # Returns true if the given thread owns this lock
+    # @return [Boolean]
+    def owned_by?(thread)
+      @owner == thread
+    end
+
+    # @see Mutex#synchronize
+    # @return [undefined]
+    def synchronize
+      lock
+
+      begin
+        yield
+      ensure
+        unlock rescue nil
+      end
+    end
+
+    # @see Mutex#lock
+    # @return [undefined]
+    def lock
+      @mutex.synchronize do
+        if @owner == Thread.current
+          raise ThreadError, 'Lock is already owned by the current thread'
+        end
+
+        while @owner
+          begin
+            @waiting.push Thread.current
+            @condition.wait @mutex
+          ensure
+            @waiting.delete Thread.current
+          end
+        end
+
+        @owner = Thread.current
+      end
+    end
+
+    # @see Mutex#unlock
+    # @return [undefined]
+    def unlock
+      @mutex.synchronize do
+        if @owner == Thread.current
+          @owner = nil
+          @condition.signal
+        else
+          raise ThreadError, 'Lock is not owned by the current thread'
+        end
+      end
+    end
+
+    # @see Mutex#try_lock
+    # @return [Boolean]]
+    def try_lock
+      @mutex.synchronize do
+        if @owner == Thread.current
+          raise ThreadError, 'Lock is already owned by the current thread'
+        end
+
+        if @owner
+          return false
+        end
+
+        @owner = Thread.current
+      end
+
+      true
+    end
+  end
+end

data/lib/synapse/event_bus/simple_event_bus.rb

@@ -5,7 +5,7 @@ module Synapse
     class SimpleEventBus < EventBus
       def initialize
         @listeners = Set.new
-        @logger = Logging.logger.new self.class
+        @logger = Logging.logger[self.class]
       end
 
       # @param [EventMessage...] events

data/lib/synapse/event_bus/wiring.rb

@@ -6,10 +6,6 @@ module Synapse
       include EventListener
       include Wiring::MessageWiring
 
-      included do
-        self.wire_registry = Wiring::WireRegistry.new true
-      end
-
       # @param [EventMessage] event
       # @return [undefined]
       def notify(event)

data/lib/synapse/event_sourcing/member.rb

@@ -6,10 +6,6 @@ module Synapse
       extend ActiveSupport::Concern
       include Wiring::MessageWiring
 
-      included do
-        self.wire_registry = Wiring::WireRegistry.new true
-      end
-
       module ClassMethods
         # Registers an instance variable as a child entity
         #

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

@@ -24,7 +24,7 @@ module Synapse
       def initialize(snapshot_taker, unit_provider)
         @counters = Hash.new
         @lock = Mutex.new
-        @logger = Logging.logger.new self.class
+        @logger = Logging.logger[self.class]
         @threshold = DEFAULT_THRESHOLD
 
         @snapshot_taker = snapshot_taker
@@ -40,7 +40,7 @@ module Synapse
       # @return [undefined]
       def trigger_snapshot(type_identifier, aggregate_id, counter)
         if counter.value > @threshold
-          @logger.debug 'Snapshot threshold reached for [%s] [%s]' % [type_identifier, aggregate_id]
+          @logger.info 'Snapshot threshold reached for [%s] [%s]' % [type_identifier, aggregate_id]
 
           @snapshot_taker.schedule_snapshot type_identifier, aggregate_id
           counter.value = 1

data/lib/synapse/event_store.rb

@@ -1,11 +1,3 @@
-module Synapse
-  module EventStore
-    extend ActiveSupport::Autoload
-
-    autoload :InMemoryEventStore, 'synapse/event_store/in_memory'
-    autoload :Mongo
-  end
-end
-
 require 'synapse/event_store/errors'
 require 'synapse/event_store/event_store'
+require 'synapse/event_store/in_memory'

data/lib/synapse/partitioning.rb

@@ -3,8 +3,6 @@ module Synapse
     extend ActiveSupport::Autoload
 
     # Optional queues
-    autoload :AMQP
-
     autoload :MemoryQueueReader
     autoload :MemoryQueueWriter
 

data/lib/synapse/process_manager.rb

@@ -1,4 +1,16 @@
 require 'synapse/process_manager/correlation'
 require 'synapse/process_manager/correlation_resolver'
 require 'synapse/process_manager/correlation_set'
+require 'synapse/process_manager/lock_manager'
+require 'synapse/process_manager/pessimistic_lock_manager'
 require 'synapse/process_manager/process'
+require 'synapse/process_manager/process_factory'
+require 'synapse/process_manager/process_manager'
+require 'synapse/process_manager/process_repository'
+require 'synapse/process_manager/resource_injector'
+require 'synapse/process_manager/simple_process_manager'
+
+require 'synapse/process_manager/wiring/process'
+require 'synapse/process_manager/wiring/process_manager'
+
+require 'synapse/process_manager/repository/in_memory'

data/lib/synapse/process_manager/lock_manager.rb

@@ -0,0 +1,22 @@
+module Synapse
+  module ProcessManager
+    # Represents a mechanism for synchronizing access to processes
+    #
+    # This base implementation does no locking; it can be used if processes are thread safe
+    # and don't need any additional synchronization.
+    class LockManager
+      # Obtains a lock for a process with the given identifier, blocking if necessary
+      #
+      # @param [String] process_id
+      # @return [undefined]
+      def obtain_lock(process_id); end
+
+      # Releases the lock for a process with the given identifier
+      #
+      # @raise [ThreadError] If thread didn't previously hold the lock
+      # @param [String] process_id
+      # @return [undefined]
+      def release_lock(process_id); end
+    end
+  end
+end

data/lib/synapse/process_manager/pessimistic_lock_manager.rb

@@ -0,0 +1,23 @@
+module Synapse
+  module ProcessManager
+    # Lock manager that does pessimistic locking for processes
+    class PessimisticLockManager
+      def initialize
+        @lock = IdentifierLock.new
+      end
+
+      # @param [String] process_id
+      # @return [undefined]
+      def obtain_lock(process_id)
+        @lock.obtain_lock process_id
+      end
+
+      # @raise [ThreadError] If thread didn't previously hold the lock
+      # @param [String] process_id
+      # @return [undefined]
+      def release_lock(process_id)
+        @lock.release_lock process_id
+      end
+    end
+  end
+end

data/lib/synapse/process_manager/process.rb

@@ -1,5 +1,7 @@
 module Synapse
   module ProcessManager
+    # Processes are used to maintain the state of long-running business transactions
+    #
     # The term process is used in Enterprise Integration Patterns to describe a mechanism used to
     # "maintain the state of the sequence and determine the next processing step based on
     # intermediate results" (Hohpe 279). Processes are also called sagas in some CQRS frameworks.

data/lib/synapse/process_manager/process_factory.rb

@@ -0,0 +1,52 @@
+module Synapse
+  module ProcessManager
+    # Represents a mechanism for create instances of processes
+    # @abstract
+    class ProcessFactory
+      # Creates a new instance of a process of a given type
+      #
+      # The returned process will be fully initialized and any resources required will be
+      # provided through dependency injection.
+      #
+      # @abstract
+      # @param [Class] process_type
+      # @return [Process]
+      def create(process_type); end
+
+      # Returns true if processes of the given type can be created by this factory
+      #
+      # @abstract
+      # @param [Class] process_type
+      # @return [Boolean]
+      def supports(process_type); end
+    end
+
+    # Generic implementation of a process factory that supports any process implementations that
+    # have a no-argument constructor
+    class GenericProcessFactory < ProcessFactory
+      # @return [ResourceInjector]
+      attr_accessor :resource_injector
+
+      # @return [undefined]
+      def initialize
+        @resource_injector = ResourceInjector.new
+      end
+
+      # @param [Class] process_type
+      # @return [Process]
+      def create(process_type)
+        process = process_type.new
+        process.tap do
+          @resource_injector.inject_resources process
+        end
+      end
+
+      # @param [Class] process_type
+      # @return [Boolean]
+      def supports(process_type)
+        ctor = process_type.instance_method :initialize
+        ctor.arity <= 0
+      end
+    end
+  end
+end

data/lib/synapse/process_manager/process_manager.rb

@@ -0,0 +1,170 @@
+module Synapse
+  module ProcessManager
+    # Represents a mechanism for managing the lifeycle and notification of process instances
+    # @abstract
+    class ProcessManager
+      include EventBus::EventListener
+
+      # @return [Boolean] Returns true if exceptions will be logged silently
+      attr_accessor :suppress_exceptions
+
+      # @param [ProcessRepository] repository
+      # @param [ProcessFactory] factory
+      # @param [LockManager] lock_manager
+      # @param [Class...] process_types
+      # @return [undefined]
+      def initialize(repository, factory, lock_manager, *process_types)
+        @repository = repository
+        @factory = factory
+        @lock_manager = lock_manager
+        @process_types = process_types.flatten
+
+        @logger = Logging.logger[self.class]
+        @suppress_exceptions = true
+      end
+
+      # @param [EventMessage] event
+      # @return [undefined]
+      def notify(event)
+        @process_types.each do |process_type|
+          correlation = extract_correlation process_type, event
+          if correlation
+            current = notify_current_processes process_type, event, correlation
+            if should_start_new_process process_type, event, current
+              start_new_process process_type, event, correlation
+            end
+          end
+        end
+      end
+
+    protected
+
+      # @abstract
+      # @param [Class] process_type
+      # @param [EventMessage] event
+      # @return [Symbol]
+      def creation_policy_for(process_type, event); end
+
+      # @abstract
+      # @param [Class] process_type
+      # @param [EventMessage] event
+      # @return [Correlation] Returns nil if no correlation could be extracted
+      def extract_correlation(process_type, event); end
+
+      # Determines whether or not a new process should be started, based off of existing processes
+      # and the creation policy for the event and process
+      #
+      # @param [Class] process_type
+      # @param [EventMessage] event
+      # @param [Boolean] current_processes True if there are existing processes
+      # @return [Boolean]
+      def should_start_new_process(process_type, event, current_processes)
+        creation_policy = creation_policy_for process_type, event
+
+        if :always == creation_policy
+          true
+        elsif :if_none_found == creation_policy
+          !current_processes
+        else
+          false
+        end
+      end
+
+      # Notifies existing processes of the given type and correlation of the given event
+      #
+      # @param [Class] process_type
+      # @param [EventMessage] event
+      # @param [Correlation] correlation
+      # @return [Boolean] Returns true if any current processes were found and notified
+      def notify_current_processes(process_type, event, correlation)
+        processes = @repository.find process_type, correlation
+
+        process_invoked = false
+        processes.each do |process_id|
+          @lock_manager.obtain_lock process_id
+          begin
+            loaded_process = notify_current_process process_id, event, correlation
+            if loaded_process
+              process_invoked = true
+            end
+          ensure
+            @lock_manager.release_lock process_id
+          end
+        end
+
+        process_invoked
+      end
+
+      # Loads and notifies the process with the given identifier of the given event
+      #
+      # @param [String] process_id
+      # @param [EventMessage] event
+      # @param [Correlation] correlation
+      # @return [Process]
+      def notify_current_process(process_id, event, correlation)
+        process = @repository.load process_id
+
+        unless process and process.active and process.correlations.include? correlation
+          # Process has changed or was deleted between the time of the selection query and the
+          # actual loading and locking of the process
+          return
+        end
+
+        begin
+          notify_process process, event
+        ensure
+          @repository.commit process
+        end
+
+        process
+      end
+
+      # Creates a new process of the given type with the given correlation
+      #
+      # After the process has been created, it is notified of the given event and then is
+      # committed to the process repository.
+      #
+      # @param [Class] process_type
+      # @param [EventMessage] event
+      # @param [Correlation] correlation
+      # @return [undefined]
+      def start_new_process(process_type, event, correlation)
+        process = @factory.create process_type
+        process.correlations.add correlation
+
+        @lock_manager.obtain_lock process.id
+
+        begin
+          notify_process process, event
+        ensure
+          begin
+            @repository.add process
+          ensure
+            @lock_manager.release_lock process.id
+          end
+        end
+      end
+
+      # Notifies the given process with of the given event
+      #
+      # @raise [Exception] If an error occurs while notifying the process and exception
+      #   suppression is disabled
+      # @param [Process] process
+      # @param [EventMessage] event
+      # @return [undefined]
+      def notify_process(process, event)
+        begin
+          process.handle event
+        rescue => exception
+          if @suppress_exceptions
+            backtrace = exception.backtrace.join $/
+            @logger.error 'Exception occured while invoking process [%s] [%s] with [%s]: %s %s' %
+              [process.class, process.id, event.payload_type, exception.inspect, backtrace]
+          else
+            raise
+          end
+        end
+      end
+    end # ProcessManager
+  end # ProcessManager
+end