synapse-core 0.4.0 → 0.5.1

data/lib/synapse/partitioning/memory_queue_reader.rb

@@ -1,31 +0,0 @@
-module Synapse
-  module Partitioning
-    # Queue reader that dequeues messages from an in-memory Ruby queue
-    class MemoryQueueReader < QueueReader
-      # @param [Queue] queue
-      # @param [String] name Name of the queue being read from
-      # @return [undefined]
-      def initialize(queue, name)
-        @queue = queue
-        @name = name
-      end
-
-      # @yield [MessageReceipt] Receipt of the message taken off the queue
-      # @return [undefined]
-      def subscribe(&handler)
-        loop do
-          packed = @queue.pop
-
-          receipt = MessageReceipt.new 0, packed, @name
-          handler.call receipt
-        end
-      end
-
-      # @param [MessageReceipt] receipt
-      # @return [undefined]
-      def nack_message(receipt)
-        @queue.push receipt.packed
-      end
-    end
-  end
-end

data/lib/synapse/partitioning/memory_queue_writer.rb

@@ -1,19 +0,0 @@
-module Synapse
-  module Partitioning
-    # Queue writer that pushes message into an in-memory Ruby queue
-    class MemoryQueueWriter < QueueWriter
-      # @param [Queue] queue
-      # @return [undefined]
-      def initialize(queue)
-        @queue = queue
-      end
-
-      # @param [Object] packed
-      # @param [Message] unpacked
-      # @return [undefined]
-      def put_message(packed, unpacked)
-        @queue.push packed
-      end
-    end
-  end
-end

data/lib/synapse/partitioning/message_receipt.rb

@@ -1,25 +0,0 @@
-module Synapse
-  module Partitioning
-    # Receipt used to track messages taken off of a queue
-    class MessageReceipt
-      # @return [Object] The transport mechanism's record of the message
-      attr_reader :tag
-
-      # @return [Object] The packed message from the transport
-      attr_reader :packed
-
-      # @return [String] The name of the queue the message was read from
-      attr_reader :queue_name
-
-      # @param [Object] tag
-      # @param [Object] packed
-      # @param [String] queue_name
-      # @return [undefined]
-      def initialize(tag, packed, queue_name)
-        @tag = tag
-        @packed = packed
-        @queue_name = queue_name
-      end
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-module Synapse
-  module Partitioning
-    # Implementation of a message packer that serializes the metadata and payload of any
-    # message and then serializes the entire message so it can go onto the wire.
-    class JsonMessagePacker < MessagePacker
-      # @param [Serializer] serializer
-      # @return [undefined]
-      def initialize(serializer)
-        @serializer = serializer
-
-        @serialization_target = String
-        # Ideally, we want to serialize the metadata and payload to hashes so that we don't
-        # duplicate serialization while serializing the message as a whole to a string
-        if serializer.can_serialize_to? Hash
-          @serialization_target = Hash
-        end
-      end
-
-      # @param [Message] unpacked
-      # @return [String]
-      def pack_message(unpacked)
-        message_type = type_for unpacked
-
-        metadata = @serializer.serialize unpacked.metadata, @serialization_target
-        payload = @serializer.serialize unpacked.payload, @serialization_target
-
-        packed = {
-          message_type: message_type,
-          id: unpacked.id,
-          metadata: metadata.content,
-          payload: payload.content,
-          payload_type: payload.type.name,
-          payload_revision: payload.type.revision
-        }
-
-        if [:event, :domain_event].include? message_type
-          pack_event unpacked, packed
-        end
-
-        if :domain_event == message_type
-          pack_domain_event unpacked, packed
-        end
-
-        JSON.dump packed
-      end
-
-    private
-
-      # Packs additional attributes specific to event messages
-      #
-      # @param [EventMessage] unpacked
-      # @param [Hash] packed
-      # @return [undefined]
-      def pack_event(unpacked, packed)
-        additional = {
-          timestamp: unpacked.timestamp.to_i
-        }
-        packed.merge! additional
-      end
-
-      # Packs additional attributes specific to domain event messages
-      #
-      # @param [DomainEventMessage] unpacked
-      # @param [Hash] packed
-      # @return [undefined]
-      def pack_domain_event(unpacked, packed)
-        additional = {
-          aggregate_id: unpacked.aggregate_id.to_s,
-          sequence_number: unpacked.sequence_number
-        }
-        packed.merge! additional
-      end
-
-      # Returns the packed type for the given message
-      #
-      # @raise [ArgumentError] If the given message isn't supported by this packer
-      # @param [Message] unpacked
-      # @return [Symbol]
-      def type_for(unpacked)
-        case unpacked
-        when Command::CommandMessage
-          :command
-        when Domain::DomainEventMessage
-          :domain_event
-        when Domain::EventMessage
-          :event
-        else
-          raise ArgumentError, 'Unknown message type'
-        end
-      end
-    end # JsonMessagePacker
-  end # Partitioning
-end # Synapse

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

