synapse-core 0.4.0 → 0.5.1

data/lib/synapse/configuration/component/command_bus/gateway.rb

@@ -0,0 +1,38 @@
+module Synapse
+  module Configuration
+    # Definition builder used to create a command gateway
+    #
+    # @example The minimum possible effort to build a command gateway
+    #   gateway
+    #
+    # @example Create a command gateway using an alternate command bus
+    #   gateway :alt_gateway do
+    #     use_command_bus :alt_command_bus
+    #   end
+    #
+    # @todo Support for command filters and retry scheduler
+    class CommandGatewayDefinitionBuilder < DefinitionBuilder
+      # Changes the command bus that commands are sent from the gateway
+      #
+      # @param [Symbol] command_bus
+      # @return [undefined]
+      def use_command_bus(command_bus)
+        @command_bus = command_bus
+      end
+
+    protected
+
+      # @return [undefined]
+      def populate_defaults
+        identified_by :gateway
+
+        use_command_bus :command_bus
+
+        use_factory do
+          command_bus = resolve @command_bus
+          Command::CommandGateway.new command_bus
+        end
+      end
+    end # CommandGatewayDefinitionBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/command_bus/simple_command_bus.rb

@@ -0,0 +1,81 @@
+module Synapse
+  module Configuration
+    # Definition builder used to create a simple command bus
+    #
+    # @example The minimum possible effort to build a command bus
+    #   simple_command_bus
+    #
+    # @example Create a command bus with an alternate identifier and handler tag
+    #   simple_command_bus :alt_command_bus do
+    #     use_handler_tag :alt_command_handler
+    #   end
+    #
+    # @todo Support for interceptors and filters
+    class SimpleCommandBusDefinitionBuilder < DefinitionBuilder
+      # Changes the tag to use to automatically subscribe command handlers
+      #
+      # Note that command handlers that are tagged must support self-subscription to the
+      # command bus. An example of a handler capable of doing so is the wiring command handler.
+      #
+      # @param [Symbol] handler_tag
+      # @return [undefined]
+      def use_handler_tag(handler_tag)
+        @handler_tag = handler_tag
+      end
+
+      # Changes the rollback policy to use for the command bus
+      #
+      # By default, the command bus will always rollback on an exception
+      #
+      # @param [Symbol] rollback_policy
+      # @return [undefined]
+      def use_rollback_policy(rollback_policy)
+        @rollback_policy = rollback_policy
+      end
+
+      # Changes the unit of work factory to use with this command bus
+      #
+      # @param [Symbol] unit_factory
+      # @return [undefined]
+      def use_unit_factory(unit_factory)
+        @unit_factory = unit_factory
+      end
+
+    protected
+
+      # @return [undefined]
+      def populate_defaults
+        identified_by :command_bus
+
+        use_handler_tag :command_handler
+        use_unit_factory :unit_factory
+
+        use_factory do
+          unit_factory = resolve @unit_factory
+
+          command_bus = create_command_bus unit_factory
+
+          if @rollback_policy
+            command_bus.rollback_policy = resolve @rollback_policy
+          end
+
+          with_tagged @handler_tag do |handler|
+            handler.subscribe command_bus
+          end
+
+          command_bus
+        end
+      end
+
+      # Creates an instance of SimpleCommandBus with the given unit of work factory
+      #
+      # This can be overriden to serve up special subclasses of SimpleCommandBus
+      #
+      # @param [UnitOfWorkFactory] unit_factory
+      # @return [SimpleCommandBus]
+      def create_command_bus(unit_factory)
+        Command::SimpleCommandBus.new unit_factory
+      end
+    end # SimpleCommandBusDefinitionBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/command_bus.rb

