synapse-core 0.2.0 → 0.4.0

data/lib/synapse/event_store/mongo/storage_strategy.rb

@@ -1,113 +0,0 @@
-module Synapse
-  module EventStore
-    module Mongo
-      # Represents a mechanism used to structure how events are stored in the database
-      # @abstract
-      class StorageStrategy
-        # @param [MongoTemplate] template
-        # @param [Serializer] serializer
-        # @param [UpcasterChain] upcaster_chain
-        # @return [undefined]
-        def initialize(template, serializer, upcaster_chain)
-          @template = template
-          @serializer = Serialization::MessageSerializer.new serializer
-          @upcaster_chain = upcaster_chain
-        end
-
-        # Creates documents that will represent the events being committed to the event store
-        #
-        # @abstract
-        # @param [String] type_identifier Type identifier for the aggregate
-        # @param [Array] events Domain events to be committed
-        # @return [Array]
-        def create_documents(type_identifier, events); end
-
-        # Extracts individual event messages from the given document
-        #
-        # The given aggregate identifier is passed so that event messages can have the actual
-        # identifier object instead of the serialized aggregate identifier.
-        #
-        # @abstract
-        # @param [Hash] document
-        # @param [Object] aggregate_id
-        # @return [Array]
-        def extract_events(document, aggregate_id); end
-
-        # Aliases of the Mongo constants for ascending and descending
-        ASCENDING = ::Mongo::ASCENDING
-        DESCENDING = ::Mongo::DESCENDING
-
-        # Provides a cursor for accessing all events for an aggregate with the given identifier
-        # and type identifier, with a sequence number equal to or greater than the given first
-        # sequence number
-        #
-        # The returned documents should be ordered chronologically, typically by using the
-        # sequence number.
-        #
-        # @param [String] type_identifier
-        # @param [Object] aggregate_id
-        # @param [Integer] first_sequence_number
-        # @return [Mongo::Cursor]
-        def fetch_events(type_identifier, aggregate_id, first_sequence_number)
-          filter = {
-            aggregate_id: aggregate_id,
-            aggregate_type: type_identifier,
-            sequence_number: {
-              '$gte' => first_sequence_number
-            }
-          }
-
-          sort = {
-            sequence_number: ASCENDING
-          }
-
-          @template.event_collection.find(filter).sort(sort)
-        end
-
-        # Finds the document containing the most recent snapshot event for an aggregate with the
-        # given identifier and type identifier
-        #
-        # @param [String] type_identifier
-        # @param [Object] aggregate_id
-        # @return [Mongo::Cursor]
-        def fetch_last_snapshot(type_identifier, aggregate_id)
-          filter = {
-            aggregate_id: aggregate_id,
-            aggregate_type: type_identifier
-          }
-
-          sort = {
-            sequence_number: DESCENDING
-          }
-
-          @template.snapshot_collection.find(filter).sort(sort).limit(1)
-        end
-
-        # Ensures that the correct indexes are in place
-        # @return [undefined]
-        def ensure_indexes
-          options = {
-            name: 'unique_aggregate_index',
-            unique: true
-          }
-
-          spec = {
-            aggregate_id: ASCENDING,
-            aggregate_type: ASCENDING,
-            sequence_number: ASCENDING
-          }
-
-          @template.event_collection.ensure_index spec, options
-
-          spec = {
-            aggregate_id: ASCENDING,
-            aggregate_type: ASCENDING,
-            sequence_number: DESCENDING
-          }
-
-          @template.snapshot_collection.ensure_index spec, options
-        end
-      end # StorageStrategy
-    end # Mongo
-  end # EventStore
-end # Synapse

data/lib/synapse/event_store/mongo/template.rb

@@ -1,73 +0,0 @@
-module Synapse
-  module EventStore
-    module Mongo
-      # Represents a mechanism for accessing collections required by the Mongo event store
-      # @abstract
-      class MongoTemplate
-        # Returns a reference to the collection containing domain events
-        #
-        # @abstract
-        # @return [Mongo::Collection]
-        def event_collection; end
-
-        # Returns a reference to the collection containing snapshot events
-        #
-        # @abstract
-        # @return [Mongo::Collection]
-        def snapshot_collection; end
-      end
-
-      class DefaultMongoTemplate
-        # @return [String] Name of the database to use
-        attr_accessor :database_name
-
-        # @return [String] Username to authenticate with (optional)
-        attr_accessor :username
-
-        # @return [String] Password to authenticate with (optional)
-        attr_accessor :password
-
-        # @return [String] Name of the collection containing domain events
-        attr_accessor :event_collection
-
-        # @return [String] Name of the collection containing snapshot events
-        attr_accessor :snapshot_collection
-
-        # @param [Mongo::MongoClient] client
-        # @return [undefined]
-        def initialize(client)
-          @client = client
-
-          @database_name = 'synapse'
-          @event_collection_name = 'domain_events'
-          @snapshot_collection_name = 'snapshot_events'
-        end
-
-        # @return [Mongo::Collection]
-        def event_collection
-          database.collection @event_collection_name
-        end
-
-        # @return [Mongo::Collection]
-        def snapshot_collection
-          database.collection @snapshot_collection_name
-        end
-
-      private
-
-        # @return [Mongo::DB]
-        def database
-          unless @database
-            @database = @client.db @database_name
-
-            if @username and @password
-              @database.authenticate @username, @password
-            end
-          end
-
-          @database
-        end
-      end # DefaultMongoTemplate
-    end # Mongo
-  end # EventStore
-end # Synapse

