synapse-core 0.1.2

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

@@ -0,0 +1,13 @@
+module Synapse
+  module Serialization
+    # Convenience implementation of serialized object containing metadata
+    class SerializedMetadata < SerializedObject
+      # @param [Object] content
+      # @param [Class] content_type
+      # @return [undefined]
+      def initialize(content, content_type)
+        super(content, content_type, SerializedType.new(Hash.to_s, nil))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Synapse
+  module Serialization
+    # Contract for message implementations that are aware of the serialization component and
+    # can provide optimization for the serialization process
+    module SerializationAware
+      # @param [Serializer] serializer
+      # @param [Class] expected_type
+      # @return [SerializedObject]
+      def serialize_metadata(serializer, expected_type); end
+
+      # @param [Serializer] serializer
+      # @param [Class] expected_type
+      # @return [SerializedObject]
+      def serialize_payload(serializer, expected_type); end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Synapse
+  module Serialization
+    # Decorator for an event message that adds serialization awareness
+    #
+    # Any serialization that occurs on the metadata or payload of this message will be
+    # cached so that if a message is serialized more than once, the serialization process will
+    # only occur once.
+    class SerializationAwareEventMessage
+      extend Forwardable
+      include SerializationAware
+
+      # @param [EventMessage] message
+      # @return [SerializationAwareEventMessage]
+      def self.decorate(message)
+        if message.is_a? SerializationAware
+          return message
+        end
+
+        self.new message
+      end
+
+      # @param [EventMessage] message
+      # @return [undefined]
+      def initialize(message)
+        @message = message
+        @cache = SerializedObjectCache.new message
+      end
+
+      # @see Message#and_metadata
+      # @param [Hash] additional_metadata
+      # @return [SerializationAwareEventMessage]
+      def and_metadata(additional_metadata)
+        new_message = @message.and_metadata additional_metadata
+        if new_message.equal? @message
+          return self
+        end
+
+        self.class.new new_message
+      end
+
+      # @see Message#with_metadata
+      # @param [Hash] replacement_metadata
+      # @return [SerializationAwareEventMessage]
+      def with_metadata(replacement_metadata)
+        new_message = @message.with_metadata replacement_metadata
+        if new_message.equal? @message
+          return self
+        end
+
+        self.class.new new_message
+      end
+
+      # Delegators for the serialized object cache
+      def_delegators :@cache, :serialize_metadata, :serialize_payload
+
+      # Delegators for message attribute readers
+      def_delegators :@message, :id, :metadata, :payload, :payload_type, :timestamp
+    end
+
+    # Decorator for a domain event message that adds serialization awareness
+    class SerializationAwareDomainEventMessage < SerializationAwareEventMessage
+      # Delegators for domain event specific attribute readers
+      def_delegators :@message, :aggregate_id, :sequence_number
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+module Synapse
+  module Serialization
+    # Serialized representation of a message
+    class SerializedMessage
+      include SerializationAware
+
+      # @return [String]
+      attr_reader :id
+
+      # @return [LazyObject]
+      attr_reader :serialized_metadata
+
+      # @return [LazyObject]
+      attr_reader :serialized_payload
+
+      # @param [String] id
+      # @param [LazyObject] metadata
+      # @param [LazyObject] payload
+      # @return [undefined]
+      def initialize(id, metadata, payload)
+        @id = id
+        @serialized_metadata = metadata
+        @serialized_payload = payload
+      end
+
+      # @return [Hash] The deserialized metadata for this message
+      def metadata
+        @serialized_metadata.deserialized
+      end
+
+      # @return [Object] The deserialized payload for this message
+      def payload
+        @serialized_payload.deserialized
+      end
+
+      # @return [Class] The type of payload for this message
+      def payload_type
+        @serialized_payload.type
+      end
+
+      # Returns a copy of this message with the given metadata merged in
+      #
+      # @see Message#and_metadata
+      # @param [Hash] additional_metadata
+      # @return [SerializedMessage]
+      def and_metadata(additional_metadata)
+        if additional_metadata.empty?
+          return self
+        end
+
+        self.class.build do |builder|
+          build_duplicate builder, metadata.merge(additional_metadata)
+        end
+      end
+
+      # Returns a copy of this message with the metadata replaced with the given metadata
+      #
+      # @see Message#with_metadata
+      # @param [Hash] replacement_metadata
+      # @return [SerializedMessage]
+      def with_metadata(replacement_metadata)
+        if @serialized_metadata.deserialized == replacement_metadata
+          return self
+        end
+
+        self.class.build do |builder|
+          build_duplicate builder, replacement_metadata
+        end
+      end
+
+      # @see SerializationAware#serialize_metadata
+      # @param [Serializer] serializer
+      # @param [Class] expected_type
+      # @return [SerializedObject]
+      def serialize_metadata(serializer, expected_type)
+        serialize @serialized_metadata, serializer, expected_type
+      end
+
+      # @see SerializationAware#serialize_payload
+      # @param [Serializer] serializer
+      # @param [Class] expected_type
+      # @return [SerializedObject]
+      def serialize_payload(serializer, expected_type)
+        serialize @serialized_payload, serializer, expected_type
+      end
+
+      # Returns the type of builder that can be used to build this type of message
+      # @return [Class]
+      def self.builder
+        SerializedMessageBuilder
+      end
+
+      # Yields a message builder that can be used to produce a message
+      #
+      # @see SerializedMessageBuilder#build
+      # @yield [SerializedMessageBuilder]
+      # @return [SerializedMessage]
+      def self.build(&block)
+        builder.build(&block)
+      end
+
+    protected
+
+      # Populates a duplicated message with attributes from this message
+      #
+      # @param [SerializedMessageBuilder] builder
+      # @param [Hash] metadata
+      # @return [undefined]
+      def build_duplicate(builder, metadata)
+        builder.id = @id
+        builder.metadata = DeserializedObject.new metadata
+        builder.payload = @serialized_payload
+      end
+
+    private
+
+      # @param [LazyObject] object
+      # @param [Serializer] serializer
+      # @param [Class] expected_type
+      # @return [SerializedObject]
+      def serialize(object, serializer, expected_type)
+        if object.serializer.equal? serializer
+          serialized = object.serialized_object
+          serializer.converter_factory.convert serialized, expected_type
+        else
+          serializer.serialize object.deserialized, expected_type
+        end
+      end
+    end
+
+    # 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
+
+    # Serialized representation of a domain event message
+    class SerializedDomainEventMessage < SerializedEventMessage
+      # @return [Object]
+      attr_reader :aggregate_id
+
+      # @return [Integer]
+      attr_reader :sequence_number
+
+      # @param [String] id
+      # @param [LazyObject] metadata
+      # @param [LazyObject] payload
+      # @param [Time] timestamp
+      # @param [Object] aggregate_id
+      # @param [Integer] sequence_number
+      # @return [undefined]
+      def initialize(id, metadata, payload, timestamp, aggregate_id, sequence_number)
+        super id, metadata, payload, timestamp
+
+        @aggregate_id = aggregate_id
+        @sequence_number = sequence_number
+      end
+
+      # @return [Class]
+      def self.builder
+        SerializedDomainEventMessageBuilder
+      end
+
+    protected
+
+      # @param [SerializedDomainEventMessageBuilder] builder
+      # @param [Hash] metadata
+      # @return [undefined]
+      def build_duplicate(builder, metadata)
+        super
+        builder.aggregate_id = @aggregate_id
+        builder.sequence_number = @sequence_number
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Synapse
+  module Serialization
+    # Message builder capable of producing SerializedMessage instances
+    class SerializedMessageBuilder
+      # @return [String]
+      attr_accessor :id
+
+      # @return [LazyObject]
+      attr_accessor :metadata
+
+      # @return [LazyObject]
+      attr_accessor :payload
+
+      def self.build
+        builder = self.new
+
+        yield builder if block_given?
+
+        builder.build
+      end
+
+      def build
+        SerializedMessage.new @id, @metadata, @payload
+      end
+    end
+
+    # 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
+      end
+    end
+
+    # Message builder capable of producing SerializedDomainEventMessage instances
+    class SerializedDomainEventMessageBuilder < SerializedEventMessageBuilder
+      # @return [Object]
+      attr_accessor :aggregate_id
+
+      # @return [Integer]
+      attr_accessor :sequence_number
+
+      # @param [SerializedDomainEventData] data
+      # @param [Serializer] serializer
+      # @return [undefined]
+      def from_data(data, serializer)
+        @id = data.id
+        @metadata ||= LazyObject.new data.metadata, serializer
+        @payload ||= LazyObject.new data.payload, serializer
+        @timestamp = data.timestamp
+        @aggregate_id = data.aggregate_id
+        @sequence_number = data.sequence_number
+      end
+
+      # @return [SerializedDomainEventMessage]
+      def build
+        SerializedDomainEventMessage.new @id, @metadata, @payload, @timestamp, @aggregate_id, @sequence_number
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Synapse
+  module Serialization
+    # Thread-safe cache for messages to store serialized metadata and payload
+    # @api private
+    class SerializedObjectCache
+      # @param [Message] message
+      # @return [undefined]
+      def initialize(message)
+        @message = message
+        @lock = Mutex.new
+        @metadata_cache = Hash.new
+        @payload_cache = Hash.new
+      end
+
+      # @param [Serializer] serializer
+      # @param [Class] expected_type
+      # @return [SerializedObject]
+      def serialize_metadata(serializer, expected_type)
+        serialize @message.metadata, @metadata_cache, serializer, expected_type
+      end
+
+      # @param [Serializer] serializer
+      # @param [Class] expected_type
+      # @return [SerializedObject]
+      def serialize_payload(serializer, expected_type)
+        serialize @message.payload, @payload_cache, serializer, expected_type
+      end
+
+    private
+
+      # @param [Object] object
+      # @param [Hash<Serializer, SerializedObject>] cache
+      # @param [Serializer] serializer
+      # @param [Class] expected_type
+      # @return [SerializedObject]
+      def serialize(object, cache, serializer, expected_type)
+        @lock.synchronize do
+          serialized = cache[serializer]
+          if serialized
+            serializer.converter_factory.convert serialized, expected_type
+          else
+            serialized = serializer.serialize object, expected_type
+            cache[serializer] = serialized
+            serialized
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Synapse
+  module Serialization
+    # Serializer that provides convenience methods for serializing messages and adds support
+    # for optimizing the serialization process
+    class MessageSerializer
+      extend Forwardable
+
+      # @param [Serializer] serializer
+      # @return [undefined]
+      def initialize(serializer)
+        @serializer = serializer
+      end
+
+      # Returns the serialized metadata for the given message in the expected type, optimizing
+      # the serialization, if possible
+      #
+      # @param [Message] message
+      # @param [Class] expected_type
+      # @return [SerializedObject]
+      def serialize_metadata(message, expected_type)
+        if message.is_a? SerializationAware
+          message.serialize_metadata @serializer, expected_type
+        else
+          serialize message.metadata, expected_type
+        end
+      end
+
+      # Returns the serialized payload for the given message in the expected type, optimizing
+      # the serialization, if possible
+      #
+      # @param [Message] message
+      # @param [Class] expected_type
+      # @return [SerializedObject]
+      def serialize_payload(message, expected_type)
+        if message.is_a? SerializationAware
+          message.serialize_payload @serializer, expected_type
+        else
+          serialize message.payload, expected_type
+        end
+      end
+
+      # Delegators for regular serializer methods
+      def_delegators :@serializer, :converter_factory, :serialize, :deserialize,
+        :can_serialize_to?, :class_for, :type_for
+    end
+  end
+end