@@ -0,0 +1,35 @@
+module Synapse
+  module Configuration
+    class ContainerBuilder
+      # Creates and configures an asynchronous command bus
+      #
+      # @see AsynchronousCommandBusDefinitionBuilder
+      # @param [Symbol] identifier
+      # @param [Proc] block
+      # @return [undefined]
+      def async_command_bus(identifier = nil, &block)
+        with_definition_builder AsynchronousCommandBusDefinitionBuilder, identifier, &block
+      end
+
+      # Creates and configures a simple command bus
+      #
+      # @see SimpleCommandBusDefinitionBuilder
+      # @param [Symbol] identifier
+      # @param [Proc] block
+      # @return [undefined]
+      def simple_command_bus(identifier = nil, &block)
+        with_definition_builder SimpleCommandBusDefinitionBuilder, identifier, &block
+      end
+
+      # Creates and configures a command gateway
+      #
+      # @see CommandGatewayBusDefinitionBuilder
+      # @param [Symbol] identifier
+      # @param [Proc] block
+      # @return [undefined]
+      def gateway(identifier = nil, &block)
+        with_definition_builder CommandGatewayBusDefinitionBuilder, identifier, &block
+      end
+    end # ContainerBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/event_bus/simple_event_bus.rb

@@ -0,0 +1,41 @@
+module Synapse
+  module Configuration
+    # Definition builder used to create a simple event bus
+    #
+    # @example The minimum possible effort to build an event bus
+    #   simple_event_bus
+    #
+    # @example Create an event bus with an alternate identifier and listener tag
+    #   simple_event_bus :alt_event_bus do
+    #     use_listener_tag :alt_event_listener
+    #   end
+    class SimpleEventBusDefinitionBuilder < DefinitionBuilder
+      # Changes the tag to use to automatically subscribe event listeners
+      #
+      # @param [Symbol] listener_tag
+      # @return [undefined]
+      def use_listener_tag(listener_tag)
+        @listener_tag = listener_tag
+      end
+
+    protected
+
+      # @return [undefined]
+      def populate_defaults
+        identified_by :event_bus
+
+        use_listener_tag :event_listener
+
+        use_factory do
+          event_bus = EventBus::SimpleEventBus.new
+
+          with_tagged @listener_tag do |listener|
+            event_bus.subscribe listener
+          end
+
+          event_bus
+        end
+      end
+    end # SimpleEventBusDefinitionBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/event_bus.rb

@@ -0,0 +1,15 @@
+module Synapse
+  module Configuration
+    class ContainerBuilder
+      # Creates and configures a simple event bus
+      #
+      # @see SimpleEventBusDefinitionBuilder
+      # @param [Symbol] identifier
+      # @param [Proc] block
+      # @return [undefined]
+      def simple_event_bus(identifier = nil, &block)
+        with_definition_builder SimpleEventBusDefinitionBuilder, identifier, &block
+      end
+    end # ContainerBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/event_sourcing/repository.rb

@@ -0,0 +1,62 @@
+module Synapse
+  module Configuration
+    # Definition builder used to create event sourced aggregate repositories
+    #
+    # @example The minimum possible effort to build a event sourcing repository
+    #   es_repository :orderbook_repository do
+    #     use_aggregate_type TradeEngine::OrderBook
+    #   end
+    class EventSourcingRepositoryDefinitionBuilder < LockingRepositoryDefinitionBuilder
+      # Convenience method that defines an aggregate factory capable of creating aggregates 
+      # of the given type
+      #
+      # @param [Class] aggregate_type
+      # @return [undefined]
+      def use_aggregate_type(aggregate_type)
+        @aggregate_factory = build_composite do
+          anonymous
+          tag :aggregate_factory
+          use_factory do
+            EventSourcing::GenericAggregateFactory.new aggregate_type
+          end
+        end
+      end
+
+      # @param [Symbol] aggregate_factory
+      # @return [undefined]
+      def use_aggregate_factory(aggregate_factory)
+        @aggregate_factory = aggregate_factory
+      end
+
+      # @param [Symbol] conflict_resolver
+      # @return [undefined]
+      def use_conflict_resolver(conflict_resolver)
+        @conflict_resolver = conflict_resolver
+      end
+
+      # @param [Symbol] event_store
+      # @return [undefined]
+      def use_event_store(event_store)
+        @event_store = event_store
+      end
+
+    protected
+
+      # @return [undefined]
+      def populate_defaults
+        super
+
+        use_event_store :event_store
+
+        use_factory do
+          aggregate_factory = resolve @aggregate_factory
+          event_store = resolve @event_store
+          lock_manager = build_lock_manager
+
+          repository = EventSourcing::EventSourcingRepository.new aggregate_factory, event_store, lock_manager
+          inject_base_dependencies repository
+        end
+      end
+    end # EventSourcingRepositoryDefinitionBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/event_sourcing.rb

