synapse-core 0.1.2

data/lib/synapse/event_sourcing/repository.rb

@@ -0,0 +1,119 @@
+module Synapse
+  module EventSourcing
+    # Repository that initializes the state of aggregates using events read from an event
+    # store and appends changes to aggregates to an event store
+    class EventSourcingRepository < Repository::LockingRepository
+      # @return [AggregateFactory]
+      attr_reader :aggregate_factory
+
+      # @return [ConflictResolver]
+      attr_accessor :conflict_resolver
+
+      # @return [EventStore]
+      attr_reader :event_store
+
+      # @return [Array<EventStreamDecorator>]
+      attr_reader :stream_decorators
+
+      # @param [AggregateFactory] aggregate_factory
+      # @param [EventStore] event_store
+      # @param [LockManager] lock_manager
+      # @return [undefined]
+      def initialize(aggregate_factory, event_store, lock_manager)
+        super lock_manager
+
+        @aggregate_factory = aggregate_factory
+        @event_store = event_store
+        @stream_decorators = Array.new
+        @storage_listener =
+          EventSourcedStorageListener.new @event_store, @lock_manager, @stream_decorators, type_identifier
+      end
+
+      # Appends a stream decorator onto the end of the list of stream decorators
+      #
+      # @param [EventStreamDecorator] stream_decorator
+      # @return [undefined]
+      def add_stream_decorator(stream_decorator)
+        @stream_decorators.push stream_decorator
+      end
+
+    protected
+
+      # @raise [AggregateNotFoundError]
+      #   If the aggregate with the given identifier could not be found
+      # @raise [AggregateDeletedError]
+      #   If the loaded aggregate has been marked as deleted
+      # @raise [ConflictingModificationError]
+      #   If the expected version doesn't match the aggregate's actual version
+      # @param [Object] aggregate_id
+      # @param [Integer] expected_version
+      # @return [AggregateRoot]
+      def perform_load(aggregate_id, expected_version)
+        begin
+          stream = @event_store.read_events type_identifier, aggregate_id
+        rescue EventStore::StreamNotFoundError
+          raise Repository::AggregateNotFoundError
+        end
+
+        @stream_decorators.each do |decorator|
+          stream = decorator.decorate_for_read aggregate_type, aggregate_id, stream
+        end
+
+        aggregate = @aggregate_factory.create_aggregate aggregate_id, stream.peek
+
+        stream = add_conflict_resolution stream, aggregate, expected_version
+
+        aggregate.initialize_from_stream stream
+
+        if aggregate.deleted?
+          raise AggregateDeletedError
+        end
+
+        if expected_version and @conflict_resolver.nil?
+          assert_version_expected aggregate, expected_version
+        end
+
+        aggregate
+      end
+
+      # @return [Class]
+      def aggregate_type
+        @aggregate_factory.aggregate_type
+      end
+
+      # @return [StorageListener]
+      def storage_listener
+        @storage_listener
+      end
+
+      # @return [String]
+      def type_identifier
+        @aggregate_factory.type_identifier
+      end
+
+    private
+
+      # @param [DomainEventStream] stream
+      # @param [AggregateRoot] aggregate
+      # @param [Integer] expected_version
+      # @return [DomainEventStream]
+      def add_conflict_resolution(stream, aggregate, expected_version)
+        unless expected_version and @conflict_resolver
+          return stream
+        end
+
+        unseen_events = Array.new
+
+        stream = CapturingEventStream.new stream, unseen_events, expected_version
+        listener = ConflictResolvingUnitOfWorkListener.new aggregate, unseen_events, @conflict_resolver
+
+        register_listener listener
+
+        stream
+      end
+    end
+
+    # Raised when an aggregate has been found but it was marked for deletion
+    class AggregateDeletedError < Repository::AggregateNotFoundError; end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Synapse
+  module EventSourcing
+    # Event stream decorator that simply counts each event that is retrieved from a delegate stream
+    class CountingEventStream < Domain::DomainEventStream
+      extend Forwardable
+
+      # @param [DomainEventStream] delegate
+      # @param [Atomic] counter
+      # @return [undefined]
+      def initialize(delegate, counter)
+        @delegate = delegate
+        @counter = counter
+      end
+
+      # @return [DomainEventMessage]
+      def next_event
+        next_event = @delegate.next_event
+
+        @counter.update do |value|
+          value = value.next
+        end
+
+        next_event
+      end
+
+      # Delegate un-decorated domain event stream operations
+      def_delegators :@delegate, :end?, :peek
+    end
+
+    # Event stream decorator that counts each event retrieved from the delegate stream and
+    # registers a listener with the current unit of work that can trigger a snapshot after the
+    # unit of work has been cleaned up
+    class TriggeringEventStream < CountingEventStream
+      # @param [DomainEventStream] delegate
+      # @param [Atomic] counter
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @param [EventCountSnapshotTrigger] trigger
+      # @return [undefined]
+      def initialize(delegate, counter, type_identifier, aggregate_id, trigger)
+        super delegate, counter
+
+        @type_identifier = type_identifier
+        @aggregate_id = aggregate_id
+        @trigger = trigger
+      end
+
+      # @return [Boolean]
+      def end?
+        the_end = @delegate.end?
+
+        if the_end
+          listener = SnapshotUnitOfWorkListener.new @type_identifier, @aggregate_id, @counter, @trigger
+
+          unit = @trigger.unit_provider.current
+          unit.register_listener listener
+
+          @trigger.clear_counter @aggregate_id
+        end
+
+        the_end
+      end
+    end
+
+    # Unit of work listener that is used to trigger snapshots after a unit of work has been cleaned up
+    class SnapshotUnitOfWorkListener < UnitOfWork::UnitOfWorkListener
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @param [Atomic] counter
+      # @param [EventCountSnapshotTrigger] trigger
+      # @return [undefined]
+      def initialize(type_identifier, aggregate_id, counter, trigger)
+        @type_identifier = type_identifier
+        @aggregate_id = aggregate_id
+        @trigger = trigger
+        @counter = counter
+      end
+
+      # @param [UnitOfWork] unit
+      # @return [undefined]
+      def on_cleanup(unit)
+        @trigger.trigger_snapshot @type_identifier, @aggregate_id, @counter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+require 'atomic'
+
+module Synapse
+  module EventSourcing
+    # Snapshot trigger that counts the number of events between snapshots to decide when to
+    # schedule the next snapshot
+    class EventCountSnapshotTrigger < EventStreamDecorator
+      # Default threshold for a snapshot to be scheduled
+      # @return [Integer]
+      DEFAULT_THRESHOLD = 50
+
+      # @return [SnapshotTaker]
+      attr_reader :snapshot_taker
+
+      # @return [Integer] The number of events between snapshots
+      attr_accessor :threshold
+
+      # @return [UnitOfWorkProvider]
+      attr_reader :unit_provider
+
+      # @param [SnapshotTaker] snapshot_taker
+      # @param [UnitOfWorkProvider] unit_provider
+      # @return [undefined]
+      def initialize(snapshot_taker, unit_provider)
+        @counters = Hash.new
+        @lock = Mutex.new
+        @logger = Logging.logger.new self.class
+        @threshold = DEFAULT_THRESHOLD
+
+        @snapshot_taker = snapshot_taker
+        @unit_provider = unit_provider
+      end
+
+      # If the event threshold has been reached for the aggregate with the given identifier, this
+      # will cause a snapshot to be scheduled
+      #
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @param [Atomic] counter
+      # @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]
+
+          @snapshot_taker.schedule_snapshot type_identifier, aggregate_id
+          counter.value = 1
+        end
+      end
+
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @param [DomainEventStream] stream
+      # @return [DomainEventStream]
+      def decorate_for_read(type_identifier, aggregate_id, stream)
+        CountingEventStream.new(stream, counter_for(aggregate_id))
+      end
+
+      # @param [String] type_identifier
+      # @param [AggregateRoot] aggregate
+      # @param [DomainEventStream] stream
+      # @return [DomainEventStream]
+      def decorate_for_append(type_identifier, aggregate, stream)
+        TriggeringEventStream.new(stream, counter_for(aggregate.id), type_identifier, aggregate.id, self)
+      end
+
+      # Returns the event counter for the aggregate with the given identifier
+      #
+      # @param [Object] aggregate_id
+      # @return [Atomic]
+      def counter_for(aggregate_id)
+        @lock.synchronize do
+          if @counters.has_key? aggregate_id
+            @counters.fetch aggregate_id
+          else
+            @counters.store aggregate_id, Atomic.new(0)
+          end
+        end
+      end
+
+      # Clears the event counter for the aggregate with the given identifier
+      #
+      # @param [Object] aggregate_id
+      # @return [undefined]
+      def clear_counter(aggregate_id)
+        @lock.synchronize do
+          @counters.delete aggregate_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Synapse
+  module EventSourcing
+    # Represents a mechanism for creating snapshot events for aggregates
+    #
+    # Implementations can choose whether to snapshot the aggregate in the calling thread or
+    # asynchronously, though it is typically done asynchronously.
+    #
+    # @abstract
+    class SnapshotTaker
+      # Schedules a snapshot to be taken for an aggregate of the given type and with the given
+      # identifier
+      #
+      # @abstract
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @return [undefined]
+      def schedule_snapshot(type_identifier, aggregate_id); end
+    end
+
+    # Snapshot taker that uses EventMachine to defer scheduling of snapshots
+    class DeferredSnapshotTaker < SnapshotTaker
+      # @param [SnapshotTaker] delegate
+      # @return [undefined]
+      def initialize(delegate)
+        @delegate = delegate
+      end
+
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @return [undefined]
+      def schedule_snapshot(type_identifier, aggregate_id)
+        EventMachine.defer do
+          @delegate.schedule_snapshot type_identifier, aggregate_id
+        end
+      end
+    end
+
+    # Snapshot taker that uses the actual aggregate and its state to create a snapshot event
+    class AggregateSnapshotTaker < SnapshotTaker
+      # @param [SnapshotEventStore] event_store
+      # @return [undefined]
+      def initialize(event_store)
+        @aggregate_factories = Hash.new
+        @event_store = event_store
+      end
+
+      # @param [AggregateFactory] factory
+      # @return [undefined]
+      def register_factory(factory)
+        @aggregate_factories.store factory.type_identifier, factory
+      end
+
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @return [undefined]
+      def schedule_snapshot(type_identifier, aggregate_id)
+        stream = @event_store.read_events type_identifier, aggregate_id
+        factory = @aggregate_factories.fetch type_identifier
+
+        aggregate = factory.create_aggregate aggregate_id, stream.peek
+        aggregate.initialize_from_stream stream
+
+        snapshot = Domain::DomainEventMessage.build do |builder|
+          builder.payload = aggregate
+          builder.aggregate_id = aggregate.id
+          builder.sequence_number = aggregate.version
+        end
+
+        @event_store.append_snapshot_event type_identifier, snapshot
+      end
+    end
+  end
+end

