public Worker(IErrorTracker errorTracker, IReceiveMessages receiveMessages, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, ISerializeMessages serializeMessages, IStoreSagaData storeSagaData, IInspectHandlerPipeline inspectHandlerPipeline, string workerThreadName, IHandleDeferredMessage handleDeferredMessage, IMutateIncomingMessages mutateIncomingMessages, IStoreTimeouts storeTimeouts, IEnumerable <IUnitOfWorkManager> unitOfWorkManagers, ConfigureAdditionalBehavior configureAdditionalBehavior, MessageLogger messageLogger) { this.receiveMessages = receiveMessages; this.serializeMessages = serializeMessages; this.mutateIncomingMessages = mutateIncomingMessages; this.unitOfWorkManagers = unitOfWorkManagers; this.configureAdditionalBehavior = configureAdditionalBehavior; this.messageLogger = messageLogger; this.errorTracker = errorTracker; dispatcher = new Dispatcher(storeSagaData, activateHandlers, storeSubscriptions, inspectHandlerPipeline, handleDeferredMessage, storeTimeouts); dispatcher.UncorrelatedMessage += RaiseUncorrelatedMessage; nullMessageReceivedBackoffHelper = CreateBackoffHelper(configureAdditionalBehavior.BackoffBehavior); workerThread = new Thread(MainLoop) { Name = workerThreadName }; workerThread.Start(); log.Info("Worker {0} created and inner thread started", WorkerThreadName); }
public Worker(IErrorTracker errorTracker, IReceiveMessages receiveMessages, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, ISerializeMessages serializeMessages, IStoreSagaData storeSagaData, IInspectHandlerPipeline inspectHandlerPipeline, string workerThreadName, IHandleDeferredMessage handleDeferredMessage, IMutateIncomingMessages mutateIncomingMessages) { this.receiveMessages = receiveMessages; this.serializeMessages = serializeMessages; this.mutateIncomingMessages = mutateIncomingMessages; this.errorTracker = errorTracker; dispatcher = new Dispatcher(storeSagaData, activateHandlers, storeSubscriptions, inspectHandlerPipeline, handleDeferredMessage); dispatcher.UncorrelatedMessage += RaiseUncorrelatedMessage; workerThread = new Thread(MainLoop) { Name = workerThreadName }; workerThread.Start(); log.Info("Worker {0} created and inner thread started", WorkerThreadName); }
/// <summary> /// Constructs the dispatcher with the specified instances to store and retrieve saga data, /// create message handlers, store and retrieve subscriptions, and to inspect and /// possibly rearrange the handler pipeline. /// </summary> public Dispatcher(IStoreSagaData storeSagaData, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, IInspectHandlerPipeline inspectHandlerPipeline, IHandleDeferredMessage handleDeferredMessage) { this.storeSagaData = storeSagaData; this.activateHandlers = activateHandlers; this.storeSubscriptions = storeSubscriptions; this.inspectHandlerPipeline = inspectHandlerPipeline; this.handleDeferredMessage = handleDeferredMessage; }
protected override void DoSetUp() { activateHandlers = new HandlerActivatorForTesting(); determineDestination = Mock <IDetermineDestination>(); sendMessages = Mock <ISendMessages>(); serializeMessages = new JsonMessageSerializer(); storeSagaData = Mock <IStoreSagaData>(); receiveMessages = new MessageReceiverForTesting(serializeMessages); inspectHandlerPipeline = new TrivialPipelineInspector(); storeSubscriptions = Mock <IStoreSubscriptions>(); bus = CreateTheBus(); bus.Start(); }
protected override void DoSetUp() { activateHandlers = new HandlerActivatorForTesting(); determineMessageOwnership = Mock<IDetermineMessageOwnership>(); sendMessages = Mock<ISendMessages>(); serializeMessages = new JsonMessageSerializer(); storeSagaData = Mock<IStoreSagaData>(); receiveMessages = new MessageReceiverForTesting(serializeMessages); inspectHandlerPipeline = new TrivialPipelineInspector(); storeSubscriptions = Mock<IStoreSubscriptions>(); bus = CreateTheBus(); bus.Start(); }
/// <summary> /// Constructs the bus with the specified ways of achieving its goals. /// </summary> /// <param name="activateHandlers">The bus will use this to construct handlers for received messages.</param> /// <param name="sendMessages">Will be used to send transport messages when you send, publish, and reply.</param> /// <param name="receiveMessages">Will be used to receive transport messages. If the bus is configured to run with multiple threads, this one should be reentrant.</param> /// <param name="storeSubscriptions">Will be used to store subscription information. Is only relevant if the bus is a publisher, i.e. it publishes messages and other services assume they can subscribe to its messages.</param> /// <param name="storeSagaData">Will be used to store saga data. Is only relevant if one or more handlers are derived from <see cref="Saga"/>.</param> /// <param name="determineDestination">Will be used to resolve a destination in cases where the message destination is not explicitly specified as part of a send/subscribe operation.</param> /// <param name="serializeMessages">Will be used to serialize and deserialize transport messages.</param> /// <param name="inspectHandlerPipeline">Will be called to inspect the pipeline of handlers constructed to handle an incoming message.</param> public RebusBus(IActivateHandlers activateHandlers, ISendMessages sendMessages, IReceiveMessages receiveMessages, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, IDetermineDestination determineDestination, ISerializeMessages serializeMessages, IInspectHandlerPipeline inspectHandlerPipeline) { this.activateHandlers = activateHandlers; this.sendMessages = sendMessages; this.receiveMessages = receiveMessages; this.storeSubscriptions = storeSubscriptions; this.determineDestination = determineDestination; this.serializeMessages = serializeMessages; this.storeSagaData = storeSagaData; this.inspectHandlerPipeline = inspectHandlerPipeline; rebusId = Interlocked.Increment(ref rebusIdCounter); log.Info("Rebus bus created"); }
public MessageBus( ITransportMessages transport, IStoreSubscriptions subscriptions, IDictionary<Type, ICollection<Uri>> recipients, IMessageContext context, MessageBuilder builder, IDiscoverMessageTypes discoverer) { this.transport = transport; this.subscriptions = subscriptions; this.recipients = recipients; this.context = context; this.builder = builder; this.discoverer = discoverer; }
public MessageBus( ITransportMessages transport, IStoreSubscriptions subscriptions, IDictionary <Type, ICollection <Uri> > recipients, IMessageContext context, MessageBuilder builder, IDiscoverMessageTypes discoverer) { this.transport = transport; this.subscriptions = subscriptions; this.recipients = recipients; this.context = context; this.builder = builder; this.discoverer = discoverer; }
/// <summary> /// Constructs the dispatcher with the specified instances to store and retrieve saga data, /// create message handlers, store and retrieve subscriptions, and to inspect and /// possibly rearrange the handler pipeline. /// </summary> public Dispatcher(IStoreSagaData storeSagaData, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, IInspectHandlerPipeline inspectHandlerPipeline, IHandleDeferredMessage handleDeferredMessage, IStoreTimeouts storeTimeouts) { this.storeSagaData = storeSagaData; this.activateHandlers = activateHandlers; this.storeSubscriptions = storeSubscriptions; this.inspectHandlerPipeline = inspectHandlerPipeline; this.handleDeferredMessage = handleDeferredMessage; this.storeTimeouts = storeTimeouts; sagaDataIdPropertyName = Reflect.Path <ISagaData>(s => s.Id); sagaDataPropertyName = Reflect.Path <Saga <ISagaData> >(s => s.Data); }
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, string errorQueueName) { var messageQueue = new MsmqMessageQueue(inputQueueName).PurgeInputQueue(); MsmqUtil.PurgeQueue(errorQueueName); serializer = new JsonMessageSerializer(); var bus = new RebusBus(activateHandlers, messageQueue, messageQueue, storeSubscriptions, storeSagaData, this, serializer, pipelineInspector, new ErrorTracker(errorQueueName), null, new ConfigureAdditionalBehavior()); EnsureProperDisposal(bus); EnsureProperDisposal(messageQueue); return bus; }
protected BuiltinContainerAdapter CreateBus(string inputQueueName, IStoreSubscriptions subscriptionStorage) { MsmqUtil.PurgeQueue(inputQueueName); MsmqUtil.PurgeQueue("error"); var adapter = new BuiltinContainerAdapter(); EnsureProperDisposal(adapter); Configure.With(adapter) .Transport(t => t.UseMsmq(inputQueueName, "error")) .MessageOwnership(o => o.Use(this)) .CreateBus() .Start(1); return(adapter); }
/// <summary> /// Constructs the bus with the specified ways of achieving its goals. /// </summary> /// <param name="activateHandlers">The bus will use this to construct handlers for received messages.</param> /// <param name="sendMessages">Will be used to send transport messages when you send, publish, and reply.</param> /// <param name="receiveMessages">Will be used to receive transport messages. If the bus is configured to run with multiple threads, this one should be reentrant.</param> /// <param name="storeSubscriptions">Will be used to store subscription information. Is only relevant if the bus is a publisher, i.e. it publishes messages and other services assume they can subscribe to its messages.</param> /// <param name="storeSagaData">Will be used to store saga data. Is only relevant if one or more handlers are derived from <see cref="Saga"/>.</param> /// <param name="determineDestination">Will be used to resolve a destination in cases where the message destination is not explicitly specified as part of a send/subscribe operation.</param> /// <param name="serializeMessages">Will be used to serialize and deserialize transport messages.</param> /// <param name="inspectHandlerPipeline">Will be called to inspect the pipeline of handlers constructed to handle an incoming message.</param> /// <param name="errorTracker">Will be used to track failed delivery attempts.</param> public RebusBus(IActivateHandlers activateHandlers, ISendMessages sendMessages, IReceiveMessages receiveMessages, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, IDetermineDestination determineDestination, ISerializeMessages serializeMessages, IInspectHandlerPipeline inspectHandlerPipeline, IErrorTracker errorTracker) { this.activateHandlers = activateHandlers; this.sendMessages = sendMessages; this.receiveMessages = receiveMessages; this.storeSubscriptions = storeSubscriptions; this.determineDestination = determineDestination; this.serializeMessages = serializeMessages; this.storeSagaData = storeSagaData; this.inspectHandlerPipeline = inspectHandlerPipeline; this.errorTracker = errorTracker; batch = new RebusBatchOperations(determineDestination, storeSubscriptions, this); routing = new RebusRouting(this); rebusId = Interlocked.Increment(ref rebusIdCounter); log.Info("Rebus bus created"); }
/// <summary> /// Constructs the bus with the specified ways of achieving its goals. /// </summary> /// <param name="activateHandlers">The bus will use this to construct handlers for received messages.</param> /// <param name="sendMessages">Will be used to send transport messages when you send, publish, and reply.</param> /// <param name="receiveMessages">Will be used to receive transport messages. If the bus is configured to run with multiple threads, this one should be reentrant.</param> /// <param name="storeSubscriptions">Will be used to store subscription information. Is only relevant if the bus is a publisher, i.e. it publishes messages and other services assume they can subscribe to its messages.</param> /// <param name="storeSagaData">Will be used to store saga data. Is only relevant if one or more handlers are derived from <see cref="Saga"/>.</param> /// <param name="determineMessageOwnership">Will be used to resolve a destination in cases where the message destination is not explicitly specified as part of a send/subscribe operation.</param> /// <param name="serializeMessages">Will be used to serialize and deserialize transport messages.</param> /// <param name="inspectHandlerPipeline">Will be called to inspect the pipeline of handlers constructed to handle an incoming message.</param> /// <param name="errorTracker">Will be used to track failed delivery attempts.</param> /// <param name="storeTimeouts">Optionally provides an internal timeout manager to be used instead of sending timeout requests to an external timeout manager</param> /// <param name="configureAdditionalBehavior"></param> public RebusBus( IActivateHandlers activateHandlers, ISendMessages sendMessages, IReceiveMessages receiveMessages, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, IDetermineMessageOwnership determineMessageOwnership, ISerializeMessages serializeMessages, IInspectHandlerPipeline inspectHandlerPipeline, IErrorTracker errorTracker, IStoreTimeouts storeTimeouts, ConfigureAdditionalBehavior configureAdditionalBehavior) { this.activateHandlers = activateHandlers; this.sendMessages = sendMessages; this.receiveMessages = receiveMessages; this.storeSubscriptions = storeSubscriptions; this.determineMessageOwnership = determineMessageOwnership; this.serializeMessages = serializeMessages; this.storeSagaData = storeSagaData; this.inspectHandlerPipeline = inspectHandlerPipeline; this.errorTracker = errorTracker; this.storeTimeouts = storeTimeouts; this.configureAdditionalBehavior = configureAdditionalBehavior; batch = new RebusBatchOperations(determineMessageOwnership, storeSubscriptions, this); routing = new RebusRouting(this); rebusId = Interlocked.Increment(ref rebusIdCounter); continuations = new RebusSynchronizationContext(); log.Info("Rebus bus {0} created", rebusId); if (storeTimeouts == null) { var timeoutManagerEndpointAddress = RebusConfigurationSection .GetConfigurationValueOrDefault(s => s.TimeoutManagerAddress, "rebus.timeout"); log.Info("Using external timeout manager with input queue '{0}'", timeoutManagerEndpointAddress); timeoutManagerAddress = timeoutManagerEndpointAddress; } else { log.Info("Using internal timeout manager"); timeoutManagerAddress = this.receiveMessages.InputQueueAddress; dueTimeoutScheduler = new DueTimeoutScheduler(storeTimeouts, new DeferredMessageReDispatcher(this)); } }
public RebusBatchOperations(IDetermineDestination determineDestination, IStoreSubscriptions storeSubscriptions, RebusBus bus) { this.determineDestination = determineDestination; this.storeSubscriptions = storeSubscriptions; this.bus = bus; }
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, string errorQueueName) { var messageQueue = new MsmqMessageQueue(inputQueueName, errorQueueName).PurgeInputQueue(); MsmqUtil.PurgeQueue(errorQueueName); serializer = new JsonMessageSerializer(); var bus = new RebusBus(activateHandlers, messageQueue, messageQueue, storeSubscriptions, storeSagaData, this, serializer, pipelineInspector); toDispose.Add(bus); toDispose.Add(messageQueue); return bus; }
public SubscriptionMessageHandlers(IStoreSubscriptions storage, IMessageContext context) { this.storage = storage; this.subscriberAddress = context.CurrentMessage.ReturnAddress; }
public Worker( IErrorTracker errorTracker, IReceiveMessages receiveMessages, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, ISerializeMessages serializeMessages, IStoreSagaData storeSagaData, IInspectHandlerPipeline inspectHandlerPipeline, string workerThreadName, IHandleDeferredMessage handleDeferredMessage, IMutateIncomingMessages mutateIncomingMessages, IStoreTimeouts storeTimeouts, IEnumerable<IUnitOfWorkManager> unitOfWorkManagers, ConfigureAdditionalBehavior configureAdditionalBehavior, MessageLogger messageLogger, RebusSynchronizationContext continuations) { this.receiveMessages = receiveMessages; this.serializeMessages = serializeMessages; this.mutateIncomingMessages = mutateIncomingMessages; this.unitOfWorkManagers = unitOfWorkManagers; this.configureAdditionalBehavior = configureAdditionalBehavior; this.messageLogger = messageLogger; this.continuations = continuations; this.errorTracker = errorTracker; dispatcher = new Dispatcher(storeSagaData, activateHandlers, storeSubscriptions, inspectHandlerPipeline, handleDeferredMessage, storeTimeouts); dispatcher.UncorrelatedMessage += RaiseUncorrelatedMessage; nullMessageReceivedBackoffHelper = CreateBackoffHelper(configureAdditionalBehavior.BackoffBehavior); workerThread = new Thread(MainLoop) { Name = workerThreadName }; workerThread.Start(); log.Info("Worker {0} created and inner thread started", WorkerThreadName); }
protected override void DoSetUp() { factory = Activator.CreateInstance <TFactory>(); storage = factory.CreateStore(); }
public virtual SubscriptionStorageWireup WithCustomSubscriptionStorage(IStoreSubscriptions storage) { this.customStorage = storage; return(this); }
public RebusBatchOperations(IDetermineMessageOwnership determineMessageOwnership, IStoreSubscriptions storeSubscriptions, RebusBus bus) { this.determineMessageOwnership = determineMessageOwnership; this.storeSubscriptions = storeSubscriptions; this.bus = bus; }
/// <summary> /// Uses the specified implementation of <see cref="IStoreSubscriptions"/> to store /// subscriptions /// </summary> public void Use(IStoreSubscriptions storeSubscriptions) { Backbone.StoreSubscriptions = storeSubscriptions; }
public SubscriptionMessageHandler(IStoreSubscriptions storeSubscriptions) { this.storeSubscriptions = storeSubscriptions; }
public virtual SubscriptionStorageWireup WithInMemorySubscriptionStorage() { this.customStorage = new InMemorySubscriptionStorage(); return this; }
public virtual SubscriptionStorageWireup WithCustomSubscriptionStorage(IStoreSubscriptions storage) { this.customStorage = storage; return this; }
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, string errorQueueName) { var messageQueue = new MsmqMessageQueue(inputQueueName).PurgeInputQueue(); MsmqUtil.PurgeQueue(errorQueueName); serializer = new JsonMessageSerializer(); var bus = new RebusBus(activateHandlers, messageQueue, messageQueue, storeSubscriptions, storeSagaData, this, serializer, pipelineInspector, new ErrorTracker(errorQueueName), null, new ConfigureAdditionalBehavior()); EnsureProperDisposal(bus); EnsureProperDisposal(messageQueue); return(bus); }
protected BuiltinContainerAdapter CreateBus(string inputQueueName, IStoreSubscriptions subscriptionStorage) { MsmqUtil.PurgeQueue(inputQueueName); MsmqUtil.PurgeQueue("error"); var adapter = new BuiltinContainerAdapter(); EnsureProperDisposal(adapter); Configure.With(adapter) .Transport(t => t.UseMsmq(inputQueueName, "error")) .MessageOwnership(o => o.Use(this)) .CreateBus() .Start(1); return adapter; }
public StorageDrivenPublisher(ISendMessages messageSender, IStoreSubscriptions subscriptionStorage) { this.messageSender = messageSender; this.subscriptionStorage = subscriptionStorage; }
public virtual SubscriptionStorageWireup WithInMemorySubscriptionStorage() { this.customStorage = new InMemorySubscriptionStorage(); return(this); }