synapse-core 0.1.2

data/lib/synapse/serialization/revision_resolver.rb

@@ -0,0 +1,30 @@
+module Synapse
+  module Serialization
+    # Represents a mechanism for determining the revision of a payload being serialized
+    # @abstract
+    class RevisionResolver
+      # Determines the revision of the given payload type
+      #
+      # @abstract
+      # @param [Class] payload_type
+      # @return [String] The revision of the given payload type
+      def revision_of(payload_type); end
+    end
+
+    # Implementation of a revision resolver that returns a fixed value. This could be an
+    # application version number, for example
+    class FixedRevisionResolver < RevisionResolver
+      # @param [String] revision
+      # @return [undefined]
+      def initialize(revision)
+        @revision = revision
+      end
+
+      # @param [Class] payload_type
+      # @return [String] Returns the fixed revision
+      def revision_of(payload_type)
+        @revision.to_s
+      end
+    end
+  end
+end

data/lib/synapse/serialization/serialized_object.rb

@@ -0,0 +1,37 @@
+module Synapse
+  module Serialization
+    class SerializedObject
+      # @return [Object]
+      attr_reader :content
+
+      # @return [Class]
+      attr_reader :content_type
+
+      # @return [SerializedType]
+      attr_reader :type
+
+      # @param [Object] content
+      # @param [Class] content_type
+      # @param [SerializedType] type
+      # @return [undefined]
+      def initialize(content, content_type, type)
+        @content = content
+        @content_type = content_type
+        @type = type
+      end
+
+      def ==(other)
+        self.class === other and
+          other.content == @content and
+          other.content_type == @content_type and
+          other.type == @type
+      end
+
+      alias eql? ==
+
+      def hash
+        @content.hash ^ @content_type.hash ^ @type.hash
+      end
+    end
+  end
+end

data/lib/synapse/serialization/serialized_type.rb

@@ -0,0 +1,31 @@
+module Synapse
+  module Serialization
+    class SerializedType
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :revision
+
+      # @param [String] name
+      # @param [String] revision
+      # @return [undefined]
+      def initialize(name, revision = nil)
+        @name = name
+        @revision = revision
+      end
+
+      def ==(other)
+        self.class === other and
+          other.name == @name and
+          other.revision == @revision
+      end
+
+      alias eql? ==
+
+      def hash
+        @name.hash ^ @revision.hash
+      end
+    end
+  end
+end

data/lib/synapse/serialization/serializer.rb