data/lib/synapse/partitioning/amqp.rb

@@ -1,3 +0,0 @@
-require 'synapse/partitioning/amqp/amqp_queue_reader'
-require 'synapse/partitioning/amqp/amqp_queue_writer'
-require 'synapse/partitioning/amqp/key_resolver'

data/lib/synapse/partitioning/amqp/amqp_queue_reader.rb

@@ -1,50 +0,0 @@
-module Synapse
-  module Partitioning
-    module AMQP
-      # Implementation of a queue reader that subscribes to an AMQP queue
-      class AMQPQueueReader < QueueReader
-        # The behavior when a message is not acknowledged by a message handler
-        #
-        # When a message is explicitly rejected, this usually indicates that there was an
-        # error while processing the message. When the message is rejected, it can either be
-        # put back on the queue so that it can be retried later, or it can be routed as a dead
-        # letter if using RabbitMQ.
-        #
-        # @see http://www.rabbitmq.com/dlx.html
-        # @return [Boolean] Default value is true
-        attr_accessor :requeue_on_nack
-
-        # @param [AMQP::Queue] queue
-        # @param [AMQP::Channel] channel
-        # @param [MessageUnpacker] unpacker
-        # @return [undefined]
-        def initialize(queue, channel, unpacker)
-          @queue = queue
-          @channel = channel
-          @requeue_on_nack = true
-        end
-
-        # @yield [MessageReceipt] Receipt of the message taken off the queue
-        # @return [undefined]
-        def subscribe(&handler)
-          @queue.subscribe do |headers, packed|
-            receipt = MessageReceipt.new headers.delivery_tag, packed, @queue.name
-            handler.call receipt
-          end
-        end
-
-        # @param [MessageReceipt] receipt
-        # @return [undefined]
-        def ack_message(receipt)
-          @channel.acknowledge receipt.tag
-        end
-
-        # @param [MessageReceipt] receipt
-        # @return [undefined]
-        def nack_message(receipt)
-          @channel.reject receipt.tag, @requeue_on_nack
-        end
-      end # AMQPQueueReader
-    end # AMQP
-  end # Partitioning
-end # Synapse

data/lib/synapse/partitioning/amqp/amqp_queue_writer.rb

@@ -1,31 +0,0 @@
-module Synapse
-  module Partitioning
-    module AMQP
-      # Implementation of a queue writer that publishes packed messages to an AMQP exchange
-      class AMQPQueueWriter < QueueWriter
-        # @return [Hash] Additional options that will be used when publishing messages
-        attr_accessor :publish_options
-
-        # @param [AMQP::Exchange] exchange
-        # @param [RoutingKeyResolver] key_resolver
-        # @return [undefined]
-        def initialize(exchange, key_resolver)
-          @exchange = exchange
-          @key_resolver = key_resolver
-          @publish_options = Hash.new
-        end
-
-        # @param [Object] packed
-        # @param [Message] unpacked
-        # @return [undefined]
-        def put_message(packed, unpacked)
-          publish_options = {
-            routing_key: @key_resolver.resolve_key(unpacked)
-          }
-
-          @exchange.publish(packed, @publish_options.merge(publish_options))
-        end
-      end # AMQPQueueWriter
-    end # AMQP
-  end # Partitioning
-end # Synapse

data/lib/synapse/partitioning/amqp/key_resolver.rb

@@ -1,26 +0,0 @@
-module Synapse
-  module Partitioning
-    module AMQP
-      # Represents a mechanism for determining the routing key to use when publishing a message
-      class RoutingKeyResolver
-        # Returns the routing key to use when publishing the given message
-        #
-        # @param [Message] message
-        # @return [String]
-        def resolve_key(message); end
-      end
-
-      # Implementation of a routing key resolver that uses the message payload's module name
-      class ModuleRoutingKeyResolver
-        # @param [Message] message
-        # @return [String]
-        def resolve_key(message)
-          type = message.payload_type.to_s
-          type.deconstantize.underscore.tap do |key|
-            key.tr! '/', '.'
-          end
-        end
-      end
-    end # AMQP
-  end # Partitioning
-end # Synapse

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

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