synapse-core 0.5.1 → 0.5.2

data/lib/synapse/command/wiring.rb

@@ -1,47 +0,0 @@
-module Synapse
-  module Command
-    # Mixin for a command handler that wishes to use the wiring DSL
-    module WiringCommandHandler
-      extend ActiveSupport::Concern
-      include CommandHandler
-      include Wiring::MessageWiring
-
-      included do
-        self.wire_registry = Wiring::WireRegistry.new false
-      end
-
-      # @param [CommandMessage] command
-      # @param [UnitOfWork] current_unit Current unit of work
-      # @return [Object] The result of handling the given command
-      def handle(command, current_unit)
-        wire = wire_registry.wire_for command.payload_type
-
-        unless wire
-          raise ArgumentError, 'Not capable of handling [%s] commands' % command.payload_type
-        end
-
-        invoke_wire command, wire
-      end
-
-      # Subscribes this handler to the given command bus for any types that have been wired
-      #
-      # @param [CommandBus] command_bus
-      # @return [undefined]
-      def subscribe(command_bus)
-        self.wire_registry.each_type do |type|
-          command_bus.subscribe type, self
-        end
-      end
-
-      # Unsubscribes this handler from the given command bus for any types that have been wired
-      #
-      # @param [CommandBus] command_bus
-      # @return [undefined]
-      def unsubscribe(command_bus)
-        self.wire_registry.each_type do |type|
-          command_bus.unsubscribe type, self
-        end
-      end
-    end # WiringCommandHandler
-  end # Command
-end

data/lib/synapse/event_bus/wiring.rb

@@ -1,20 +0,0 @@
-module Synapse
-  module EventBus
-    # Mixin for an event listener that wishes to use the wiring DSL
-    module WiringEventListener
-      extend ActiveSupport::Concern
-      include EventListener
-      include Wiring::MessageWiring
-
-      # @param [EventMessage] event
-      # @return [undefined]
-      def notify(event)
-        wire = wire_registry.wire_for event.payload_type
-
-        return unless wire
-
-        invoke_wire event, wire
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-module Synapse
-  module EventSourcing
-    # Event stream decorator that simply counts each event that is retrieved from a delegate stream
-    class CountingEventStream < Domain::DomainEventStream
-      extend Forwardable
-
-      # @param [DomainEventStream] delegate
-      # @param [Atomic] counter
-      # @return [undefined]
-      def initialize(delegate, counter)
-        @delegate = delegate
-        @counter = counter
-      end
-
-      # @return [DomainEventMessage]
-      def next_event
-        next_event = @delegate.next_event
-
-        @counter.update do |value|
-          value = value.next
-        end
-
-        next_event
-      end
-
-      # Delegate un-decorated domain event stream operations
-      def_delegators :@delegate, :end?, :peek
-    end
-
-    # Event stream decorator that counts each event retrieved from the delegate stream and
-    # registers a listener with the current unit of work that can trigger a snapshot after the
-    # unit of work has been cleaned up
-    class TriggeringEventStream < CountingEventStream
-      # @param [DomainEventStream] delegate
-      # @param [Atomic] counter
-      # @param [String] type_identifier
-      # @param [Object] aggregate_id
-      # @param [EventCountSnapshotTrigger] trigger
-      # @return [undefined]
-      def initialize(delegate, counter, type_identifier, aggregate_id, trigger)
-        super delegate, counter
-
-        @type_identifier = type_identifier
-        @aggregate_id = aggregate_id
-        @trigger = trigger
-      end
-
-      # @return [Boolean]
-      def end?
-        the_end = @delegate.end?
-
-        if the_end
-          listener = SnapshotUnitOfWorkListener.new @type_identifier, @aggregate_id, @counter, @trigger
-
-          unit = @trigger.unit_provider.current
-          unit.register_listener listener
-
-          @trigger.clear_counter @aggregate_id
-        end
-
-        the_end
-      end
-    end
-
-    # Unit of work listener that is used to trigger snapshots after a unit of work has been cleaned up
-    class SnapshotUnitOfWorkListener < UnitOfWork::UnitOfWorkListener
-      # @param [String] type_identifier
-      # @param [Object] aggregate_id
-      # @param [Atomic] counter
-      # @param [EventCountSnapshotTrigger] trigger
-      # @return [undefined]
-      def initialize(type_identifier, aggregate_id, counter, trigger)
-        @type_identifier = type_identifier
-        @aggregate_id = aggregate_id
-        @trigger = trigger
-        @counter = counter
-      end
-
-      # @param [UnitOfWork] unit
-      # @return [undefined]
-      def on_cleanup(unit)
-        @trigger.trigger_snapshot @type_identifier, @aggregate_id, @counter
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-require 'atomic'
-
-module Synapse
-  module EventSourcing
-    # Snapshot trigger that counts the number of events between snapshots to decide when to
-    # schedule the next snapshot
-    class EventCountSnapshotTrigger < EventStreamDecorator
-      # Default threshold for a snapshot to be scheduled
-      # @return [Integer]
-      DEFAULT_THRESHOLD = 50
-
-      # @return [SnapshotTaker]
-      attr_reader :snapshot_taker
-
-      # @return [Integer] The number of events between snapshots
-      attr_accessor :threshold
-
-      # @return [UnitOfWorkProvider]
-      attr_reader :unit_provider
-
-      # @param [SnapshotTaker] snapshot_taker
-      # @param [UnitOfWorkProvider] unit_provider
-      # @return [undefined]
-      def initialize(snapshot_taker, unit_provider)
-        @counters = Hash.new
-        @lock = Mutex.new
-        @logger = Logging.logger[self.class]
-        @threshold = DEFAULT_THRESHOLD
-
-        @snapshot_taker = snapshot_taker
-        @unit_provider = unit_provider
-      end
-
-      # If the event threshold has been reached for the aggregate with the given identifier, this
-      # will cause a snapshot to be scheduled
-      #
-      # @param [String] type_identifier
-      # @param [Object] aggregate_id
-      # @param [Atomic] counter
-      # @return [undefined]
-      def trigger_snapshot(type_identifier, aggregate_id, counter)
-        if counter.value > @threshold
-          @logger.info 'Snapshot threshold reached for [%s] [%s]' % [type_identifier, aggregate_id]
-
-          @snapshot_taker.schedule_snapshot type_identifier, aggregate_id
-          counter.value = 1
-        end
-      end
-
-      # @param [String] type_identifier
-      # @param [Object] aggregate_id
-      # @param [DomainEventStream] stream
-      # @return [DomainEventStream]
-      def decorate_for_read(type_identifier, aggregate_id, stream)
-        CountingEventStream.new(stream, counter_for(aggregate_id))
-      end
-
-      # @param [String] type_identifier
-      # @param [AggregateRoot] aggregate
-      # @param [DomainEventStream] stream
-      # @return [DomainEventStream]
-      def decorate_for_append(type_identifier, aggregate, stream)
-        TriggeringEventStream.new(stream, counter_for(aggregate.id), type_identifier, aggregate.id, self)
-      end
-
-      # Returns the event counter for the aggregate with the given identifier
-      #
-      # @param [Object] aggregate_id
-      # @return [Atomic]
-      def counter_for(aggregate_id)
-        @lock.synchronize do
-          if @counters.has_key? aggregate_id
-            @counters.fetch aggregate_id
-          else
-            @counters.store aggregate_id, Atomic.new(0)
-          end
-        end
-      end
-
-      # Clears the event counter for the aggregate with the given identifier
-      #
-      # @param [Object] aggregate_id
-      # @return [undefined]
-      def clear_counter(aggregate_id)
-        @lock.synchronize do
-          @counters.delete aggregate_id
-        end
-      end
-    end
-  end
-end

