synapse-core 0.5.3 → 0.5.4

data/lib/synapse/event_sourcing/repository.rb

@@ -31,16 +31,6 @@ module Synapse
         @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
@@ -93,16 +83,33 @@ module Synapse
         end
       end
 
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def delete_aggregate(aggregate)
+        save_aggregate aggregate
+      end
+
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def save_aggregate(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
+
       # @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

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

@@ -2,11 +2,10 @@ module Synapse
   module EventSourcing
     # 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)
+      def initialize
+        super
         @aggregate_factories = Hash.new
-        @event_store = event_store
       end
 
       # @param [AggregateFactory] factory
@@ -15,23 +14,23 @@ module Synapse
         @aggregate_factories.store factory.type_identifier, factory
       end
 
+    protected
+
       # @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
+      # @param [DomainEventStream] stream
+      # @return [DomainEventMessage]
+      def create_snapshot(type_identifier, aggregate_id, stream)
         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|
+        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 # AggregateSnapshotTaker
   end # EventSourcing

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

@@ -12,6 +12,7 @@ module Synapse
     # Snapshot policy that takes a snapshot if the number of events committed in an aggregate since
     # the last snapshot goes over the configured threshold
     class IntervalSnapshotPolicy < SnapshotPolicy
+      # @param [Integer] threshold
       # @return [undefined]
       def initialize(threshold)
         @threshold = threshold

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

@@ -7,14 +7,43 @@ module Synapse
     #
     # @abstract
     class SnapshotTaker
+      # @return [SnapshotEventStore]
+      attr_accessor :event_store
+
+      # @return [Executor]
+      attr_accessor :executor
+
+      # @return [undefined]
+      def initialize
+        @executor = DirectExecutor.new
+      end
+
       # 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
+      def schedule_snapshot(type_identifier, aggregate_id)
+        @executor.execute do
+          stream = @event_store.read_events type_identifier, aggregate_id
+          first_sequence_number = stream.peek.sequence_number
+          snapshot = create_snapshot type_identifier, aggregate_id, stream
+
+          if snapshot and snapshot.sequence_number > first_sequence_number
+            @event_store.append_snapshot_event type_identifier, snapshot
+          end
+        end
+      end
+
+    protected
+
+      # @abstract
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @param [DomainEventStream] stream
+      # @return [DomainEventMessage]
+      def create_snapshot(type_identifier, aggregate_id, stream); end
     end # SnapshotTaker
   end # EventSourcing
 end

data/lib/synapse/repository/repository.rb

@@ -48,11 +48,19 @@ module Synapse
       # @return [Class]
       def aggregate_type; end
 
-      # Returns the listener that handles aggregate storage
+      # Deletes the given aggregate from the underlying storage mechanism
       #
       # @abstract
-      # @return [StorageListener]
-      def storage_listener; end
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def delete_aggregate(aggregate); end
+
+      # Saves the given aggregate using the underlying storage mechanism
+      #
+      # @abstract
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def save_aggregate(aggregate); end
 
       # Asserts that an aggregate being added is compatible with this repository and is newly
       # created
@@ -89,7 +97,13 @@ module Synapse
       # @param [AggregateRoot] aggregate
       # @return [undefined]
       def register_aggregate(aggregate)
-        current_unit.register_aggregate aggregate, @event_bus, storage_listener
+        current_unit.register_aggregate aggregate, @event_bus do |aggregate|
+          if aggregate.deleted?
+            delete_aggregate aggregate
+          else
+            save_aggregate aggregate
+          end
+        end
       end
 
       # Registers the given unit of work listener with the current unit of work

data/lib/synapse/repository/simple_repository.rb

@@ -14,9 +14,7 @@ module Synapse
       # @return [undefined]
       def initialize(lock_manager, aggregate_type)
         super lock_manager
-
         @aggregate_type = aggregate_type
-        @storage_listener = SimpleStorageListener.new
       end
 
     protected
@@ -29,7 +27,7 @@ module Synapse
       # @param [Integer] expected_version
       # @return [AggregateRoot]
       def perform_load(aggregate_id, expected_version)
-        # Most ORMs that I can think of use #find like this -- no need for orm_adapter or anything 
+        # Most ORMs that I can think of use #find like this -- no need for orm_adapter or anything
         # crazy like that
         aggregate = @aggregate_type.find aggregate_id
         aggregate.tap do
@@ -46,24 +44,17 @@ module Synapse
         @aggregate_type
       end
 
-      # @return [StorageListener]
-      def storage_listener
-        @storage_listener
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def delete_aggregate(aggregate)
+        aggregate.destroy
       end
-    end # SimpleRepository
 
-    # Storage listener that simply calls #save on the aggregate, unless it has been marked for 
-    # deletion. In that case, then the #destroy method is called instead.
-    class SimpleStorageListener < UnitOfWork::StorageListener
       # @param [AggregateRoot] aggregate
       # @return [undefined]
-      def store(aggregate)
-        if aggregate.deleted?
-          aggregate.destroy
-        else
-          aggregate.save
-        end
+      def save_aggregate(aggregate)
+        aggregate.save
       end
-    end # SimpleStorageListener
+    end # SimpleRepository
   end # Repository
 end

data/lib/synapse/serialization/converter.rb

@@ -34,6 +34,6 @@ module Synapse
       # @param [Object] original
       # @return [Object]
       def convert_content(original); end
-    end
-  end
+    end # Converter
+  end # Serialization
 end

data/lib/synapse/serialization/converter/identity.rb

@@ -24,6 +24,6 @@ module Synapse
       def convert_content(original)
         original
       end
-    end
-  end
+    end # IdentityConverter
+  end # Serialization
 end

data/lib/synapse/serialization/converter/json.rb

@@ -13,7 +13,7 @@ module Synapse
       def convert_content(original)
         JSON.parse original, @options
       end
-    end
+    end # JsonToObjectConverter
 
     # Converter that converts a Ruby data structure into a JSON string
     class ObjectToJsonConverter
@@ -26,6 +26,6 @@ module Synapse
       def convert_content(original)
         JSON.generate original, @options
       end
-    end
-  end
+    end # ObjectToJsonConverter
+  end # Serialization
 end

data/lib/synapse/serialization/converter/ox.rb

@@ -13,7 +13,7 @@ module Synapse
       def convert_content(original)
         Ox.dump original, @options
       end
-    end
+    end # OxDocumentToXmlConverter
 
     # Converter that converts an XML string into an Ox document
     class XmlToOxDocumentConverter
@@ -26,6 +26,6 @@ module Synapse
       def convert_content(original)
         Ox.load original, @options
       end
-    end
-  end
+    end # XmlToOxDocumentConverter
+  end # Serialization
 end

data/lib/synapse/serialization/message/metadata.rb

@@ -8,6 +8,6 @@ module Synapse
       def initialize(content, content_type)
         super(content, content_type, SerializedType.new(Hash.to_s, nil))
       end
-    end
-  end
+    end # SerializedMetadata
+  end # Serialization
 end

data/lib/synapse/serialization/message/serialization_aware.rb

@@ -12,6 +12,6 @@ module Synapse
       # @param [Class] expected_type
       # @return [SerializedObject]
       def serialize_payload(serializer, expected_type); end
-    end
-  end
+    end # SerializationAware
+  end # Serialization
 end

data/lib/synapse/serialization/message/serialized_message.rb

@@ -13,14 +13,19 @@ module Synapse
       # @return [LazyObject]
       attr_reader :serialized_payload
 
+      # @return [Time]
+      attr_reader :timestamp
+
       # @param [String] id
       # @param [LazyObject] metadata
       # @param [LazyObject] payload
+      # @param [Time] timestamp
       # @return [undefined]
-      def initialize(id, metadata, payload)
+      def initialize(id, metadata, payload, timestamp)
         @id = id
         @serialized_metadata = metadata
         @serialized_payload = payload
+        @timestamp = timestamp
       end
 
       # @return [Hash] The deserialized metadata for this message
@@ -106,6 +111,7 @@ module Synapse
         builder.id = @id
         builder.metadata = DeserializedObject.new metadata
         builder.payload = @serialized_payload
+        builder.timestamp = @timestamp
       end
 
     private
@@ -126,33 +132,10 @@ module Synapse
 
     # Serialized representation of an event message
     class SerializedEventMessage < SerializedMessage
-      # @return [Time]
-      attr_reader :timestamp
-
-      # @param [String] id
-      # @param [LazyObject] metadata
-      # @param [LazyObject] payload
-      # @param [Time] timestamp
-      # @return [undefined]
-      def initialize(id, metadata, payload, timestamp)
-        super id, metadata, payload
-        @timestamp = timestamp
-      end
-
       # @return [Class]
       def self.builder
         SerializedEventMessageBuilder
       end
-
-    protected
-
-      # @param [SerializedEventMessageBuilder] builder
-      # @param [Hash] metadata
-      # @return [undefined]
-      def build_duplicate(builder, metadata)
-        super
-        builder.timestamp = @timestamp
-      end
     end # SerializedEventMessage
 
     # Serialized representation of a domain event message

data/lib/synapse/serialization/message/serialized_message_builder.rb

@@ -11,6 +11,9 @@ module Synapse
       # @return [LazyObject]
       attr_accessor :payload
 
+      # @return [Time]
+      attr_accessor :timestamp
+
       def self.build
         builder = self.new
 
@@ -20,15 +23,12 @@ module Synapse
       end
 
       def build
-        SerializedMessage.new @id, @metadata, @payload
+        SerializedMessage.new @id, @metadata, @payload, @timestamp
       end
     end # SerializedMessageBuilder
 
     # Message builder capable of producing SerializedEventMessage instances
     class SerializedEventMessageBuilder < SerializedMessageBuilder
-      # @return [Time]
-      attr_accessor :timestamp
-
       # @return [SerializedEventMessage]
       def build
         SerializedEventMessage.new @id, @metadata, @payload, @timestamp

data/lib/synapse/uow.rb

@@ -3,6 +3,5 @@ require 'synapse/uow/listener'
 require 'synapse/uow/listener_collection'
 require 'synapse/uow/nesting'
 require 'synapse/uow/provider'
-require 'synapse/uow/storage_listener'
 require 'synapse/uow/transaction_manager'
 require 'synapse/uow/uow'

data/lib/synapse/uow/nesting.rb

@@ -225,7 +225,7 @@ module Synapse
       def stop
         @started = false
       end
-    end
+    end # NestableUnitOfWork
 
     # Listener that allows a nested unit of work to properly operate within in a unit of
     # work that is not aware of nesting
@@ -264,6 +264,6 @@ module Synapse
       def on_cleanup(outer_unit)
         @inner_unit.perform_cleanup
       end
-    end # NestableUnitOfWork
+    end # OuterCommitUnitOfWorkListener
   end # UnitOfWork
 end

data/lib/synapse/uow/uow.rb

@@ -34,7 +34,7 @@ module Synapse
       # This unit of work adds an event listener to the aggregate so that any events generated
       # are published to the given event bus when this unit of work is committed.
       #
-      # The provided storage listener is used to commit the aggregate to its respective
+      # The provided storage callback is used to commit the aggregate to its respective
       # underlying storage mechanism.
       #
       # If there is already an aggregate registered with this unit of work of the same type
@@ -42,23 +42,22 @@ module Synapse
       # aggregate.
       #
       # @api public
+      # @yield [AggregateRoot] Deferred until the aggregate is stored
       # @param [AggregateRoot] aggregate
       # @param [EventBus] event_bus
-      # @param [StorageListener] storage_listener
+      # @param [Proc] storage_callback
       # @return [AggregateRoot]
-      def register_aggregate(aggregate, event_bus, storage_listener)
+      def register_aggregate(aggregate, event_bus, &storage_callback)
         similar = find_similar_aggregate aggregate
-        if similar
-          return similar
+        return similar if similar
+
+        aggregate.add_registration_listener do |event|
+          publish_event event, event_bus
         end
 
-        aggregate.tap do
-          aggregate.add_registration_listener do |event|
-            publish_event event, event_bus
-          end
+        @aggregates.store aggregate, storage_callback
 
-          @aggregates.store aggregate, storage_listener
-        end
+        aggregate
       end
 
       # Buffers an event for publication to the given event bus until this unit of work is
@@ -146,8 +145,8 @@ module Synapse
 
       # @return [undefined]
       def store_aggregates
-        @aggregates.each_pair do |aggregate, storage_listener|
-          storage_listener.store aggregate
+        @aggregates.each_pair do |aggregate, storage_callback|
+          storage_callback.call aggregate
         end
         @aggregates.clear
       end