Exemple #1
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CommandProcessor"/> class.
 /// Use this constructor when both task queue and command processor support is required, and you want to inject a test logger
 /// </summary>
 /// <param name="subscriberRegistry">The subscriber registry.</param>
 /// <param name="handlerFactory">The handler factory.</param>
 /// <param name="asyncHandlerFactory">The async handler factory.</param>
 /// <param name="requestContextFactory">The request context factory.</param>
 /// <param name="policyRegistry">The policy registry.</param>
 /// <param name="mapperRegistry">The mapper registry.</param>
 /// <param name="messageStore">The message store.</param>
 /// <param name="asyncMessageStore">The message store supporting async/await.</param>
 /// <param name="messageProducer">The messaging gateway.</param>
 /// <param name="asyncMessageProducer">The messaging gateway supporting async/await.</param>
 /// <param name="messageStoreTimeout">How long should we wait to write to the message store</param>
 /// <param name="messageGatewaySendTimeout">How long should we wait to post to the message store</param>
 public CommandProcessor(
     IAmASubscriberRegistry subscriberRegistry,
     IAmAHandlerFactory handlerFactory,
     IAmAHandlerFactoryAsync asyncHandlerFactory,
     IAmARequestContextFactory requestContextFactory,
     IAmAPolicyRegistry policyRegistry,
     IAmAMessageMapperRegistry mapperRegistry,
     IAmAMessageStore <Message> messageStore,
     IAmAMessageStoreAsync <Message> asyncMessageStore,
     IAmAMessageProducer messageProducer,
     IAmAMessageProducerAsync asyncMessageProducer,
     int messageStoreTimeout       = 300,
     int messageGatewaySendTimeout = 300
     )
     : this(
         subscriberRegistry, handlerFactory, asyncHandlerFactory, requestContextFactory, policyRegistry,
         mapperRegistry, messageStore, asyncMessageStore, messageProducer, asyncMessageProducer,
         LogProvider.GetCurrentClassLogger())
 {
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="CommandProcessor"/> class.
 /// Use this constructor when both task queue and command processor support is required
 /// </summary>
 /// <param name="subscriberRegistry">The subscriber registry.</param>
 /// <param name="asyncHandlerFactory">The async handler factory.</param>
 /// <param name="requestContextFactory">The request context factory.</param>
 /// <param name="policyRegistry">The policy registry.</param>
 /// <param name="mapperRegistry">The mapper registry.</param>
 /// <param name="asyncOutbox">The outbox supporting async/await.</param>
 /// <param name="asyncMessageProducer">The messaging gateway supporting async/await.</param>
 /// <param name="outboxTimeout">How long should we wait to write to the outbox</param>
 /// <param name="featureSwitchRegistry">The feature switch config provider.</param>
 /// <param name="inboxConfiguration">Do we want to insert an inbox handler into pipelines without the attribute. Null (default = no), yes = how to configure</param>
 public CommandProcessor(
     IAmASubscriberRegistry subscriberRegistry,
     IAmAHandlerFactoryAsync asyncHandlerFactory,
     IAmARequestContextFactory requestContextFactory,
     IPolicyRegistry <string> policyRegistry,
     IAmAMessageMapperRegistry mapperRegistry,
     IAmAnOutboxAsync <Message> asyncOutbox,
     IAmAMessageProducerAsync asyncMessageProducer,
     int outboxTimeout = 300,
     IAmAFeatureSwitchRegistry featureSwitchRegistry = null,
     InboxConfiguration inboxConfiguration           = null)
     : this(subscriberRegistry, asyncHandlerFactory, requestContextFactory, policyRegistry, featureSwitchRegistry)
 {
     _mapperRegistry        = mapperRegistry;
     _asyncOutbox           = asyncOutbox;
     _asyncMessageProducer  = asyncMessageProducer;
     _outboxTimeout         = outboxTimeout;
     _featureSwitchRegistry = featureSwitchRegistry;
     _inboxConfiguration    = inboxConfiguration;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="CommandProcessor"/> class.
 /// Use this constructor when both rpc and command processor support is required
 /// </summary>
 /// <param name="subscriberRegistry">The subscriber registry.</param>
 /// <param name="handlerFactory">The handler factory.</param>
 /// <param name="requestContextFactory">The request context factory.</param>
 /// <param name="policyRegistry">The policy registry.</param>
 /// <param name="mapperRegistry">The mapper registry.</param>
 /// <param name="messageProducer">The messaging gateway.</param>
 /// <param name="responseChannelFactory">If we are expecting a response, then we need a channel to listen on</param>
 /// <param name="outboxTimeout">How long should we wait to write to the outbox</param>
 /// <param name="featureSwitchRegistry">The feature switch config provider.</param>
 /// <param name="inboxConfiguration">Do we want to insert an inbox handler into pipelines without the attribute. Null (default = no), yes = how to configure</param>
 public CommandProcessor(
     IAmASubscriberRegistry subscriberRegistry,
     IAmAHandlerFactory handlerFactory,
     IAmARequestContextFactory requestContextFactory,
     IPolicyRegistry <string> policyRegistry,
     IAmAMessageMapperRegistry mapperRegistry,
     IAmAMessageProducer messageProducer,
     int outboxTimeout = 300,
     IAmAFeatureSwitchRegistry featureSwitchRegistry = null,
     IAmAChannelFactory responseChannelFactory       = null,
     InboxConfiguration inboxConfiguration           = null)
     : this(subscriberRegistry, handlerFactory, requestContextFactory, policyRegistry)
 {
     _mapperRegistry         = mapperRegistry;
     _messageProducer        = messageProducer;
     _outboxTimeout          = outboxTimeout;
     _featureSwitchRegistry  = featureSwitchRegistry;
     _responseChannelFactory = responseChannelFactory;
     _inboxConfiguration     = inboxConfiguration;
 }
Exemple #4
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CommandProcessor"/> class.
 /// Use this constructor when both task queue and command processor support is required, and you want to inject a test logger
 /// </summary>
 /// <param name="subscriberRegistry">The subscriber registry.</param>
 /// <param name="handlerFactory">The handler factory.</param>
 /// <param name="asyncHandlerFactory">The async handler factory.</param>
 /// <param name="requestContextFactory">The request context factory.</param>
 /// <param name="policyRegistry">The policy registry.</param>
 /// <param name="mapperRegistry">The mapper registry.</param>
 /// <param name="messageStore">The message store.</param>
 /// <param name="asyncMessageStore">The message store supporting async/await.</param>
 /// <param name="messageProducer">The messaging gateway.</param>
 /// <param name="asyncMessageProducer">The messaging gateway supporting async/await.</param>
 /// <param name="messageStoreTimeout">How long should we wait to write to the message store</param>
 public CommandProcessor(
     IAmASubscriberRegistry subscriberRegistry,
     IAmAHandlerFactory handlerFactory,
     IAmAHandlerFactoryAsync asyncHandlerFactory,
     IAmARequestContextFactory requestContextFactory,
     IAmAPolicyRegistry policyRegistry,
     IAmAMessageMapperRegistry mapperRegistry,
     IAmAMessageStore <Message> messageStore,
     IAmAMessageStoreAsync <Message> asyncMessageStore,
     IAmAMessageProducer messageProducer,
     IAmAMessageProducerAsync asyncMessageProducer,
     int messageStoreTimeout = 300)
     : this(subscriberRegistry, handlerFactory, asyncHandlerFactory, requestContextFactory, policyRegistry)
 {
     _mapperRegistry       = mapperRegistry;
     _messageStore         = messageStore;
     _asyncMessageStore    = asyncMessageStore;
     _messageProducer      = messageProducer;
     _asyncMessageProducer = asyncMessageProducer;
     _messageStoreTimeout  = messageStoreTimeout;
 }
Exemple #5
0
        /// <summary>
        /// Initializes a new instance of the <see cref="CommandProcessor"/> class.
        /// Use this constructor when both external bus and command processor support is required
        /// </summary>
        /// <param name="subscriberRegistry">The subscriber registry.</param>
        /// <param name="handlerFactory">The handler factory.</param>
        /// <param name="requestContextFactory">The request context factory.</param>
        /// <param name="policyRegistry">The policy registry.</param>
        /// <param name="mapperRegistry">The mapper registry.</param>
        /// <param name="outBox">The outbox.</param>
        /// <param name="producerRegistry">The register of producers via whom we send messages over the external bus</param>
        /// <param name="outboxTimeout">How long should we wait to write to the outbox</param>
        /// <param name="featureSwitchRegistry">The feature switch config provider.</param>
        /// <param name="inboxConfiguration">Do we want to insert an inbox handler into pipelines without the attribute. Null (default = no), yes = how to configure</param>
        /// <param name="boxTransactionConnectionProvider">The Box Connection Provider to use when Depositing into the outbox.</param>
        public CommandProcessor(
            IAmASubscriberRegistry subscriberRegistry,
            IAmAHandlerFactory handlerFactory,
            IAmARequestContextFactory requestContextFactory,
            IPolicyRegistry <string> policyRegistry,
            IAmAMessageMapperRegistry mapperRegistry,
            IAmAnOutbox <Message> outBox,
            IAmAProducerRegistry producerRegistry,
            int outboxTimeout = 300,
            IAmAFeatureSwitchRegistry featureSwitchRegistry = null,
            InboxConfiguration inboxConfiguration           = null,
            IAmABoxTransactionConnectionProvider boxTransactionConnectionProvider = null)
            : this(subscriberRegistry, handlerFactory, requestContextFactory, policyRegistry, featureSwitchRegistry)
        {
            _mapperRegistry     = mapperRegistry;
            _inboxConfiguration = inboxConfiguration;
            _boxTransactionConnectionProvider = boxTransactionConnectionProvider;

            InitExtServiceBus(policyRegistry, outBox, outboxTimeout, producerRegistry);

            ConfigureCallbacks(producerRegistry);
        }
Exemple #6
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CommandProcessor"/> class.
 /// Use this constructor when both task queue and command processor support is required, and you want to inject a test logger
 /// </summary>
 /// <param name="subscriberRegistry">The subscriber registry.</param>
 /// <param name="handlerFactory">The handler factory.</param>
 /// <param name="asyncHandlerFactory">The async handler factory.</param>
 /// <param name="requestContextFactory">The request context factory.</param>
 /// <param name="policyRegistry">The policy registry.</param>
 /// <param name="mapperRegistry">The mapper registry.</param>
 /// <param name="outBox">The outbox.</param>
 /// <param name="asyncOutbox">The message store supporting async/await.</param>
 /// <param name="messageProducer">The messaging gateway.</param>
 /// <param name="asyncMessageProducer">The messaging gateway supporting async/await.</param>
 /// <param name="messageStoreTimeout">How long should we wait to write to the message store</param>
 /// <param name="featureSwitchRegistry">The feature switch config provider.</param>
 public CommandProcessor(
     IAmASubscriberRegistry subscriberRegistry,
     IAmAHandlerFactory handlerFactory,
     IAmAHandlerFactoryAsync asyncHandlerFactory,
     IAmARequestContextFactory requestContextFactory,
     IPolicyRegistry <string> policyRegistry,
     IAmAMessageMapperRegistry mapperRegistry,
     IAmAnOutbox <Message> outBox,
     IAmAnOutboxAsync <Message> asyncOutbox,
     IAmAMessageProducer messageProducer,
     IAmAMessageProducerAsync asyncMessageProducer,
     int messageStoreTimeout = 300,
     IAmAFeatureSwitchRegistry featureSwitchRegistry = null)
     : this(subscriberRegistry, handlerFactory, asyncHandlerFactory, requestContextFactory, policyRegistry, featureSwitchRegistry)
 {
     _mapperRegistry       = mapperRegistry;
     _outBox               = outBox;
     _asyncOutbox          = asyncOutbox;
     _messageProducer      = messageProducer;
     _asyncMessageProducer = asyncMessageProducer;
     _messageStoreTimeout  = messageStoreTimeout;
 }
Exemple #7
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CommandProcessor"/> class.
 /// Use this constructor when no external bus is required and only sync handlers are needed
 /// </summary>
 /// <param name="subscriberRegistry">The subscriber registry.</param>
 /// <param name="handlerFactory">The handler factory.</param>
 /// <param name="requestContextFactory">The request context factory.</param>
 /// <param name="policyRegistry">The policy registry.</param>
 /// <param name="featureSwitchRegistry">The feature switch config provider.</param>
 /// <param name="inboxConfiguration">Do we want to insert an inbox handler into pipelines without the attribute. Null (default = no), yes = how to configure</param>
 public CommandProcessor(
     IAmASubscriberRegistry subscriberRegistry,
     IAmAHandlerFactory handlerFactory,
     IAmARequestContextFactory requestContextFactory,
     IPolicyRegistry <string> policyRegistry,
     IAmAFeatureSwitchRegistry featureSwitchRegistry = null,
     InboxConfiguration inboxConfiguration           = null
     )
 {
     _subscriberRegistry = subscriberRegistry;
     if (handlerFactory is IAmAHandlerFactorySync handlerFactorySync)
     {
         _handlerFactorySync = handlerFactorySync;
     }
     if (handlerFactory is IAmAHandlerFactoryAsync handlerFactoryAsync)
     {
         _handlerFactoryAsync = handlerFactoryAsync;
     }
     _requestContextFactory = requestContextFactory;
     _policyRegistry        = policyRegistry;
     _featureSwitchRegistry = featureSwitchRegistry;
     _inboxConfiguration    = inboxConfiguration;
 }
Exemple #8
0
 internal Interpreter(IAmASubscriberRegistry registry, IAmAHandlerFactoryAsync asyncHandlerFactory)
     : this(registry, null, asyncHandlerFactory)
 {
 }
Exemple #9
0
 /// <summary>
 /// Initializes a new instance of the <see cref="HandlerConfiguration"/> class.
 /// We use the <see cref="IAmASubscriberRegistry"/> instance to look up subscribers for messages when dispatching. Use <see cref="SubscriberRegistry"/> unless
 /// you have some reason to override. We expect a <see cref="CommandProcessor.Send{T}(T)"/> to have one registered handler
 /// We use the
 /// </summary>
 /// <param name="subscriberRegistry">The subscriber registry.</param>
 /// <param name="handlerFactory">The handler factory.</param>
 public HandlerConfiguration(IAmASubscriberRegistry subscriberRegistry, IAmAHandlerFactory handlerFactory)
 {
     SubscriberRegistry = subscriberRegistry;
     HandlerFactory     = handlerFactory;
 }
 /// <summary>
 /// Supplies the specified handler configuration, so that we can register subscribers and the handler factory used to create instances of them
 /// </summary>
 /// <param name="handlerConfiguration">The handler configuration.</param>
 /// <returns>INeedPolicy.</returns>
 public INeedPolicy Handlers(HandlerConfiguration handlerConfiguration)
 {
     registry       = handlerConfiguration.SubscriberRegistry;
     handlerFactory = handlerConfiguration.HandlerFactory;
     return(this);
 }
Exemple #11
0
 /// <summary>
 /// Initializes a new instance of the <see cref="HandlerConfiguration"/> class.
 /// We use the <see cref="IAmASubscriberRegistry"/> instance to look up subscribers for messages when dispatching. Use <see cref="SubscriberRegistry"/> unless
 /// you have some reason to override. We expect a <see cref="CommandProcessor.Send{T}(T)"/> to have one registered handler
 /// We use the
 /// </summary>
 /// <param name="subscriberRegistry">The subscriber registry.</param>
 /// <param name="asyncHandlerFactory">The async handler factory.</param>
 public HandlerConfiguration(IAmASubscriberRegistry subscriberRegistry, IAmAHandlerFactoryAsync asyncHandlerFactory)
 {
     SubscriberRegistry  = subscriberRegistry;
     AsyncHandlerFactory = asyncHandlerFactory;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="HandlerConfiguration"/> class.
 /// We use the <see cref="IAmASubscriberRegistry"/> instance to look up subscribers for messages when dispatching. Use <see cref="SubscriberRegistry"/> unless
 /// you have some reason to override. We expect a <see cref="CommandProcessor.Send{T}(T)"/> to have one registered handler
 /// We use the 
 /// </summary>
 /// <param name="subscriberRegistry">The subscriber registry.</param>
 /// <param name="handlerFactory">The handler factory.</param>
 /// <param name="asyncHandlerFactory">The async handler factory.</param>
 public HandlerConfiguration(IAmASubscriberRegistry subscriberRegistry, IAmAHandlerFactory handlerFactory, IAmAnAsyncHandlerFactory asyncHandlerFactory)
 {
     SubscriberRegistry = subscriberRegistry;
     HandlerFactory = handlerFactory;
     AsyncHandlerFactory = asyncHandlerFactory;
 }
 /// <summary>
 /// Supplies the specified handler configuration, so that we can register subscribers and the handler factory used to create instances of them
 /// </summary>
 /// <param name="handlerConfiguration">The handler configuration.</param>
 /// <returns>INeedPolicy.</returns>
 public INeedPolicy Handlers(HandlerConfiguration handlerConfiguration)
 {
     _registry = handlerConfiguration.SubscriberRegistry;
     _handlerFactory = handlerConfiguration.HandlerFactory;
     return this;
 }
Exemple #14
0
 public PipelineBuilder(IAmASubscriberRegistry registry, IAmAHandlerFactoryAsync asyncHandlerFactory)
 {
     _asyncHandlerFactory = asyncHandlerFactory;
     _instanceScope       = new LifetimeScope(asyncHandlerFactory);
     _interpreter         = new Interpreter <TRequest>(registry, asyncHandlerFactory);
 }
Exemple #15
0
 internal PipelineBuilder(IAmASubscriberRegistry registry, IAmAHandlerFactory handlerFactory)
     : this(registry, handlerFactory, LogProvider.GetCurrentClassLogger())
 {
 }
Exemple #16
0
 internal Interpreter(IAmASubscriberRegistry registry, IAmAHandlerFactory handlerFactory, IAmAHandlerFactoryAsync asyncHandlerFactory)
 {
     _registry            = registry;
     _handlerFactory      = handlerFactory;
     _asyncHandlerFactory = asyncHandlerFactory;
 }
Exemple #17
0
 internal PipelineBuilder(IAmASubscriberRegistry registry, IAmAHandlerFactoryAsync asyncHandlerFactory)
     : this(registry, asyncHandlerFactory, LogProvider.For <PipelineBuilder <TRequest> >())
 {
 }
Exemple #18
0
 internal Interpreter(IAmASubscriberRegistry registry, IAmAHandlerFactory handlerFactory)
     : this(registry, handlerFactory, null)
 {
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="Interpreter{TRequest}"/> class.
 /// </summary>
 /// <param name="registry">The registry.</param>
 /// <param name="handlerFactory">The handler factory.</param>
 internal Interpreter(IAmASubscriberRegistry registry, IAmAHandlerFactory handlerFactory)
 {
     this.registry       = registry;
     this.handlerFactory = handlerFactory;
 }