data/lib/synapse/event_sourcing/storage_listener.rb

@@ -0,0 +1,34 @@
+module Synapse
+  module EventSourcing
+    # Storage listener that commits aggregates to an event store
+    class EventSourcedStorageListener < UnitOfWork::StorageListener
+      # @param [EventStore] event_store
+      # @param [LockManager] lock_manager
+      # @param [Array] stream_decorators
+      # @param [String] type_identifier
+      # @return [undefined]
+      def initialize(event_store, lock_manager, stream_decorators, type_identifier)
+        @event_store = event_store
+        @lock_manager = lock_manager
+        @stream_decorators = stream_decorators
+        @type_identifier = type_identifier
+      end
+
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def store(aggregate)
+        if aggregate.version and !@lock_manager.validate_lock aggregate
+          raise Repository::ConflictingModificationError
+        end
+
+        stream = aggregate.uncommitted_events
+        @stream_decorators.reverse_each do |decorator|
+          stream = decorator.decorate_for_append @type_identifier, aggregate, stream
+        end
+
+        @event_store.append_events @type_identifier, stream
+        aggregate.mark_committed
+      end
+    end
+  end
+end

data/lib/synapse/event_sourcing/stream_decorator.rb

@@ -0,0 +1,25 @@
+module Synapse
+  module EventSourcing
+    # Represents a mechanism for decorating event streams when aggregates are read or appended
+    # @abstract
+    class EventStreamDecorator
+      # Decorates an event stream when it is read from the event store
+      #
+      # @abstract
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @param [DomainEventStream] stream
+      # @return [DomainEventStream]
+      def decorate_for_read(type_identifier, aggregate_id, stream); end
+
+      # Decorates an event stream when it is appended to the event store
+      #
+      # @abstract
+      # @param [String] type_identifier
+      # @param [AggregateRoot] aggregate
+      # @param [DomainEventStream] stream
+      # @return [DomainEventStream]
+      def decorate_for_append(type_identifier, aggregate, stream); end
+    end
+  end
+end

data/lib/synapse/event_store/errors.rb

@@ -0,0 +1,16 @@
+module Synapse
+  module EventStore
+    # Raised when an error occurs when reading or appending events to an event store
+    class EventStoreError < NonTransientError; end
+
+    # Raised when a stream could not be found for a specific aggregate
+    class StreamNotFoundError < EventStoreError
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @return [undefined]
+      def initialize(type_identifier, aggregate_id)
+        super 'Stream not found for [%s] [%s]' % [type_identifier, aggregate_id]
+      end
+    end
+  end
+end