synapse-core 0.1.2 → 0.2.0

data/lib/synapse/auditing/audit_logger.rb

@@ -0,0 +1,28 @@
+module Synapse
+  module Auditing
+    # Represents a mechanism for auditing commands and the events produced by their execution
+    # @abstract
+    class AuditLogger
+      # Called when a command execution was finished successfully
+      #
+      # @abstract
+      # @param [CommandMessage] command
+      # @param [Object] return_value
+      # @param [Array<EventMessage>] events
+      # @return [undefined]
+      def on_success(command, return_value, events); end
+
+      # Called when a command execution results in an exception being raised
+      #
+      # The list of events may not be empty; in this case, some events could have been published
+      # to the event bus and/or appended to the event store.
+      #
+      # @abstract
+      # @param [CommandMessage] command
+      # @param [Exception] exception
+      # @param [Array<EventMessage>] events
+      # @return [undefined]
+      def on_failure(command, exception, events); end
+    end
+  end
+end

data/lib/synapse/auditing/data_provider.rb

@@ -0,0 +1,42 @@
+module Synapse
+  module Auditing
+    # Provides relevant information to events for auditing purposes
+    # @abstract
+    class AuditDataProvider
+      # Returns auditing information for the given command
+      #
+      # @abstract
+      # @param [CommandMessage] command
+      # @return [Hash]
+      def provide_data_for(command); end
+    end
+
+    # Implementation of an audit provider that simply audits a command's metadata
+    class CommandMetadataProvider < AuditDataProvider
+      # @param [CommandMessage] command
+      # @return [Hash]
+      def provide_data_for(command)
+        command.metadata
+      end
+    end
+
+    # Implementation of an audit provider that attaches a command's identifier to each event
+    # produced as a result of the execution of that command
+    class CorrelationDataProvider < AuditDataProvider
+      # The default key to use when correlating events with commands
+      DEFAULT_KEY = :command_id
+
+      # @param [Symbol] correlation_key
+      # @return [undefined]
+      def initialize(correlation_key = DEFAULT_KEY)
+        @correlation_key = correlation_key
+      end
+
+      # @param [CommandMessage] command
+      # @return [Hash]
+      def provide_data_for(command)
+        Hash[@correlation_key, command.id]
+      end
+    end
+  end
+end

data/lib/synapse/auditing/dispatch_interceptor.rb

@@ -0,0 +1,29 @@
+module Synapse
+  module Auditing
+    class AuditingDispatchInterceptor < Command::DispatchInterceptor
+      # @return [Array<AuditDataProvider>]
+      attr_accessor :data_providers
+
+      # @return [Array<AuditLogger>]
+      attr_accessor :loggers
+
+      def initialize
+        @data_providers = Array.new
+        @loggers = Array.new
+      end
+
+      # @param [CommandMessage] command
+      # @param [UnitOfWork] unit The current unit of work for this command dispatch
+      # @param [InterceptorChain] chain
+      # @return [Object] The result of the execution of the command
+      def intercept(command, unit, chain)
+        audit_listener = AuditingUnitOfWorkListener.new command, @data_providers, @loggers
+        unit.register_listener audit_listener
+
+        chain.proceed(command).tap do |result|
+          audit_listener.return_value = result
+        end
+      end
+    end
+  end
+end

data/lib/synapse/auditing/unit_listener.rb