@@ -0,0 +1,15 @@
+module Synapse
+  module Configuration
+    class ContainerBuilder
+      # Creates and configures an event sourcing repository
+      #
+      # @see EventSourcingRepositoryDefinitionBuilder
+      # @param [Symbol] identifier
+      # @param [Proc] block
+      # @return [undefined]
+      def es_repository(identifier = nil, &block)
+        with_definition_builder EventSourcingRepositoryDefinitionBuilder, identifier, &block
+      end
+    end # ContainerBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/repository/locking_repository.rb

@@ -0,0 +1,85 @@
+module Synapse
+  module Configuration
+    # Definition builder that serves a base for building specific implementations of a
+    # locking repository
+    #
+    # @abstract
+    # @see EventSourcingRepositoryDefinitionBuilder
+    # @see SimpleRepositoryDefinitionBuilder
+    class LockingRepositoryDefinitionBuilder < DefinitionBuilder
+      # Changes the event bus used to publish aggregate events to
+      #
+      # @param [Symbol] event_bus
+      # @return [undefined]
+      def use_event_bus(event_bus)
+        @event_bus = event_bus
+      end
+
+      # Uses the lock manager with no locking
+      # @return [undefined]
+      def use_no_locking
+        @lock_manager_type = Repository::NullLockManager
+      end
+
+      # Uses the lock manager with pessimistic locking
+      # @return [undefined]
+      def use_pessimistic_locking
+        @lock_manager_type = Repository::PessimisticLockManager
+      end
+
+      # Uses the lock manager with optimistic locking
+      # @return [undefined]
+      def use_optimistic_locking
+        @lock_manager_type = Repository::OptimisticLockManager
+      end
+
+      # Changes the lock manager used to prevent concurrent aggregate modification
+      #
+      # @param [Symbol] lock_manager
+      # @return [undefined]
+      def use_lock_manager(lock_manager)
+        @lock_manager = lock_manager
+      end
+
+      # Changes the provider used to get the current unit of work
+      #
+      # @param [Symbol] unit_provider
+      # @return [undefined]
+      def use_unit_provider(unit_provider)
+        @unit_provider = unit_provider
+      end
+
+    protected
+
+      # @return [undefined]
+      def populate_defaults
+        use_event_bus :event_bus
+        use_pessimistic_locking
+        use_unit_provider :unit_provider
+      end
+
+      # @raise [RuntimeError] If no locking manager was configured
+      # @return [LockManager]
+      def build_lock_manager
+        if @lock_manager
+          resolve @lock_manager
+        elsif @lock_manager_type
+          @lock_manager_type.new
+        else
+          raise 'No lock manager was configured for this repository'
+        end
+      end
+
+      # Injects the dependencies required by the base repository class
+      #
+      # @param [Repository] repository
+      # @return [Repository]
+      def inject_base_dependencies(repository)
+        repository.event_bus = resolve @event_bus
+        repository.unit_provider = resolve @unit_provider
+
+        repository
+      end
+    end # LockingRepositoryDefinitionBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/repository/simple_repository.rb

@@ -0,0 +1,31 @@
+module Synapse
+  module Configuration
+    # Definition builder used to create simple aggregate repositories
+    #
+    # @example The minimum possible effort to build a simple repository
+    #   simple_repository :user_repository do
+    #     use_aggregate_type User
+    #   end
+    class SimpleRepositoryDefinitionBuilder < LockingRepositoryDefinitionBuilder
+      # @param [Class] aggregate_type
+      # @return [undefined]
+      def use_aggregate_type(aggregate_type)
+        @aggregate_type = aggregate_type
+      end
+
+    protected
+
+      # @return [undefined]
+      def populate_defaults
+        super
+
+        use_factory do
+          lock_manager = build_lock_manager
+
+          repository = Repository::SimpleRepository.new lock_manager, @aggregate_type
+          inject_base_dependencies repository
+        end
+      end
+    end # SimpleRepositoryDefinitionBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/repository.rb

