synapse-core 0.1.2

data/lib/synapse/command/duplication.rb

@@ -0,0 +1,43 @@
+module Synapse
+  module Command
+    # Filter that prevents duplicate commands from reaching the command handlers
+    class DuplicationFilter < CommandFilter
+      # @param [DuplicationRecorder] recorder
+      # @return [undefined]
+      def initialize(recorder)
+        @recorder = recorder
+      end
+
+      # @param [CommandMessage] command
+      # @return [CommandMessage] The command to dispatch on the bus
+      def filter(command)
+        @recorder.record command
+        command
+      end
+    end
+
+    # Interceptor that removes commands from the duplication recorder if their execution results
+    # in a transient error (like concurrency error) being raised. This way, the same command can
+    # be retried by the client or command gateway
+    class DuplicationCleanupInterceptor < DispatchInterceptor
+      # @param [DuplicationRecorder] recorder
+      # @return [undefined]
+      def initialize(recorder)
+        @recorder = recorder
+      end
+
+      # @param [CommandMessage] command
+      # @param [UnitOfWork] unit The current unit of work for this command dispatch
+      # @param [InterceptorChain] chain
+      # @return [Object] The result of the execution of the command
+      def intercept(command, unit, chain)
+        begin
+          chain.proceed command
+        rescue TransientError
+          @recorder.forget command
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/synapse/command/errors.rb

@@ -0,0 +1,27 @@
+module Synapse
+  module Command
+    # Raised when an error is raised during the handling of a command
+    class CommandExecutionError < SynapseError
+      # @return [Exception]
+      attr_reader :cause
+
+      # @param [Exception] cause
+      # @return [undefined]
+      def initialize(cause)
+        @cause = cause
+        set_backtrace cause.backtrace
+      end
+
+      # @return [String]
+      def inspect
+        @cause.inspect
+      end
+    end
+
+    # Raised when a command is refused because of structural validation errors
+    class CommandValidationError < NonTransientError; end
+
+    # Raised when a dispatched command has no handler subscribed to it
+    class NoHandlerError < NonTransientError; end
+  end
+end

data/lib/synapse/command/filters/validation.rb

@@ -0,0 +1,32 @@
+module Synapse
+  module Command
+    class ActiveModelValidationFilter < CommandFilter
+      # @raise [ActiveModelValidationError] If command doesn't pass validation
+      # @param [CommandMessage] command
+      # @return [CommandMessage] The command to dispatch on the bus
+      def filter(command)
+        payload = command.payload
+
+        if payload.respond_to? :valid?
+          unless payload.valid?
+            raise ActiveModelValidationError, payload.errors
+          end
+        end
+
+        command
+      end
+    end
+
+    # Raised when a command with ActiveModel doesn't pass validation
+    class ActiveModelValidationError < CommandValidationError
+      # @return [ActiveModel::Errors]
+      attr_reader :errors
+
+      # @param [ActiveModel::Errors] errors
+      # @return [undefined]
+      def initialize(errors)
+        @errors = errors
+      end
+    end
+  end
+end

data/lib/synapse/command/gateway.rb

@@ -0,0 +1,34 @@
+module Synapse
+  module Command
+    # Simplified interface to the command bus
+    class CommandGateway
+      # @param [CommandBus] command_bus
+      # @return [undefined]
+      def initialize(command_bus)
+        @command_bus = command_bus
+      end
+
+      # Fire and forget method of sending a command to the command bus
+      #
+      # @param [Object] command
+      # @return [undefined]
+      def send(command)
+        @command_bus.dispatch(as_command_message(command))
+      end
+
+    private
+
+      # @param [Object] command
+      # @return [CommandMessage]
+      def as_command_message(command)
+        unless command.is_a? CommandMessage
+          command = CommandMessage.build do |builder|
+            builder.payload = command
+          end
+        end
+
+        command
+      end
+    end
+  end
+end

data/lib/synapse/command/interceptor_chain.rb

