synapse-core 0.1.2 → 0.2.0

data/lib/synapse/partitioning/packing/json_unpacker.rb

@@ -0,0 +1,83 @@
+module Synapse
+  module Partitioning
+    # Implementation of a message unpacker that unpacks messages that come off the wire in the
+    # format described by JsonMessagePacker
+    class JsonMessageUnpacker < MessageUnpacker
+      # @param [Serializer] serializer
+      # @return [undefined]
+      def initialize(serializer)
+        @serializer = serializer
+      end
+
+      # @param [String] packed
+      # @return [Message]
+      def unpack_message(message)
+        packed = JSON.load message
+        packed.symbolize_keys!
+
+        message_type = packed.fetch(:message_type).to_sym
+        builder = builder_for(message_type).new
+
+        builder.id = packed.fetch :id
+        builder.metadata = deserialize_metadata packed
+        builder.payload = deserialize_payload packed
+
+        if [:event, :domain_event].include? message_type
+          timestamp = packed.fetch :timestamp
+          builder.timestamp = Time.at timestamp
+        end
+
+        if :domain_event == message_type
+          builder.aggregate_id = packed.fetch :aggregate_id
+          builder.sequence_number = packed.fetch :sequence_number
+        end
+
+        builder.build
+      end
+
+    private
+
+      # Deserializes the metadata of the given packed message
+      #
+      # @param [Hash] packed
+      # @return [Hash]
+      def deserialize_metadata(packed)
+        content = packed.fetch :metadata
+        @serializer.deserialize Serialization::SerializedMetadata.new content, content.class
+      end
+
+      # Deserializes the payload of the given packed message
+      #
+      # @param [Hash] packed
+      # @return [Object]
+      def deserialize_payload(packed)
+        content = packed.fetch :payload
+        name = packed.fetch :payload_type
+        revision = packed.fetch :payload_revision
+
+        serialized_type = Serialization::SerializedType.new name, revision
+        serialized_object = Serialization::SerializedObject.new content, content.class, serialized_type
+
+        @serializer.deserialize serialized_object
+      end
+
+      # Returns the builder type for the given message type
+      #
+      # @raise [ArgumentError] If message type isn't supported by this unpacker
+      # @param [Symbol] type
+      # @return [Class]
+      def builder_for(type)
+        case type
+        when :command
+          Command::CommandMessage.builder
+        when :domain_event
+          Domain::DomainEventMessage.builder
+        when :event
+          Domain::EventMessage.builder
+        else
+          raise ArgumentError, 'Unknown message type'
+        end
+      end
+    end # JsonMessageUnpacker
+  end # Partitioning
+end # Synapse

data/lib/synapse/partitioning/packing.rb

@@ -0,0 +1,27 @@
+module Synapse
+  module Partitioning
+    # Represents a mechanism for packing a message into a string so that it can be either stored
+    # in a file or passed over a transport mechanism to be unpacked at the receiver
+    #
+    # This implementation simply returns the message as-is
+    class MessagePacker
+      # @param [Message] unpacked
+      # @return [String]
+      def pack_message(unpacked)
+        unpacked
+      end
+    end
+
+    # Represents a mechanism for unpacking a message that has been packed for storage in a file
+    # or transport from a producer
+    #
+    # This implementation simply returns the message as-is
+    class MessageUnpacker
+      # @param [String] packed
+      # @return [Message]
+      def unpack_message(packed)
+        packed
+      end
+    end
+  end
+end

data/lib/synapse/partitioning/queue_reader.rb

@@ -0,0 +1,32 @@
+module Synapse
+  module Partitioning
+    # Represents a mechanism for taking messages off a queue and handling the acknowledgement
+    # or rejection of each message
+    #
+    # @abstract
+    class QueueReader
+      # Subscribes the given handler to the queue
+      #
+      # Depending on the implementation, this method may or may not return immediately. It should
+      # be assumed that the method will block until a message is received and then will go back
+      # to blocking after the given callback is invoked.
+      #
+      # @abstract
+      # @yield [MessageReceipt] Receipt of the message taken off the queue
+      # @return [undefined]
+      def subscribe(&handler); end
+
+      # Acknowledges the message, removing it from the original queue
+      #
+      # @param [MessageReceipt] receipt
+      # @return [undefined]
+      def ack_message(receipt); end
+
+      # Attempts to notify the original queue that the message was not processed
+      #
+      # @param [MessageReceipt] receipt
+      # @return [undefined]
+      def nack_message(receipt); end
+    end
+  end
+end

data/lib/synapse/partitioning/queue_writer.rb