data/lib/synapse/process_manager/wiring/process.rb

@@ -1,27 +0,0 @@
-module Synapse
-  module ProcessManager
-    # Process that has the wiring DSL built-in
-    #
-    # @example
-    #   class OrderProcess < WiringProcess
-    #     wire OrderCreatedEvent, correlate: :order_id, start: true, to: :on_create
-    #     wire OrderFinishedEvent, correlate: :order_id, finish: true, to: :on_finish
-    #   end
-    class WiringProcess < Process
-      include Wiring::MessageWiring
-
-      # @param [EventMessage] event
-      # @return [undefined]
-      def handle(event)
-        return unless @active
-
-        wire = wire_registry.wire_for event.payload_type
-
-        return unless wire
-
-        invoke_wire event, wire
-        finish if wire.options[:finish]
-      end
-    end # WiringProcess
-  end # ProcessManager
-end

data/lib/synapse/wiring.rb

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

data/lib/synapse/wiring/message_wiring.rb

@@ -1,76 +0,0 @@
-module Synapse
-  module Wiring
-    # Base mixin that make it easier to wire handlers to their respective types
-    #
-    # It is recommended to use mixins more specific to the component being implemented, like
-    # wiring command handlers, event listeners, event-sourced members, or processes.
-    #
-    # @abstract
-    module MessageWiring
-      extend ActiveSupport::Concern
-
-      included do
-        # @return [WireRegistry]
-        class_attribute :wire_registry
-
-        # By default, the wire registry allows duplicates
-        self.wire_registry = Wiring::WireRegistry.new true
-      end
-
-      module ClassMethods
-        # Wires a message handler to messages with payload of the given type
-        #
-        # @example
-        #   wire CashWithdrawnEvent do |event|
-        #     # do something with the event
-        #   end
-        #
-        # @example
-        #   wire CashWithdrawnEvent :to => :on_withdraw
-        #
-        #   def on_withdraw(event)
-        #     # do something with the event
-        #   end
-        #
-        # Certain components that use message handling have different options that can be set
-        # on wires, like wiring processes.
-        #
-        # @example
-        #   wire SellTransactionStartedEvent, :start => true, :correlate => :transaction_id do
-        #     # do something with the event
-        #   end
-        #
-        # @api public
-        # @param [Class] type
-        # @param [Object...] args
-        # @param [Proc] block
-        # @return [undefined]
-        def wire(type, *args, &block)
-          options = args.extract_options!
-
-          to = options.delete :to
-          unless to
-            unless block
-              raise ArgumentError, 'Expected block or option :to'
-            end
-
-            to = block
-          end
-
-          wire = Wire.new type, options, to
-
-          self.wire_registry.register wire
-        end
-      end
-
-    protected
-
-      # @param [Message] message
-      # @param [Wire] wire
-      # @return [Object] Result of the handler invocation
-      def invoke_wire(message, wire)
-        wire.invoke self, message.payload
-      end
-    end
-  end
-end