@@ -0,0 +1,53 @@
+module Synapse
+  module Auditing
+    class AuditingUnitOfWorkListener < UnitOfWork::UnitOfWorkListener
+      # @return [Array<EventMessage>]
+      attr_reader :recorded_events
+
+      # @return [Object]
+      attr_accessor :return_value
+
+      # @param [CommandMessage] command
+      # @param [Array<AuditDataProvider>] data_providers
+      # @param [Array<AuditLogger>] loggers
+      # @return [undefined]
+      def initialize(command, data_providers, loggers)
+        @command = command
+        @data_providers = data_providers
+        @loggers = loggers
+        @recorded_events = Array.new
+      end
+
+      # @param [UnitOfWork] unit
+      # @param [EventMessage] event
+      # @return [EventMessage]
+      def on_event_registered(unit, event)
+        audit_data = Hash.new
+        @data_providers.each do |provider|
+          audit_data.merge! provider.provide_data_for @command
+        end
+
+        event.and_metadata(audit_data).tap do |e|
+          @recorded_events.push e
+        end
+      end
+
+      # @param [UnitOfWork] unit
+      # @return [undefined]
+      def after_commit(unit)
+        @loggers.each do |logger|
+          logger.on_success @command, @return_value, @recorded_events
+        end
+      end
+
+      # @param [UnitOfWork] unit
+      # @param [Error] cause
+      # @return [undefined]
+      def on_rollback(unit, cause = nil)
+        @loggers.each do |logger|
+          logger.on_success @command, cause, @recorded_events
+        end
+      end
+    end
+  end
+end

data/lib/synapse/auditing.rb

@@ -0,0 +1,4 @@
+require 'synapse/auditing/audit_logger'
+require 'synapse/auditing/data_provider'
+require 'synapse/auditing/dispatch_interceptor'
+require 'synapse/auditing/unit_listener'

data/lib/synapse/command.rb

@@ -0,0 +1,34 @@
+module Synapse
+  module Command
+    extend ActiveSupport::Autoload
+
+    # Optional filters and interceptors
+    autoload_at 'synapse/command/duplication' do
+      autoload :DuplicationFilter
+      autoload :DuplicationCleanupInterceptor
+    end
+
+    autoload_at 'synapse/command/filters/validation' do
+      autoload :ActiveModelValidationFilter
+      autoload :ActiveModelValidationError
+    end
+
+    autoload_at 'synapse/command/interceptors/serialization' do
+      autoload :SerializationOptimizingInterceptor
+      autoload :SerializationOptimizingListener
+    end
+  end
+end
+
+require 'synapse/command/command_bus'
+require 'synapse/command/command_callback'
+require 'synapse/command/command_filter'
+require 'synapse/command/command_handler'
+require 'synapse/command/dispatch_interceptor'
+require 'synapse/command/errors'
+require 'synapse/command/gateway'
+require 'synapse/command/interceptor_chain'
+require 'synapse/command/message'
+require 'synapse/command/rollback_policy'
+require 'synapse/command/simple_command_bus'
+require 'synapse/command/wiring'

data/lib/synapse/{identifier.rb → common/identifier.rb}

@@ -19,5 +19,6 @@ module Synapse
     end
   end
 
-  ActiveSupport.run_load_hooks :identifier_factory, IdentifierFactory
+  # Setup the default identifier factory
+  IdentifierFactory.instance = GuidIdentifierFactory.new
 end

data/lib/synapse/domain.rb

@@ -0,0 +1,5 @@
+require 'synapse/domain/aggregate_root'
+require 'synapse/domain/event_container'
+require 'synapse/domain/message'
+require 'synapse/domain/message_builder'
+require 'synapse/domain/stream'

data/lib/synapse/event_bus.rb

@@ -0,0 +1,5 @@
+require 'synapse/event_bus/event_bus'
+require 'synapse/event_bus/event_listener'
+require 'synapse/event_bus/event_listener_proxy'
+require 'synapse/event_bus/simple_event_bus'
+require 'synapse/event_bus/wiring'

data/lib/synapse/event_sourcing/conflict_resolver.rb

@@ -64,13 +64,11 @@ module Synapse
 
       # @return [DomainEventMessage]
       def next_event
-        event = @delegate.next_event
-
-        if @expected_version and event.sequence_number > @expected_version
-          @unseen_events.push event
+        @delegate.next_event.tap do |event|
+          if @expected_version and event.sequence_number > @expected_version
+            @unseen_events.push event
+          end
         end
