synapse-core 0.2.0 → 0.4.0

data/lib/synapse/process_manager/process_repository.rb

@@ -0,0 +1,53 @@
+module Synapse
+  module ProcessManager
+    # Represents a mechanism for storing and loading process instances
+    # @abstract
+    class ProcessRepository
+      # Returns a set of process identifiers for processes of the given type that have been
+      # correlated with the given key value pair
+      #
+      # Processes that have been changed must be committed for changes to take effect
+      #
+      # @abstract
+      # @param [Class] type
+      # @param [Correlation] correlation
+      # @return [Set]
+      def find(type, correlation); end
+
+      # Loads a known process by its unique identifier
+      #
+      # Processes that have been changed must be committed for changes to take effect
+      #
+      # Due to the concurrent nature of processes, it is not unlikely for a process to have
+      # ceased to exist after it has been found based on correlations. Therefore, a repository
+      # should gracefully handle a missing process.
+      #
+      # @abstract
+      # @param [String] id
+      # @return [Process] Returns nil if process could not be found
+      def load(id); end
+
+      # Commits the changes made to the process instance
+      #
+      # If the committed process is marked as inactive, it should delete the process from the
+      # underlying storage and remove all correlations for that process.
+      #
+      # @abstract
+      # @param [Process] process
+      # @return [undefined]
+      def commit(process); end
+
+      # Registers a newly created process with the repository
+      #
+      # Once a process has been registered, it can be found using its correlations or by its
+      # unique identifier.
+      #
+      # Note that if the added process is marked as inactive, it will not be stored.
+      #
+      # @abstract
+      # @param [Process] process
+      # @return [undefined]
+      def add(process); end
+    end
+  end
+end

data/lib/synapse/process_manager/repository/in_memory.rb

@@ -0,0 +1,63 @@
+module Synapse
+  module ProcessManager
+    # Process repository that stores all processes in memory
+    #
+    # This implementation is not thread-safe -- use a lock manager for thread safety
+    class InMemoryProcessRepository < ProcessRepository
+      def initialize
+        @managed_processes = Hash.new
+        @lock = Mutex.new
+      end
+
+      # @param [Class] type
+      # @param [Correlation] correlation
+      # @return [Set]
+      def find(type, correlation)
+        matching = Array.new
+
+        @managed_processes.each_value do |process|
+          if process.correlations.include? correlation
+            matching.push process.id
+          end
+        end
+
+        matching
+      end
+
+      # @param [String] id
+      # @return [Process] Returns nil if process could not be found
+      def load(id)
+        if @managed_processes.has_key? id
+          @managed_processes.fetch id
+        end
+      end
+
+      # @param [Process] process
+      # @return [undefined]
+      def commit(process)
+        @lock.synchronize do
+          if process.active?
+            @managed_processes.store process.id, process
+          else
+            @managed_processes.delete process.id
+          end
+        end
+
+        process.correlations.commit
+      end
+
+      # @param [Process] process
+      # @return [undefined]
+      def add(process)
+        if process.active?
+          commit process
+        end
+      end
+
+      # @return [Integer] The number of processes managed by this repository
+      def count
+        @managed_processes.count
+      end
+    end # InMemoryProcessRepository
+  end
+end

data/lib/synapse/process_manager/resource_injector.rb

@@ -0,0 +1,12 @@
+module Synapse
+  module ProcessManager
+    # Represents a mechanism for injecting resources into process instances
+    class ResourceInjector
+      # Injects required resources into the given process instance
+      #
+      # @param [Process] process
+      # @return [undefined]
+      def inject_resources(process); end
+    end
+  end
+end

data/lib/synapse/process_manager/simple_process_manager.rb

@@ -0,0 +1,48 @@
+module Synapse
+  module ProcessManager
+    # Simple implementation of a process manager
+    class SimpleProcessManager < ProcessManager
+      # @return [Array] Types of events that will always result in the creation of a process
+      attr_accessor :always_create_events
+      # @return [Array] Types of events that will result in the creation of a process if one
+      #   doesn't already exist
+      attr_accessor :optionally_create_events
+
+      # @param [ProcessRepository] repository
+      # @param [ProcessFactory] factory
+      # @param [LockManager] lock_manager
+      # @param [CorrelationResolver] correlation_resolver
+      # @param [Class...] process_types
+      # @return [undefined]
+      def initialize(repository, factory, lock_manager, correlation_resolver, *process_types)
+        super repository, factory, lock_manager, *process_types
+
+        @correlation_resolver = correlation_resolver
+        @always_create_events = Array.new
+        @optionally_create_events = Array.new
+      end
+
+    protected
+
+      # @param [Class] process_type
+      # @param [EventMessage] event
+      # @return [Symbol]
+      def creation_policy_for(process_type, event)
+        if @always_create_events.include? event.payload_type
+          :always
+        elsif @optionally_create_events.include? event.payload_type
+          :if_none_found
+        else
+          :none
+        end
+      end
+
+      # @param [Class] process_type
+      # @param [EventMessage] event
+      # @return [Correlation] Returns nil if no correlation could be extracted
+      def extract_correlation(process_type, event)
+        @correlation_resolver.resolve event
+      end
+    end # SimpleProcessManager
+  end # ProcessManager
+end