@@ -0,0 +1,98 @@
+module Synapse
+  module Serialization
+    # Represents a mechanism for serializing and deserializing objects
+    # @abstract
+    class Serializer
+      # @return [ConverterFactory]
+      attr_accessor :converter_factory
+
+      # @return [RevisionResolver]
+      attr_accessor :revision_resolver
+
+      def initialize
+        @converter_factory = ConverterFactory.new
+      end
+
+      # @param [Object] object
+      # @param [Class] representation_type
+      # @return [SerializedObject]
+      def serialize(object, representation_type)
+        content = perform_serialize(object)
+        content = convert(content, native_content_type, representation_type)
+        type = type_for(object.class)
+
+        SerializedObject.new(content, representation_type, type)
+      end
+
+      # @param [SerializedObject] serialized_object
+      # @return [Object]
+      def deserialize(serialized_object)
+        content = convert(serialized_object.content, serialized_object.content_type, native_content_type)
+        type = class_for(serialized_object.type)
+
+        perform_deserialize(content, type)
+      end
+
+      # @param [Class] representation_type
+      # @return [Boolean]
+      def can_serialize_to?(representation_type)
+        converter_factory.has_converter?(String, representation_type)
+      end
+
+      # @param [SerializedType] serialized_type
+      # @return [Class]
+      def class_for(serialized_type)
+        begin
+          serialized_type.name.constantize
+        rescue
+          raise UnknownSerializedTypeError, 'Unknown serialized type %s' % serialized_type.name
+        end
+      end
+
+      # @param [Class] type
+      # @return [SerializedType]
+      def type_for(type)
+        if @revision_resolver
+          SerializedType.new(type.to_s, @revision_resolver.revision_of(type))
+        else
+          SerializedType.new(type.to_s)
+        end
+      end
+
+    protected
+
+      # Serializes the given Ruby object
+      #
+      # @abstract
+      # @param [Object] content The original Ruby object to serialize
+      # @return [Object] Should be in the native content type of the serializer
+      def perform_serialize(content); end
+
+      # Deserializes the given serialized content into the given Ruby type
+      #
+      # @abstract
+      # @param [Object] content Should be in the native content type of the serializer
+      # @param [Class] type The class type to be deserialized into
+      # @return [Object] The deserialized object
+      def perform_deserialize(content, type); end
+
+      # Returns the native content type that the serializer works with
+      #
+      # @abstract
+      # @return [Class]
+      def native_content_type; end
+
+    private
+
+      # Converts the given content from the given source type to the given target type
+      #
+      # @param [Object] original
+      # @param [Class] source_type
+      # @param [Class] target_type
+      # @return [Object]
+      def convert(original, source_type, target_type)
+        converter_factory.converter(source_type, target_type).convert_content(original)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Synapse
+  module Serialization
+    # Implementation of a serializer that uses the built-in marshaling library
+    #
+    # Note that this serializer is not necessarily the fastest serializer available, nor is it
+    # flexible. Output is binary and difficult to modify, which means upcasting is not possible
+    # when using this serializer.
+    class MarshalSerializer < Serializer
+      # This serializer doesn't provide any configuration options
+
+    protected
+
+      # @param [Object] content
+      # @return [Object]
+      def perform_serialize(content)
+        Marshal.dump content
+      end
+
+      # @param [Object] content
+      # @param [Class] type
+      # @return [Object]
+      def perform_deserialize(content, type)
+        Marshal.load content
+      end
+
+      # @return [Class]
+      def native_content_type
+        String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'oj'
+
+module Synapse
+  module Serialization
+    # Implementation of a serializer that uses the Optimized JSON (Oj) marshaling library
+    class OjSerializer < Serializer
+      # @return [Hash] Options that will be passed to the Oj dump method
+      attr_accessor :serialize_options
+
+      # @return [Hash] Options that will be passed to the Oj load method
+      attr_accessor :deserialize_options
+
+    protected
+
+      # @param [Object] content
+      # @return [Object]
+      def perform_serialize(content)
+        Oj.dump content, @serialize_options
+      end
+
+      # @param [Object] content
+      # @param [Class] type
+      # @return [Object]
+      def perform_deserialize(content, type)
+        Oj.load content, @deserialize_options
+      end
+
+      # @return [Class]
+      def native_content_type
+        String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'ox'
+
+module Synapse
+  module Serialization
+    # Implementation of a serializer that uses the Optimized XML (Ox) marshaling library
+    class OxSerializer < Serializer
+      # @return [Hash] Options that will be passed to the Ox dump method
+      attr_accessor :serialize_options
+
+    protected
+
+      # @param [Object] content
+      # @return [Object]
+      def perform_serialize(content)
+        Ox.dump content, @serialize_options
+      end
+
+      # @param [Object] content
+      # @param [Class] type
+      # @return [Object]
+      def perform_deserialize(content, type)
+        Ox.parse_obj content
+      end
+
+      # @return [Class]
+      def native_content_type
+        String
+      end
+    end
+  end
+end

data/lib/synapse/uow/factory.rb

@@ -0,0 +1,28 @@
+module Synapse
+  module UnitOfWork
+    # Factory that creates and configures new unit of work instances
+    class UnitOfWorkFactory
+      # @return [TransactionManager]
+      attr_accessor :transaction_manager
+
+      # @param [UnitOfWorkProvider] provider
+      # @return [undefined]
+      def initialize(provider)
+        @provider = provider
+      end
+
+      # Creates and starts a unit of work
+      # @return [UnitOfWork]
+      def create
+        unit = UnitOfWork.new @provider
+
+        if @transaction_manager
+          unit.transaction_manager = @transaction_manager
+        end
+
+        unit.start
+        unit
+      end
+    end
+  end
+end

data/lib/synapse/uow/listener.rb