@@ -0,0 +1,17 @@
+module Synapse
+  module Partitioning
+    # Represents a mechanism for writing packed messages to a queue
+    # @abstract
+    class QueueWriter
+      # Enqueues the given message
+      #
+      # Depending on the implementation, this method may or may not block until the message has
+      # been enqueued.
+      #
+      # @param [Object] packed
+      # @param [Message] unpacked
+      # @return [undefined]
+      def put_message(packed, unpacked); end
+    end
+  end
+end

data/lib/synapse/partitioning.rb

@@ -0,0 +1,20 @@
+module Synapse
+  module Partitioning
+    extend ActiveSupport::Autoload
+
+    # Optional queues
+    autoload :AMQP
+
+    autoload :MemoryQueueReader
+    autoload :MemoryQueueWriter
+
+    # Optional message packing
+    autoload :JsonMessagePacker, 'synapse/partitioning/packing/json_packer'
+    autoload :JsonMessageUnpacker, 'synapse/partitioning/packing/json_unpacker'
+  end
+end
+
+require 'synapse/partitioning/message_receipt'
+require 'synapse/partitioning/packing'
+require 'synapse/partitioning/queue_reader'
+require 'synapse/partitioning/queue_writer'

data/lib/synapse/process_manager.rb

@@ -0,0 +1,4 @@
+require 'synapse/process_manager/correlation'
+require 'synapse/process_manager/correlation_resolver'
+require 'synapse/process_manager/correlation_set'
+require 'synapse/process_manager/process'

data/lib/synapse/repository/locking.rb

@@ -26,10 +26,9 @@ module Synapse
         begin
           aggregate = perform_load aggregate_id, expected_version
 
-          aggregate = register_aggregate aggregate
-          register_listener LockCleaningUnitOfWorkListener.new aggregate_id, @lock_manager
-
-          aggregate
+          register_aggregate(aggregate).tap do
+            register_listener LockCleaningUnitOfWorkListener.new aggregate_id, @lock_manager
+          end
         rescue
           @logger.debug 'Excepton raised while loading an aggregate, releasing lock'
 
@@ -70,10 +69,6 @@ module Synapse
       # @param [Integer] expected_version
       # @return [AggregateRoot]
       def perform_load(aggregate_id, expected_version); end
-
-      def logger
-
-      end
     end
 
     # Unit of work listener that releases the lock on an aggregate when the unit of work

data/lib/synapse/repository.rb

@@ -0,0 +1,7 @@
+require 'synapse/repository/errors'
+
+require 'synapse/repository/lock_manager'
+require 'synapse/repository/pessimistic_lock_manager'
+
+require 'synapse/repository/repository'
+require 'synapse/repository/locking'

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

@@ -0,0 +1,28 @@
+require 'bson'
+
+module Synapse
+  module Serialization
+    # Converter that converts an ordered hash from BSON into a regular Ruby hash
+    class OrderedHashToHashConverter
+      include Converter
+
+      converts BSON::OrderedHash, Hash
+
+      # @param [Object] original
+      # @return [Object]
+      def convert_content(original)
+        converted = Hash.new
+
+        original.each do |key, value|
+          if value.is_a? BSON::OrderedHash
+            value = convert_content value
+          end
+
+          converted[key] = value
+        end
+
+        converted
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Synapse
+  module Serialization
+    # Implementation of a serializer that uses the hashing features of ActiveModel and Virtus
+    #
+    # If the object being serialized or deserialized is a hash, it will be untouched
+    #
+    # Objects being serialized by this implementation must meet the following requirements:
+    # * Respond to #attributes and #attributes=
+    # * #attributes= must work without the deserializer calling #initialize
+    #
+    # If either one of these are not met, the serializer may fail instantly or the deserialized
+    # object could be put in a bad state
+    class AttributeSerializer < Serializer
+      # This serializer doesn't provide any configuration options
+
+    protected
+
+      # @param [Object] content
+      # @return [Object]
+      def perform_serialize(content)
+        if content.is_a? Hash
+          content
+        else
+          content.attributes
+        end
+      end
+
+      # @param [Object] content
+      # @param [Class] type
+      # @return [Object]
+      def perform_deserialize(content, type)
+        if Hash == type
+          content
+        else
+          # Allocate the target object but don't call #initialize
+          object = type.allocate
+          object.attributes = content
+          object
+        end
+      end
+
+      # @return [Class]
+      def native_content_type
+        Hash
+      end
+    end
+  end
+end

data/lib/synapse/serialization/serializer.rb

@@ -36,7 +36,7 @@ module Synapse
       # @param [Class] representation_type
       # @return [Boolean]
       def can_serialize_to?(representation_type)
-        converter_factory.has_converter?(String, representation_type)
+        converter_factory.has_converter?(native_content_type, representation_type)
       end
 
       # @param [SerializedType] serialized_type