@@ -1,83 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,18 +0,0 @@
-module Synapse
-  module Partitioning
-    extend ActiveSupport::Autoload
-
-    # Optional queues
-    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/test/partitioning/memory_test.rb

@@ -1,34 +0,0 @@
-require 'test_helper'
-
-module Synapse
-  module Partitioning
-
-    class MemoryQueueTest < Test::Unit::TestCase
-      def test_queuing
-        message = MessageBuilder.build
-
-        queue = Queue.new
-
-        reader = MemoryQueueReader.new queue, :test
-        writer = MemoryQueueWriter.new queue
-
-        count = 0
-
-        Thread.new do
-          reader.subscribe do |receipt|
-            assert_equal message, receipt.packed
-            assert_equal :test, receipt.queue_name
-
-            count = count.next
-          end
-        end
-
-        writer.put_message message, message
-        writer.put_message message, message
-
-        wait_until { count == 2 }
-      end
-    end
-
-  end
-end

data/test/partitioning/packing/json_test.rb

@@ -1,62 +0,0 @@
-require 'test_helper'
-
-module Synapse
-  module Partitioning
-
-    class JsonPackingTest < Test::Unit::TestCase
-      def setup
-        @converter_factory = Serialization::ConverterFactory.new
-        @serializer = Serialization::MarshalSerializer.new @converter_factory
-        @packer = JsonMessagePacker.new @serializer
-        @unpacker = JsonMessageUnpacker.new @serializer
-      end
-
-      def test_packing
-        message = Domain::DomainEventMessage.build do |builder|
-          builder.metadata = { foo: 0 }
-          builder.payload = { bar: 1 }
-          builder.aggregate_id = '123'
-          builder.sequence_number = 1
-        end
-
-        packed = @packer.pack_message message
-        unpacked = @unpacker.unpack_message packed
-
-        assert_equal message.id, unpacked.id
-        assert_equal message.metadata, unpacked.metadata
-        assert_equal message.payload, unpacked.payload
-        assert_equal message.timestamp.to_i, unpacked.timestamp.to_i
-        assert_equal message.aggregate_id, unpacked.aggregate_id
-        assert_equal message.sequence_number, unpacked.sequence_number
-      end
-
-      def test_type_packing
-        [Command::CommandMessage, Domain::EventMessage, Domain::DomainEventMessage].each do |type|
-          message = type.build
-          packed = @packer.pack_message message
-          unpacked = @unpacker.unpack_message packed
-
-          assert type === unpacked
-        end
-      end
-
-      def test_unknown_type
-        message = Message.build
-
-        assert_raise ArgumentError do
-          @packer.pack_message message
-        end
-
-        packed = {
-          message_type: :message
-        }
-        packed = JSON.dump packed
-
-        assert_raise ArgumentError do
-          @unpacker.unpack_message packed
-        end
-      end
-    end
-
-  end
-end