-
-        event
       end
 
       # Delegators for domain event stream

data/lib/synapse/event_sourcing/member.rb

@@ -4,6 +4,11 @@ module Synapse
     # applied to the aggregate
     module Member
       extend ActiveSupport::Concern
+      include Wiring::MessageWiring
+
+      included do
+        self.wire_registry = Wiring::WireRegistry.new true
+      end
 
       module ClassMethods
         # Registers an instance variable as a child entity
@@ -53,10 +58,14 @@ module Synapse
       # If the event is relative to this member, its parameters will be used to change
       # the state of this member
       #
-      # @abstract
       # @param [EventMessage] event
       # @return [undefined]
-      def handle_event(event); end
+      def handle_event(event)
+        wire = self.wire_registry.wire_for event.payload_type
+        if wire
+          invoke_wire event, wire
+        end
+      end
 
     private
 

data/lib/synapse/event_sourcing/snapshot/taker.rb

@@ -17,24 +17,6 @@ module Synapse
       def schedule_snapshot(type_identifier, aggregate_id); end
     end
 
-    # Snapshot taker that uses EventMachine to defer scheduling of snapshots
-    class DeferredSnapshotTaker < SnapshotTaker
-      # @param [SnapshotTaker] delegate
-      # @return [undefined]
-      def initialize(delegate)
-        @delegate = delegate
-      end
-
-      # @param [String] type_identifier
-      # @param [Object] aggregate_id
-      # @return [undefined]
-      def schedule_snapshot(type_identifier, aggregate_id)
-        EventMachine.defer do
-          @delegate.schedule_snapshot type_identifier, aggregate_id
-        end
-      end
-    end
-
     # Snapshot taker that uses the actual aggregate and its state to create a snapshot event
     class AggregateSnapshotTaker < SnapshotTaker
       # @param [SnapshotEventStore] event_store

data/lib/synapse/event_sourcing.rb

@@ -0,0 +1,13 @@
+require 'synapse/event_sourcing/aggregate_factory'
+require 'synapse/event_sourcing/conflict_resolver'
+require 'synapse/event_sourcing/repository'
+require 'synapse/event_sourcing/storage_listener'
+require 'synapse/event_sourcing/stream_decorator'
+
+require 'synapse/event_sourcing/member'
+require 'synapse/event_sourcing/aggregate_root'
+require 'synapse/event_sourcing/entity'
+
+require 'synapse/event_sourcing/snapshot/count_stream'
+require 'synapse/event_sourcing/snapshot/count_trigger'
+require 'synapse/event_sourcing/snapshot/taker'

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

@@ -30,9 +30,9 @@ module Synapse
 
         # @return [DomainEventMessage]
         def next_event
-          current = @next
-          initialize_next_event
-          current
+          @next.tap do
+            initialize_next_event
+          end
         end
 
         # @return [DomainEventMessage]

data/lib/synapse/event_store/mongo.rb

@@ -0,0 +1,8 @@
+require 'synapse/event_store/mongo/cursor_event_stream'
+require 'synapse/event_store/mongo/event_store'
+
+require 'synapse/event_store/mongo/storage_strategy'
+require 'synapse/event_store/mongo/per_commit_strategy'
+require 'synapse/event_store/mongo/per_event_strategy'
+
+require 'synapse/event_store/mongo/template'

data/lib/synapse/event_store.rb

@@ -0,0 +1,11 @@
+module Synapse
+  module EventStore
+    extend ActiveSupport::Autoload
+
+    autoload :InMemoryEventStore, 'synapse/event_store/in_memory'
+    autoload :Mongo
+  end
+end
+
+require 'synapse/event_store/errors'
+require 'synapse/event_store/event_store'

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

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

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

@@ -0,0 +1,26 @@
+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/partitioning/amqp.rb

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

data/lib/synapse/partitioning/memory_queue_reader.rb

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

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

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

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