@@ -0,0 +1,31 @@
+module Synapse
+  module Command
+    # Represents a mechanism for controlling the flow through a chain of interceptors that
+    # eventually ends in the invocation of the command handler
+    #
+    # Interceptors can either continue the dispatch of a command by calling {#proceed} or choose
+    # to block the dispatch by not calling {#proceed} at all. Interceptors can also replace the
+    # command message that will be passed on in the chain.
+    class InterceptorChain
+      # @param [UnitOfWork] unit The current unit of work for this command dispatch
+      # @param [Array] interceptors
+      # @param [CommandHandler] handler
+      # @return [undefined]
+      def initialize(unit, interceptors, handler)
+        @unit = unit
+        @interceptors = interceptors.each
+        @handler = handler
+      end
+
+      # @param [CommandMessage] command The command to proceed with
+      # @return [Object] The result of the execution of the command
+      def proceed(command)
+        begin
+          @interceptors.next.intercept command, @unit, self
+        rescue StopIteration
+          @handler.handle command, @unit
+        end
+      end
+    end
+  end
+end

data/lib/synapse/command/interceptors/serialization.rb

@@ -0,0 +1,35 @@
+module Synapse
+  module Command
+    # Interceptor that registers a unit of work listener that wraps each event message in a
+    # serialization-aware message. This provides optimization in cases where storage (in an event
+    # store) and publication (on the event bus) use the same serialization mechansim.
+    class SerializationOptimizingInterceptor < DispatchInterceptor
+      def initialize
+        @listener = SerializationOptimizingListener.new
+      end
+
+      # @param [CommandMessage] command
+      # @param [UnitOfWork] unit The current unit of work for this command dispatch
+      # @param [InterceptorChain] chain
+      # @return [Object] The result of the execution of the command
+      def intercept(command, unit, chain)
+        unit.register_listener @listener
+        chain.proceed command
+      end
+    end
+
+    # @api private
+    class SerializationOptimizingListener < UnitOfWork::UnitOfWorkListener
+      # @param [UnitOfWork] unit
+      # @param [EventMessage] event
+      # @return [EventMessage]
+      def on_event_registered(unit, event)
+        if event.is_a? Domain::DomainEventMessage
+          Serialization::SerializationAwareDomainEventMessage.decorate event
+        else
+          Serialization::SerializationAwareEventMessage.decorate event
+        end
+      end
+    end
+  end
+end

data/lib/synapse/command/message.rb

@@ -0,0 +1,19 @@
+module Synapse
+  module Command
+    # Represents an intent to change application state
+    class CommandMessage < Message
+      # @return [Class]
+      def self.builder
+        CommandMessageBuilder
+      end
+    end
+
+    # Message builder capable of producing CommandMessage instances
+    class CommandMessageBuilder < MessageBuilder
+      # @return [CommandMessage]
+      def build
+        CommandMessage.new @id, @metadata, @payload
+      end
+    end
+  end
+end

data/lib/synapse/command/rollback_policy.rb

@@ -0,0 +1,22 @@
+module Synapse
+  module Command
+    # Represents a mechanism for determining whether or not to rollback the unit of work for a
+    # command dispatch in case an exception occurs during the dispatch
+    class RollbackPolicy
+      # Returns true if the unit of work should be rolled back
+      #
+      # @param [Exception] exception
+      # @return [Boolean]
+      def should_rollback(exception); end
+    end
+
+    # Implementation of a rollback policy that performs a rollback on any exception
+    class RollbackOnAnyExceptionPolicy < RollbackPolicy
+      # @param [Exception] exception
+      # @return [Boolean]
+      def should_rollback(exception)
+        true
+      end
+    end
+  end
+end

data/lib/synapse/command/simple_command_bus.rb