data/lib/synapse/process_manager/wiring/process.rb

@@ -0,0 +1,27 @@
+module Synapse
+  module ProcessManager
+    # Process that has the wiring DSL built-in
+    #
+    # @example
+    #   class OrderProcess < WiringProcess
+    #     wire OrderCreatedEvent, correlate: :order_id, start: true, to: :on_create
+    #     wire OrderFinishedEvent, correlate: :order_id, finish: true, to: :on_finish
+    #   end
+    class WiringProcess < Process
+      include Wiring::MessageWiring
+
+      # @param [EventMessage] event
+      # @return [undefined]
+      def handle(event)
+        return unless @active
+
+        wire = self.wire_registry.wire_for event.payload_type
+
+        if wire
+          invoke_wire event, wire
+          finish if wire.options[:finish]
+        end
+      end
+    end # WiringProcess
+  end
+end

data/lib/synapse/process_manager/wiring/process_manager.rb

@@ -0,0 +1,72 @@
+module Synapse
+  module ProcessManager
+    # Process manager that is aware of processes that use the wiring DSL
+    # @see [WiringProcess]
+    class WiringProcessManager < ProcessManager
+      # @raise [ArgumentError] If a process type is given that doesn't support the wiring DSL
+      # @param [ProcessRepository] repository
+      # @param [ProcessFactory] factory
+      # @param [LockManager] lock_manager
+      # @param [Class...] process_types
+      # @return [undefined]
+      def initialize(repository, factory, lock_manager, *process_types)
+        super
+
+        @process_types.each do |process_type|
+          unless process_type.respond_to? :wire_registry
+            raise ArgumentError, 'Incompatible process type %s' % process_type
+          end
+        end
+      end
+
+    protected
+
+      # @param [Class] process_type
+      # @param [EventMessage] event
+      # @return [Symbol]
+      def creation_policy_for(process_type, event)
+        wire = process_type.wire_registry.wire_for event.payload_type
+
+        if wire
+          if !wire.options[:start]
+            :none
+          elsif wire.options[:force_new]
+            :always
+          else
+            :if_none_found
+          end
+        end
+      end
+
+      # @param [Class] process_type
+      # @param [EventMessage] event
+      # @return [Correlation] Returns nil if no correlation could be extracted
+      def extract_correlation(process_type, event)
+        wire = process_type.wire_registry.wire_for event.payload_type
+
+        if wire
+          correlation_key = wire.options[:correlate]
+          if correlation_key
+            correlation_value event.payload, correlation_key
+          end
+        end
+      end
+
+    private
+
+      # @param [Object] payload
+      # @param [Symbol] correlation_key
+      # @return [Correlation] Returns nil if correlation value could not be extracted
+      def correlation_value(payload, correlation_key)
+        unless payload.respond_to? correlation_key
+          raise 'Correlation key [%s] is not valid for [%s]' % [correlation_key, payload.class]
+        end
+
+        value = payload.public_send correlation_key
+        if value
+          Correlation.new correlation_key, value
+        end
+      end
+    end
+  end
+end

data/lib/synapse/repository.rb

@@ -1,6 +1,7 @@
 require 'synapse/repository/errors'
 
 require 'synapse/repository/lock_manager'
+require 'synapse/repository/optimistic_lock_manager'
 require 'synapse/repository/pessimistic_lock_manager'
 
 require 'synapse/repository/repository'

data/lib/synapse/repository/locking.rb

@@ -10,7 +10,7 @@ module Synapse
       # @return [undefined]
       def initialize(lock_manager)
         @lock_manager = lock_manager
-        @logger = Logging.logger.new self.class
+        @logger = Logging.logger[self.class]
       end
 
       # @raise [AggregateNotFoundError]

data/lib/synapse/repository/optimistic_lock_manager.rb