@@ -0,0 +1,79 @@
+module Synapse
+  module UnitOfWork
+    # Listener that is registered to a unit of work and is notified of state changes
+    # @abstract
+    class UnitOfWorkListener
+      # Invoked when the unit of work has been started
+      #
+      # @param [UnitOfWork] unit
+      # @return [undefined]
+      def on_start(unit); end
+
+      # Invoked when an event is registered for publication when the unit of work is committed
+      #
+      # Listeners may alter event information. Note that the listener must ensure the functional
+      # meaning of the message does not change. Typically, this is done only by modifying the
+      # metadata of the message.
+      #
+      # @param [UnitOfWork] unit
+      # @param [EventMessage] event
+      # @return [EventMessage]
+      def on_event_registered(unit, event)
+        event
+      end
+
+      # Invoked before aggregates are committed, and before any events are published
+      #
+      # This phase can be used to do validation or any other activity that should be able to
+      # prevent event publication in certain circumstances.
+      #
+      # @param [UnitOfWork] unit
+      # @param [Array<AggregateRoot>] aggregates
+      # @param [Hash<EventBus, Array>] events
+      # @return [undefined]
+      def on_prepare_commit(unit, aggregates, events); end
+
+      # Invoked before the transaction bound to this unit of work is committed, but after all
+      # other commit activities (publication of events and storage of aggregates) are performed
+      #
+      # This gives a resource manager the opportunity to take actions that must be part of the
+      # same transaction. Note that this method is only invoked if the unit of work is bound
+      # to a transaction.
+      #
+      # @param [UnitOfWork] unit
+      # @param [Object] transaction
+      # @return [undefined]
+      def on_prepare_transaction_commit(unit, transaction); end
+
+      # Invoked when the unit of work is committed
+      #
+      # At this point, any registered aggregates have been stored and any registered events have
+      # been scheduled for publication. When processing of this method causes an exception, the
+      # unit of work may choose to rollback.
+      #
+      # @param [UnitOfWork] unit
+      # @return [undefined]
+      def after_commit(unit); end
+
+      # Invoked when the unit of work is rolled back
+      #
+      # Alternatively, the unit of work may choose to invoke this method when the commit of the
+      # unit of work failed as well.
+      #
+      # @param [UnitOfWork] unit
+      # @param [Error] cause
+      # @return [undefined]
+      def on_rollback(unit, cause = nil); end
+
+      # Invoked while a unit of work is being cleaned up
+      #
+      # This gives listeners the opportunity to release resources that might have been acquired
+      # during commit or rollback operations, such as locks. This method is always called after all
+      # listeners have been notified of a commit or rollback operation.
+      #
+      # @param [UnitOfWork] unit
+      # @return [undefined]
+      def on_cleanup(unit); end
+    end
+  end
+end

data/lib/synapse/uow/listener_collection.rb

@@ -0,0 +1,93 @@
+module Synapse
+  module UnitOfWork
+    # Represents a mechanism for notifying registered listeners in a specific order of precendence
+    #
+    # When {#on_start}, {#on_event_registered}, {#on_prepare_commit} and
+    # {#on_prepare_transaction_commit} are invoked, the listeners will be notified the order
+    # they were added to this colleciton. When {#after_commit}, {#on_rollback} and {#on_cleanup}
+    # are called, listeners will be notified in the reverse order they were added to this
+    # collection.
+    #
+    # This behavior is particularly useful for an auditing listener, which could log a commit
+    # before any listeners are allowed to do anything, and log that the commit is finished after
+    # all other listeners have finished.
+    class UnitOfWorkListenerCollection < UnitOfWorkListener
+      def initialize
+        @listeners = Array.new
+      end
+
+      # Pushes a unit of work listener onto the end of this collection
+      #
+      # @param [UnitOfWorkListener] listener
+      # @return [undefined]
+      def push(listener)
+        @listeners.push listener
+      end
+
+      alias << push
+
+      # @param [UnitOfWork] unit
+      # @return [undefined]
+      def on_start(unit)
+        @listeners.each do |listener|
+          listener.on_start unit
+        end
+      end
+
+      # @param [UnitOfWork] unit
+      # @param [EventMessage] event
+      # @return [EventMessage]
+      def on_event_registered(unit, event)
+        @listeners.each do |listener|
+          event = listener.on_event_registered unit, event
+        end
+
+        event
+      end
+
+      # @param [UnitOfWork] unit
+      # @param [Array<AggregateRoot>] aggregates
+      # @param [Hash<EventBus, Array>] events
+      # @return [undefined]
+      def on_prepare_commit(unit, aggregates, events)
+        @listeners.each do |listener|
+          listener.on_prepare_commit unit, aggregates, events
+        end
+      end
+
+      # @param [UnitOfWork] unit
+      # @param [Object] transaction
+      # @return [undefined]
+      def on_prepare_transaction_commit(unit, transaction)
+        @listeners.each do |listener|
+          listener.on_prepare_transaction_commit unit, transaction
+        end
+      end
+
+      # @param [UnitOfWork] unit
+      # @return [undefined]
+      def after_commit(unit)
+        @listeners.reverse_each do |listener|
+          listener.after_commit unit
+        end
+      end
+
+      # @param [UnitOfWork] unit
+      # @param [Error] cause
+      # @return [undefined]
+      def on_rollback(unit, cause = nil)
+        @listeners.reverse_each do |listener|
+          listener.on_rollback unit, cause
+        end
+      end
+
+      # @param [UnitOfWork] unit
+      # @return [undefined]
+      def on_cleanup(unit)
+        @listeners.reverse_each do |listener|
+          listener.on_cleanup unit
+        end
+      end
+    end
+  end
+end