@@ -0,0 +1,138 @@
+module Synapse
+  module Command
+    # Implementation of a command bus that dispatches commands in the calling thread
+    # @todo Thread safety?
+    class SimpleCommandBus < CommandBus
+      # @return [RollbackPolicy]
+      attr_accessor :rollback_policy
+
+      # @return [Array]
+      attr_reader :filters
+
+      # @return [Array]
+      attr_reader :interceptors
+
+      # @param [UnitOfWorkFactory] unit_factory
+      # @return [undefined]
+      def initialize(unit_factory)
+        @handlers = Hash.new
+        @filters = Array.new
+        @interceptors = Array.new
+        @logger = Logging.logger.new self.class
+        @rollback_policy = RollbackOnAnyExceptionPolicy.new
+        @unit_factory = unit_factory
+      end
+
+      # @param [CommandMessage] command
+      # @return [undefined]
+      def dispatch(command)
+        dispatch_with_callback command, CommandCallback.new
+      end
+
+      # @param [CommandMessage] command
+      # @param [CommandCallback] callback
+      # @return [undefined]
+      def dispatch_with_callback(command, callback)
+        begin
+          result = perform_dispatch command
+          callback.on_success result
+        rescue => exception
+          backtrace = exception.backtrace.join $/
+          @logger.error 'Exception occured while dispatching command [%s] [%s]: %s %s' %
+            [command.payload_type, command.id, exception.inspect, backtrace]
+
+          callback.on_failure exception
+        end
+      end
+
+      # @param [Class] command_type
+      # @param [CommandHandler] handler
+      # @return [undefined]
+      def subscribe(command_type, handler)
+        if @handlers.has_key? command_type
+          current_handler = @handlers.fetch command_type
+          @logger.info 'Command handler [%s] is being replaced by [%s] for command type [%s]' %
+            [current_handler.class, handler.class, command_type]
+        else
+          @logger.debug 'Command handler [%s] subscribed to command type [%s]' %
+            [handler.class, command_type]
+        end
+
+        @handlers.store command_type, handler
+      end
+
+      # @param [Class] command_type
+      # @param [CommandHandler] handler
+      # @return [undefined]
+      def unsubscribe(command_type, handler)
+        if @handlers.has_key? command_type
+          current_handler = @handlers.fetch command_type
+          if current_handler.equal? handler
+            @handlers.delete command_type
+
+            @logger.debug 'Command handler [%s] unsubscribed from command type [%s]' %
+              [handler.class, command_type]
+          else
+            @logger.info 'Command type [%s] subscribed to handler [%s] not [%s]' %
+              [command_type, current_handler.class, handler.class]
+          end
+        else
+          @logger.info 'Command type [%s] not subscribed to any handler' % command_type
+        end
+      end
+
+    protected
+
+      # @raise [CommandExecutionError]
+      #   If an error occurs during the handling of the command
+      # @raise [NoHandlerError]
+      #   If no handler is subscribed that is capable of handling the command
+      # @param [CommandMessage] command
+      # @return [Object] The result from the command handler
+      def perform_dispatch(command)
+        @filters.each do |filter|
+          command = filter.filter command
+        end
+
+        handler = handler_for command
+        unit = @unit_factory.create
+
+        chain = InterceptorChain.new unit, @interceptors, handler
+
+        begin
+          @logger.debug 'Dispatching command [%s] [%s] to handler [%s]' %
+            [command.id, command.payload_type, handler.class]
+
+          result = chain.proceed command
+        rescue => exception
+          if @rollback_policy.should_rollback exception
+            @logger.debug 'Unit of work is being rolled back due to rollback policy'
+            unit.rollback exception
+          else
+            @logger.info 'Unit of work is being committed due to rollback policy'
+            unit.commit
+          end
+
+          raise CommandExecutionError, exception
+        end
+
+        unit.commit
+
+        result
+      end
+
+      # @raise [NoHandlerError]
+      # @param [CommandMessage] command
+      # @return [CommandHandler]
+      def handler_for(command)
+        type = command.payload_type
+
+        begin
+          @handlers.fetch type
+        rescue KeyError
+          raise NoHandlerError, 'No handler subscribed for command [%s]' % type
+        end
+      end
+    end
+  end
+end

data/lib/synapse/command/wiring.rb