data/lib/synapse/serialization.rb

@@ -0,0 +1,46 @@
+module Synapse
+  module Serialization
+    extend ActiveSupport::Autoload
+
+    # Optional converters
+    autoload_at 'synapse/serialization/converter/json' do
+      autoload :JsonToObjectConverter
+      autoload :ObjectToJsonConverter
+    end
+
+    autoload_at 'synapse/serialization/converter/ox' do
+      autoload :XmlToOxDocumentConverter
+      autoload :OxDocumentToXmlConverter
+    end
+
+    autoload :OrderedHashToHashConverter, 'synapse/serialization/converter/bson'
+
+    # Optional serializers
+    autoload :AttributeSerializer, 'synapse/serialization/serializer/attribute'
+    autoload :OjSerializer, 'synapse/serialization/serializer/oj'
+    autoload :OxSerializer, 'synapse/serialization/serializer/ox'
+    autoload :MarshalSerializer, 'synapse/serialization/serializer/marshal'
+  end
+end
+
+require 'synapse/serialization/converter'
+require 'synapse/serialization/converter/chain'
+require 'synapse/serialization/converter/factory'
+require 'synapse/serialization/converter/identity'
+
+require 'synapse/serialization/errors'
+
+require 'synapse/serialization/lazy_object'
+require 'synapse/serialization/revision_resolver'
+require 'synapse/serialization/serialized_object'
+require 'synapse/serialization/serialized_type'
+require 'synapse/serialization/serializer'
+
+require 'synapse/serialization/message/data'
+require 'synapse/serialization/message/metadata'
+require 'synapse/serialization/message/serialization_aware'
+require 'synapse/serialization/message/serialization_aware_message'
+require 'synapse/serialization/message/serialized_message_builder'
+require 'synapse/serialization/message/serialized_message'
+require 'synapse/serialization/message/serialized_object_cache'
+require 'synapse/serialization/message/serializer'

data/lib/synapse/uow/factory.rb

@@ -15,13 +15,13 @@ module Synapse
       # @return [UnitOfWork]
       def create
         unit = UnitOfWork.new @provider
+        unit.tap do
+          if @transaction_manager
+            unit.transaction_manager = @transaction_manager
+          end
 
-        if @transaction_manager
-          unit.transaction_manager = @transaction_manager
+          unit.start
         end
-
-        unit.start
-        unit
       end
     end
   end

data/lib/synapse/uow/uow.rb

@@ -48,13 +48,13 @@ module Synapse
           return similar
         end
 
-        aggregate.add_registration_listener do |event|
-          publish_event event, event_bus
-        end
-
-        @aggregates.store aggregate, storage_listener
+        aggregate.tap do
+          aggregate.add_registration_listener do |event|
+            publish_event event, event_bus
+          end
 
-        aggregate
+          @aggregates.store aggregate, storage_listener
+        end
       end
 
       # Buffers an event for publication to the given event bus until this unit of work is
@@ -65,15 +65,15 @@ module Synapse
       # @return [EventMessage] The event that will be published to the event bus
       def publish_event(event, event_bus)
         event = @listeners.on_event_registered self, event
+        event.tap do
+          begin
+            events = @events.fetch event_bus
+          rescue KeyError
+            events = @events.store event_bus, Array.new
+          end
 
-        begin
-          events = @events.fetch event_bus
-        rescue KeyError
-          events = @events.store event_bus, Array.new
+          events.push event
         end
-
-        events.push event
-        event
       end
 
       # Sets the transaction manager that will be used by this unit of work

data/lib/synapse/uow.rb

@@ -0,0 +1,8 @@
+require 'synapse/uow/factory'
+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/upcasting/chain.rb

@@ -63,7 +63,7 @@ module Synapse
 
           if upcaster.can_upcast? serialized_type
             serialized_object = converter_factory.convert serialized_object, upcaster.expected_content_type
-            expected_types = upcaster.upcast_type(serialized_type)
+            expected_types = upcaster.upcast_type serialized_type
 
             upcast_objects.concat(perform_upcast(upcaster, serialized_object, expected_types, upcast_context))
           else

data/lib/synapse/upcasting.rb

@@ -0,0 +1,5 @@
+require 'synapse/upcasting/context'
+require 'synapse/upcasting/chain'
+require 'synapse/upcasting/data'
+require 'synapse/upcasting/upcaster'
+require 'synapse/upcasting/single_upcaster'

data/lib/synapse/version.rb

@@ -1,3 +1,3 @@
 module Synapse
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/lib/synapse/wiring.rb

@@ -0,0 +1,3 @@
+require 'synapse/wiring/message_wiring'
+require 'synapse/wiring/wire'
+require 'synapse/wiring/wire_registry'