@@ -0,0 +1,128 @@
+module Synapse
+  module Repository
+    # Lock manager that uses an optimistic locking strategy
+    #
+    # This implementation uses the sequence number of an aggregate's last committed event to
+    # detect concurrenct access.
+    class OptimisticLockManager < LockManager
+      def initialize
+        @aggregates = Hash.new
+        @lock = Mutex.new
+      end
+
+      # @param [AggregateRoot] aggregate
+      # @return [Boolean]
+      def validate_lock(aggregate)
+        @aggregates.has_key? aggregate.id and @aggregates[aggregate.id].validate aggregate
+      end
+
+      # @param [Object] aggregate_id
+      # @return [undefined]
+      def obtain_lock(aggregate_id)
+        obtained = false
+        until obtained
+          lock = lock_for aggregate_id
+          obtained = lock and lock.lock
+          unless obtained
+            remove_lock aggregate_id, lock
+          end
+        end
+      end
+
+      # @param [Object] aggregate_id
+      # @return [undefined]
+      def release_lock(aggregate_id)
+        lock = @aggregates[aggregate_id]
+        if lock
+          lock.unlock
+          if lock.closed?
+            remove_lock aggregate_id, lock
+          end
+        end
+      end
+
+    private
+
+      # @param [Object] aggregate_id
+      # @param [OptimisticLock] lock
+      # @return [undefined]
+      def remove_lock(aggregate_id, lock)
+        @lock.synchronize do
+          if @aggregates.has_key? aggregate_id and @aggregates[aggregate_id].equal? lock
+            @aggregates.delete aggregate_id
+          end
+        end
+      end
+
+      # @param [Object] aggregate_id
+      # @return [OptimisticLock]
+      def lock_for(aggregate_id)
+        @lock.synchronize do
+          if @aggregates.has_key? aggregate_id
+            @aggregates[aggregate_id]
+          else
+            @aggregates[aggregate_id] = OptimisticLock.new
+          end
+        end
+      end
+    end
+
+    # Lock that keeps track of an aggregate's version
+    # @api private
+    class OptimisticLock
+      # @return [Boolean] True if this lock can be disposed
+      attr_reader :closed
+
+      alias closed? closed
+
+      # @return [Hash] Hash of threads to the number of times they hold the lock
+      attr_reader :threads
+
+      def initialize
+        @closed = false
+        @threads = Hash.new 0
+      end
+
+      # @param [AggregateRoot] aggregate
+      # @return [Boolean]
+      def validate(aggregate)
+        last_committed = aggregate.version
+        if @version.nil? or @version.eql? last_committed
+          if last_committed.nil?
+            last_committed = 0
+          end
+
+          @version = last_committed + aggregate.uncommitted_event_count
+
+          true
+        else
+          false
+        end
+      end
+
+      # @return [Boolean] Returns false if lock is closed
+      def lock
+        if @closed
+          false
+        else
+          @threads[Thread.current] = @threads[Thread.current] + 1
+          true
+        end
+      end
+
+      # @return [undefined]
+      def unlock
+        count = @threads[Thread.current]
+        if count <= 1
+          @threads.delete Thread.current
+        else
+          @threads[Thread.current] = @threads[Thread.current] - 1
+        end
+
+        if @threads.empty?
+          @closed = true
+        end
+      end
+    end # OptimisticLock
+  end # Repository
+end

data/lib/synapse/repository/pessimistic_lock_manager.rb

@@ -3,59 +3,26 @@ module Synapse
     # Rough implementation of a pessimistic lock manager using local locks
     class PessimisticLockManager < LockManager
       def initialize
-        @aggregates = Hash.new
-        @lock = Mutex.new
+        @aggregates = IdentifierLock.new
       end
 
-      # @todo Check if current thread holds lock, not just if lock is held
       # @param [AggregateRoot] aggregate
       # @return [Boolean]
       def validate_lock(aggregate)
-        @aggregates.has_key?(aggregate.id) and lock_for(aggregate.id).locked?
+        @aggregates.owned? aggregate.id
       end
 
       # @param [Object] aggregate_id
       # @return [undefined]
       def obtain_lock(aggregate_id)
-        lock = lock_for aggregate_id
-        lock.lock
+        @aggregates.obtain_lock aggregate_id
       end
 
       # @param [Object] aggregate_id
       # @return [undefined]
       def release_lock(aggregate_id)
-        unless @aggregates.has_key? aggregate_id
-          raise 'No lock for this identifier was ever obtained'
-        end
-
-        lock = lock_for aggregate_id
-        lock.unlock
-      end
-
-    private
-
-      # @param [Object] aggregate_id
-      # @return [Mutex]
-      def lock_for(aggregate_id)
-        lock = @aggregates[aggregate_id]
-        until lock
-          put_if_absent aggregate_id, Mutex.new
-          lock = @aggregates[aggregate_id]
-        end
-        lock
+        @aggregates.release_lock aggregate_id
       end
-
-      # @param [Object] aggregate_id
-      # @param [Mutex] lock
-      # @return [undefined]
-      def put_if_absent(aggregate_id, lock)
-        @lock.synchronize do
-          unless @aggregates.has_key? aggregate_id
-            @aggregates.store aggregate_id, lock
-          end
-        end
-      end
-
     end
   end
 end