@@ -0,0 +1,47 @@
+module Synapse
+  module Command
+    # Mixin for a command handler that wishes to use the wiring DSL
+    module WiringCommandHandler
+      extend ActiveSupport::Concern
+      include CommandHandler
+      include Wiring::MessageWiring
+
+      included do
+        self.wire_registry = Wiring::WireRegistry.new false
+      end
+
+      # @param [CommandMessage] command
+      # @param [UnitOfWork] current_unit Current unit of work
+      # @return [Object] The result of handling the given command
+      def handle(command, current_unit)
+        wire = self.wire_registry.wire_for command.payload_type
+
+        unless wire
+          raise ArgumentError, 'Not capable of handling [%s] commands' % command.payload_type
+        end
+
+        invoke_wire command, wire
+      end
+
+      # Subscribes this handler to the given command bus for any types that have been wired
+      #
+      # @param [CommandBus] command_bus
+      # @return [undefined]
+      def subscribe(command_bus)
+        self.wire_registry.each_type do |type|
+          command_bus.subscribe type, self
+        end
+      end
+
+      # Unsubscribes this handler from the given command bus for any types that have been wired
+      #
+      # @param [CommandBus] command_bus
+      # @return [undefined]
+      def unsubscribe(command_bus)
+        self.wire_registry.each_type do |type|
+          command_bus.unsubscribe type, self
+        end
+      end
+    end
+  end
+end

data/lib/synapse/domain/aggregate_root.rb

@@ -0,0 +1,121 @@
+module Synapse
+  module Domain
+    # Mixin module for a basic aggregate root
+    module AggregateRoot
+      # @return [Boolean] True if this aggregate has been marked for deletion
+      attr_reader :deleted
+
+      alias deleted? deleted
+
+      # @return [Object] The identifier of this aggregate
+      attr_reader :id
+
+      # @return [Integer] The version of this aggregate
+      attr_reader :version
+
+      # Adds a listener that will be notified when this aggregate registers an event to be published
+      #
+      # If an event registration listener is added after events have already been registered, it
+      # will still get a change to process the uncommitted events in this aggregate.
+      #
+      # @param [#call] listener
+      # @return [undefined]
+      def add_registration_listener(&listener)
+        event_container.add_registration_listener listener
+      end
+
+      # Marks this aggregate as committed by a repository
+      # @return [undefined]
+      def mark_committed
+        if @event_container
+          @last_sequence_number = @event_container.last_sequence_number
+          @event_container.mark_committed
+        end
+      end
+
+      # Returns the number of uncommitted events published by this aggregate
+      # @return [Integer]
+      def uncommitted_event_count
+        unless @event_container
+          return 0
+        end
+
+        @event_container.size
+      end
+
+      # Returns a domain event strema containing any uncommitted events published by this aggregate
+      # @return [DomainEventStream]
+      def uncommitted_events
+        unless @event_container
+          return SimpleDomainEventStream.new
+        end
+
+        @event_container.to_stream
+      end
+
+    protected
+
+      # Publishes a domain event with the given payload and metadata (optional)
+      #
+      # @param [Object] payload
+      #   Payload of the message; the actual event object
+      #
+      # @param [Hash] metadata
+      #   Metadata associated with the event
+      #
+      # @return [DomainEventMessage] The event that will be committed
+      def publish_event(payload, metadata = nil)
+        event_container.register_event payload, metadata
+      end
+
+      # Initializes the event container with the given sequence number
+      #
+      # @param [Integer] last_sequence_number
+      #   The sequence number of the last committed event for this aggregate
+      #
+      # @return [undefined]
+      def initialize_event_container(last_sequence_number)
+        event_container.initialize_sequence_number last_sequence_number
+        @last_sequence_number = last_sequence_number >= 0 ? last_sequence_number : nil
+      end
+
+      # Returns the sequence number of the last committed event
+      # @return [Integer]
+      def last_committed_sequence_number
+        unless @event_container
+          return @last_sequence_number
+        end
+
+        @event_container.last_committed_sequence_number
+      end
+
+      # Marks this aggregate for deletion by its repository
+      # @return [undefined]
+      def mark_deleted
+        @deleted = true
+      end
+
+    private
+
+      # Initializes the uncommitted event container for this aggregate, if not already
+      #
+      # @raise [AggregateIdentifierNotInitializedError] If identifier not set
+      # @return [EventContainer]
+      def event_container
+        unless @event_container
+          unless @id
+            raise AggregateIdentifierNotInitializedError
+          end
+
+          @event_container = EventContainer.new @id
+          @event_container.initialize_sequence_number @last_sequence_number
+        end
+
+        @event_container
+      end
+    end
+
+    # Raised when an event is published but the aggregate identifier is not set
+    class AggregateIdentifierNotInitializedError < NonTransientError; end
+  end
+end