data/lib/synapse/wiring/wire_registry.rb

@@ -1,61 +0,0 @@
-module Synapse
-  module Wiring
-    class WireRegistry
-      # @param [Boolean] duplicates_allowed
-      # @return [undefined]
-      def initialize(duplicates_allowed)
-        @duplicates_allowed = duplicates_allowed
-        @wires = Array.new
-      end
-
-      # Yields the type that each wire is registered for
-      #
-      # @yield [Class]
-      # @return [undefined]
-      def each_type
-        @wires.each do |wire|
-          yield wire.type
-        end
-      end
-
-      # @raise [DuplicateWireError] If duplicates aren't allowed and another wire exists that
-      #   wires the exact same type as the given wire
-      # @param [Wire] wire
-      # @return [undefined]
-      def register(wire)
-        unless @duplicates_allowed
-          if @wires.include? wire
-            raise DuplicateWireError
-          end
-        end
-
-        @wires.push wire
-        @wires.sort!
-      end
-
-      # Retrieves the most specific wire for a given type, if any
-      #
-      # @param [Class] target_type
-      # @return [Wire]
-      def wire_for(target_type)
-        @wires.find do |wire|
-          wire.type >= target_type
-        end
-      end
-
-      # Retrieves any wires for a given type, regardless of specificity
-      #
-      # @param [Class] target_type
-      # @return [Array]
-      def wires_for(target_type)
-        @wires.find_all do |wire|
-          wire.type >= target_type
-        end
-      end
-    end
-
-    # Raised if a wire registry doesn't allow duplicates and an attempt is made to wire the same
-    # type to multiple handlers
-    class DuplicateWireError < NonTransientError; end
-  end
-end

data/test/event_sourcing/snapshot/integration_test.rb

@@ -1,65 +0,0 @@
-require 'test_helper'
-require 'event_sourcing/fixtures'
-
-module Synapse
-  module EventSourcing
-
-    class SnapshotIntegrationTest < Test::Unit::TestCase
-      def test_integration
-        unit_provider = Object.new
-        unit = Object.new
-
-        mock(unit_provider).current do
-          unit
-        end
-
-        listener = nil
-
-        mock(unit).register_listener(is_a(SnapshotUnitOfWorkListener)) do |l|
-          listener = l
-        end
-
-        event_store = Object.new
-
-        aggregate_id = 123
-        type_identifier = Object.to_s
-
-        aggregate = Object.new
-        mock(aggregate).id.any_times do
-          aggregate_id
-        end
-
-        snapshot_taker = Object.new
-        snapshot_trigger = EventCountSnapshotTrigger.new snapshot_taker, unit_provider
-        snapshot_trigger.threshold = 5
-
-        read_stream = create_stream 3
-        append_stream = create_stream 3
-
-        decorated_read_stream = snapshot_trigger.decorate_for_read type_identifier, aggregate_id, read_stream
-        decorated_read_stream.to_a # Causes stream to iterate over all events
-
-        decorated_append_stream = snapshot_trigger.decorate_for_append type_identifier, aggregate, append_stream
-        decorated_append_stream.to_a # Ditto
-
-        # At this point, there is a snapshot unit of work listener added
-        # Let's "cleanup" the unit of work and check if the snapshot is triggered
-
-        mock(snapshot_taker).schedule_snapshot type_identifier, aggregate_id
-
-        listener.on_cleanup unit
-      end
-
-      def create_stream(size)
-        events = Array.new
-
-        size.times do
-          events.push Domain::DomainEventMessage.build
-        end
-
-        Domain::SimpleDomainEventStream.new events
-      end
-    end
-
-  end
-end