@@ -0,0 +1,15 @@
+module Synapse
+  module Configuration
+    class ContainerBuilder
+      # Creates and configures a simple repository
+      #
+      # @see SimpleRepositoryDefinitionBuilder
+      # @param [Symbol] identifier
+      # @param [Proc] block
+      # @return [undefined]
+      def simple_repository(identifier = nil, &block)
+        with_definition_builder SimpleRepositoryDefinitionBuilder, identifier, &block
+      end
+    end # ContainerBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/serialization/converter_factory.rb

@@ -0,0 +1,50 @@
+module Synapse
+  module Configuration
+    # Definition builder used to create a converter factory
+    #
+    # @example The minimum possible effort to build a converter factory
+    #   converter_factory
+    #
+    # @example Create a converter factory using a different identifier and different converter tag
+    #   converter_factory :alt_converter_factory do
+    #     use_converter_tag :alt_converter
+    #   end
+    #
+    # @example Register several converters that will be picked up by a converter factory
+    #   factory :xml2ox_converter, :tag => :converter do
+    #     Serialization::XmlToOxDocumentConverter.new
+    #   end
+    #
+    #   factory :ox2xml_converter, :tag => :converter do
+    #     Serialization::OxDocumentToXmlConverter.new
+    #   end
+    class ConverterFactoryDefinitionBuilder < DefinitionBuilder
+      # Changes the tag to use to automatically register converters
+      #
+      # @param [Symbol] converter_tag
+      # @return [undefined]
+      def use_converter_tag(converter_tag)
+        @converter_tag = converter_tag
+      end
+
+    protected
+
+      # @return [undefined]
+      def populate_defaults
+        identified_by :converter_factory
+
+        use_converter_tag :converter
+
+        use_factory do
+          converter_factory = Serialization::ConverterFactory.new
+          
+          with_tagged @converter_tag do |converter|
+            converter_factory.register converter
+          end
+
+          converter_factory
+        end
+      end
+    end # ConverterFactoryDefinitionBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/serialization/serializer.rb

@@ -0,0 +1,90 @@
+module Synapse
+  module Configuration
+    # Definition builder used to create and configure serializers
+    #
+    # @example The minimum possible to create a serializer (defaults to marshal)
+    #   serializer
+    #
+    # @example Use a specific serializer and converter_factory
+    #   serializer :alt_serializer do
+    #     use_ox
+    #     use_converter_factory :alt_converter_factory
+    #   end
+    class SerializerDefinitionBuilder < DefinitionBuilder
+      # Selects a serializer that uses attributes (ActiveModel, Virtus, etc.)
+      # @return [undefined]
+      def use_attribute
+        @serializer_type = Serialization::AttributeSerializer
+      end
+
+      # Selects a serializer that uses the Ruby marshaling library
+      # @return [undefined]
+      def use_marshal
+        @serializer_type = Serialization::MarshalSerializer
+      end
+
+      # Selects a serializer that uses the Optimized JSON (Oj) serialization library
+      # @return [undefined]
+      def use_oj
+        @serializer_type = Serialization::OjSerializer
+      end
+
+      # Selects a serializer that uses the Optimized XML (Ox) serialization library
+      # @return [undefined]
+      def use_ox
+        @serializer_type = Serialization::OxSerializer
+      end
+
+      # Changes the converter factory
+      #
+      # @param [Symbol] converter_factory
+      # @return [undefined]
+      def use_converter_factory(converter_factory)
+        @converter_factory = converter_factory
+      end
+
+      # Changes the options to use during serialization; note that these are serializer-specific
+      # and that not all serializers support options.
+      #
+      # @param [Hash] serialize_options
+      # @return [undefined]
+      def use_serialize_options(serialize_options)
+        @serialize_options = serialize_options
+      end
+
+      # Changes the options to use during deserialization; note that these are serializer-specific
+      # and that not all serializers support options.
+      #
+      # @param [Hash] deserialize_options
+      # @return [undefined]
+      def use_deserialize_options(deserialize_options)
+        @deserialize_options = deserialize_options
+      end
+
+    protected
+
+      # @return [undefined]
+      def populate_defaults
+        identified_by :serializer
+
+        use_marshal
+        use_converter_factory :converter_factory
+
+        use_factory do
+          converter_factory = resolve @converter_factory
+          serializer = @serializer_type.new converter_factory
+
+          if @serialize_options
+            serializer.serialize_options = @serialize_options
+          end
+
+          if @deserialize_options
+            serializer.deserialize_options = @deserialize_options
+          end
+
+          serializer
+        end
+      end
+    end # SerializerDefinitionBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/serialization.rb

@@ -0,0 +1,25 @@
+module Synapse
+  module Configuration
+    class ContainerBuilder
+      # Creates and configures a converter factory for serialization
+      #
+      # @see ConverterFactoryDefinitionBuilder
+      # @param [Symbol] identifier
+      # @param [Proc] block
+      # @return [undefined]
+      def converter_factory(identifier = nil, &block)
+        with_definition_builder ConverterFactoryDefinitionBuilder, identifier, &block
+      end
+
+      # Creates and configures a serializer for partitioning, event storage, etc.
+      #
+      # @see SerializerDefinitionBuilder
+      # @param [Symbol] identifier
+      # @param [Proc] block
+      # @return [undefined]
+      def serializer(identifier = nil, &block)
+        with_definition_builder SerializerDefinitionBuilder, identifier, &block
+      end
+    end # ContainerBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/uow/unit_factory.rb

@@ -0,0 +1,51 @@
+module Synapse
+  module Configuration
+    # Definition builder used to create a unit of work factory
+    #
+    # @example The minimum possible effort to build a unit of work factory
+    #   unit_factory
+    #
+    # @example Create a factory with a specific unit provider and tx manager
+    #   unit_factory :alt_unit_factory do
+    #     use_transaction_manager :sequel_tx_manager
+    #     use_unit_provider :alt_unit_provider
+    #   end
+    class UnitOfWorkFactoryDefinitionBuilder < DefinitionBuilder
+      # Changes the transaction manager to use when creating units of work
+      #
+      # @param [Symbol] tx_manager
+      # @return [undefined]
+      def use_transaction_manager(tx_manager)
+        @tx_manager = tx_manager
+      end
+
+      # Changes the unit of work provider to use when creating units of work
+      #
+      # @param [Symbol] unit_provider
+      # @return [undefined]
+      def use_unit_provider(unit_provider)
+        @unit_provider = unit_provider
+      end
+
+    protected
+
+      # @return [undefined]
+      def populate_defaults
+        identified_by :unit_factory
+
+        use_transaction_manager :transaction_manager
+        use_unit_provider :unit_provider
+
+        use_factory do
+          tx_manager = resolve @tx_manager, true
+          unit_provider = resolve @unit_provider
+
+          unit_factory = UnitOfWork::UnitOfWorkFactory.new unit_provider
+          unit_factory.transaction_manager = tx_manager
+          
+          unit_factory
+        end
+      end
+    end # UnitOfWorkFactoryDefinitionBuilder
+  end # Configuration
+end

data/lib/synapse/configuration/component/uow.rb

@@ -0,0 +1,22 @@
+module Synapse
+  module Configuration
+    class ContainerBuilder
+      initializer do
+        # Configures the default unit of work provider implementation
+        factory :unit_provider do
+          UnitOfWork::UnitOfWorkProvider.new
+        end
+      end
+
+      # Creates and configures a unit of work factory
+      #
+      # @see UnitOfWorkFactoryDefinitionBuilder
+      # @param [Symbol] identifier
+      # @param [Proc] block
+      # @return [undefined]
+      def unit_factory(identifier = nil, &block)
+        with_definition_builder UnitOfWorkFactoryDefinitionBuilder, identifier, &block
+      end
+    end # ContainerBuilder
+  end # Configuration
+end