/// <summary>
/// Creates Amazon Simple Queue Service publisher
/// </summary>
/// <param name="factory"></param>
/// <param name="serviceUrl"></param>
/// <param name="queueName"></param>
/// <param name="regionEndpoint"></param>
/// <returns></returns>
public static IMessagePublisher AmazonSQSMessagePublisher(this IMessagingFactory factory,
string serviceUrl,
string queueName,
RegionEndpoint regionEndpoint = null)
{
return(new AwsS3MessagePublisher(serviceUrl, queueName, regionEndpoint));
}
public AccountController(IUserManagerService <User> userManager, IServiceHelper helper, IPasswordGenerator passwordGenerator, IMessagingFactory messagingFactory) : base(nameof(AccountController))
{
_userManager = userManager;
_helper = helper;
_passwordGenerator = passwordGenerator;
_messagingFactory = messagingFactory;
}
/// <summary>
/// Creates an instance of a receiver from Azure Storage Queues using development storage.
/// </summary>
/// <param name="factory">Factory reference</param>
/// <param name="queueName">Queue name</param>
/// <param name="messageVisibilityTimeout">Message visibility timeout</param>
/// <param name="messagePollingInterval">Storage Queues do not support listening therefore internally we poll for new messages. This parameters
/// indicates how often this happens</param>
/// <returns>Generic message receiver interface</returns>
public static IMessageReceiver AzureDevelopmentStorageQueueReceiver(this IMessagingFactory factory,
string queueName,
TimeSpan messageVisibilityTimeout,
TimeSpan messagePollingInterval)
{
return(new AzureStorageQueueReceiver(queueName, messageVisibilityTimeout, messagePollingInterval));
}
public void Listener_Should_Start_And_Stop_And_Call_MessagingFactory_CreateMessageReceiver()
{
ListenerSettings listenerSettings = CreateDefaultSettings();
ConnectionSettings connSettings = CreateDefaultConnection();
IMessageReceiver receiver = CreateLocalClosedReceiver();
IMessageReceiver receiver2 = CreateLocalReceiver();
var moq1 = new Mock <IMessagingFactory>();
moq1.Setup(x => x.CreateMessageReceiver(It.IsAny <string>(), It.IsAny <ReceiveMode>())).Returns(receiver2);
IMessagingFactory messagingFactory = moq1.Object;
IEventPublisher eventPublisher = new EventPublisher();
Listener target = ListenerFactory.Create(listenerSettings, connSettings, receiver, eventPublisher, messagingFactory);
Assert.AreEqual(ListenerStatus.NotStarted, target.Status);
target.Start();
Assert.AreEqual(ListenerStatus.Running, target.Status);
Thread.Sleep(Constants.ListeningDefaultMilliseconds);
target.Stop();
Assert.AreEqual(ListenerStatus.Stopped, target.Status);
moq1.Verify(x => x.CreateMessageReceiver(It.IsAny <string>(), It.IsAny <ReceiveMode>()), Times.Once());
}
public static IMessagePublisher AzureServiceFabricReliableConcurrentQueuePublisher(
this IMessagingFactory factory,
IReliableStateManager stateManager,
string queueName = null)
{
return(new ServiceFabricReliableConcurrentQueuePublisher(stateManager, queueName ?? DefaultQueueName));
}
/// <summary>
/// Creates an instance of a publisher to Azure Storage Queues
/// </summary>
/// <param name="factory">Factory reference</param>
/// <param name="accountName">Account name</param>
/// <param name="storageKey">Storage key</param>
/// <param name="queueName">Queue name</param>
/// <returns>Generic message publisher interface</returns>
public static IMessagePublisher AzureStorageQueuePublisher(this IMessagingFactory factory,
string accountName,
string storageKey,
string queueName)
{
return(new AzureStorageQueuePublisher(accountName, storageKey, queueName));
}
/// <summary>
/// Creates Amazon Simple Queue Service publisher
/// </summary>
/// <param name="factory"></param>
/// <param name="accessKeyId">Access key ID</param>
/// <param name="secretAccessKey">Secret access key</param>
/// <param name="serviceUrl"></param>
/// <param name="regionEndpoint"></param>
/// <returns></returns>
public static IMessenger AwsSQS(this IMessagingFactory factory,
string accessKeyId,
string secretAccessKey,
string serviceUrl,
RegionEndpoint regionEndpoint = null)
{
return(new AwsSQSMessenger(accessKeyId, secretAccessKey, serviceUrl, regionEndpoint));
}
public ConsumerHostedService(IMessagingFactory messagingFactory, IMessagingService <PingPongExample> messagingService,
ILogger <ConsumerHostedService> logger, IOptions <MessagingConfiguration> messagingConfiguration)
{
_messagingFactory = messagingFactory;
_messagingService = messagingService;
_logger = logger;
_messagingConfiguration = messagingConfiguration.Value;
}
/// <summary>
/// Create a receiver on top of Service Fabric Reliable Concurrent Queue.
/// </summary>
/// <param name="factory"></param>
/// <param name="stateManager"></param>
/// <param name="scanInterval">Due to the fact that queues are scanned, set this value to a scan interval. 1 second is minimum.</param>
/// <param name="queueName">Set queue name, otherwise a default queue name is used.</param>
/// <returns></returns>
public static IMessageReceiver AzureServiceFabricReliableConcurrentQueueReceiver(
this IMessagingFactory factory,
IReliableStateManager stateManager,
TimeSpan scanInterval,
string queueName = null)
{
return(new ServiceFabricReliableConcurrentQueueReceiver(stateManager, queueName ?? DefaultQueueName, scanInterval));
}
public GenericServiceBusConfigurationFactory(IBusConfiguration configuration, IMessagingFactory messageFactory, INamespaceManager namespaceManager) {
Guard.ArgumentNotNull(configuration, "configuration");
Guard.ArgumentNotNull(messageFactory, "messageFactory");
Guard.ArgumentNotNull(namespaceManager, "namespaceManager");
this.configuration = configuration;
this.MessageFactory = messageFactory;
this.NamespaceManager = namespaceManager;
}
/// <summary>
/// Creates an instance of a receiver from Azure Storage Queues
/// </summary>
/// <param name="factory">Factory reference</param>
/// <param name="accountName">Account name</param>
/// <param name="storageKey">Storage key</param>
/// <param name="queueName">Queue name</param>
/// <param name="messageVisibilityTimeout">Message visibility timeout</param>
/// <returns>Generic message receiver interface</returns>
public static IMessageReceiver AzureStorageQueueReceiver(this IMessagingFactory factory,
string accountName,
string storageKey,
string queueName,
TimeSpan messageVisibilityTimeout)
{
return(new AzureStorageQueueReceiver(accountName, storageKey, queueName, messageVisibilityTimeout));
}
/// <summary>
/// Creates Azure Service Bus Receiver
/// </summary>
public static IMessageReceiver AzureServiceBusTopicReceiver(this IMessagingFactory factory,
string connectionString,
string topicName,
string subscriptionName,
bool peekLock = true)
{
return(new AzureServiceBusTopicReceiver(connectionString, topicName, subscriptionName, peekLock));
}
/// <summary>
/// Creates a message receiver to receive messages from a specified memory buffer.
/// </summary>
/// <param name="factory"></param>
/// <param name="name">Memory buffer name. Use the name used when you've created a publisher to receive messages from that buffer.</param>
public static IMessageReceiver InMemoryReceiver(this IMessagingFactory factory, string name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
return(_inMemoryMessagingNameToInstance.GetOrAdd(name, () => new InMemoryMessagePublisherReceiver()));
}
/// <summary>
/// Creates Azure Event Hub receiver
/// </summary>
/// <param name="factory">Factory reference</param>
/// <param name="connectionString"></param>
/// <param name="hubPath"></param>
/// <param name="partitionIds"></param>
/// <param name="consumerGroupName"></param>
/// <param name="stateStorage"></param>
/// <returns></returns>
public static IMessageReceiver AzureEventHubReceiver(this IMessagingFactory factory,
string connectionString, string hubPath,
IEnumerable <string> partitionIds = null,
string consumerGroupName = null,
IBlobStorageProvider stateStorage = null
)
{
return(new AzureEventHubReceiver(connectionString, hubPath, partitionIds, consumerGroupName, stateStorage));
}
public MessagingService(
IMessagingFactory messagingFactory,
IOptions <Messaging> messaging,
ILogger <MessagingService <T> > logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_messagingFactory = messagingFactory ?? throw new ArgumentNullException(nameof(messagingFactory));
_messaging = messaging.Value ?? throw new ArgumentNullException(nameof(messaging));
}
internal Listener(ListenerSettings listenerSettings, ConnectionSettings connSettings, IMessageReceiver receiver, IEventPublisher eventPublisher, IMessagingFactory messagingFactory)
{
ListenerSettings = listenerSettings;
ConnectionSettings = connSettings;
MessageReceiver = receiver;
EventPublisher = eventPublisher == null ? new EventPublisher() : eventPublisher;
MessagingFactory = messagingFactory;
Status = ListenerStatus.NotStarted;
}
/// <summary>
/// Creates Amazon Simple Queue Service receiver
/// </summary>
/// <param name="factory"></param>
/// <param name="accessKeyId">Access key ID</param>
/// <param name="secretAccessKey">Secret access key</param>
/// <param name="serviceUrl"></param>
/// <param name="queueName"></param>
/// <param name="regionEndpoint"></param>
/// <returns></returns>
public static IMessageReceiver AmazonSQSMessageReceiver(this IMessagingFactory factory,
string accessKeyId,
string secretAccessKey,
string serviceUrl,
string queueName,
RegionEndpoint regionEndpoint = null)
{
return(new AwsS3MessageReceiver(accessKeyId, secretAccessKey, serviceUrl, queueName, regionEndpoint));
}
/// <summary>Create a <see cref="IMessaging"/> for a <paramref name="address"/> </summary>
/// <param name="address">The URL to create</param>
/// <example>To create a <see cref="IMessaging"/> to an MSMQ public queue: msmq://Computer/queue</example>
/// <example>To create a <see cref="IMessaging"/> to an MSMQ private queue: msmq://Computer/PRIVATE$/queue</example>
/// <exception cref="UriFormatException"></exception>
/// <exception cref="ArgumentNullException"></exception>
public static IMultiSubjectMessaging CreateMultiSubject(this IMessagingFactory factory, string address)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
var url = new Uri(address);
return(factory.CreateMultiSubject(url));
}
public ListenerService(IMessagingFactory messagingFactory,
IMassTerminationService <Commands.DataloadRequest> massTerminationService,
IMassRehireService <Commands.DataloadRequest> massRehireService,
IDataFactory datafactory)
{
InitializeComponent();
_massTerminationService = massTerminationService;
_massRehireService = massRehireService;
_messagingFactory = messagingFactory;
_dataFactory = datafactory;
}
public StarChefMessageSender(
IMessagingFactory messagingFactory,
IDatabaseManager databaseManager,
IEventFactory eventFactory,
ICommandFactory commandFactory)
{
_eventFactory = eventFactory;
_messagingFactory = messagingFactory;
_databaseManager = databaseManager;
_commandFactory = commandFactory;
}
public ICanSpecifyAzureServiceBusMessagingEntityVerifier <TMessage, TCommand, TEvent, TRequest, TResponse> WithMessagingFactory(IMessagingFactory messagingFactory)
{
if (messagingFactory == null)
{
throw new ArgumentNullException("messagingFactory");
}
_messagingFactory = messagingFactory;
return(this);
}
/// <summary>
/// Creates an instance of a publisher to Azure Storage Queues
/// </summary>
/// <param name="factory">Factory reference</param>
/// <param name="accountName">Account name. Must not be <see langword="null"/> or empty.</param>
/// <param name="storageKey">Storage key. Must not be <see langword="null"/> or empty.</param>
/// <param name="serviceUri">Alternative service uri. Pass <see langword="null"/> for default.</param>
/// <returns>Generic message publisher interface</returns>
public static IMessenger AzureStorageQueue(this IMessagingFactory factory,
string accountName,
string storageKey,
Uri serviceUri = null)
{
if (serviceUri == null)
{
return(new AzureStorageQueueMessenger(accountName, storageKey));
}
return(new AzureStorageQueueMessenger(accountName, storageKey, serviceUri));
}
public CommandMessageReceiverFactory(IHandlerMapper handlerMapper,
IZombusLogger logger,
IMessageDispatcherFactory messageDispatcherFactory,
IMessagingFactory messagingFactory,
IRouter router,
ITypeProvider typeProvider)
{
_handlerMapper = handlerMapper;
_logger = logger;
_messagingFactory = messagingFactory;
_router = router;
_typeProvider = typeProvider;
_messageDispatcherFactory = messageDispatcherFactory;
}
/// <summary>
/// Create Azure Event Hub messenger by full connection string and provide all the information for receiving end.
/// </summary>
/// <param name="factory">Factory reference</param>
/// <param name="connectionString">Full connection string, including entity path</param>
/// <param name="azureBlobStorageConnectionString">Native Azure Blob Storage connection string. Event Hub receiver requires this for internal state management, therefore you need to provide it if you plan to receive messages, and not just send them.</param>
/// <param name="consumerGroupName">Name of of the consumer group, defaults to "$Default" when not passed, however it's a good practive to create a new consumer group.</param>
/// <param name="leaseContainerName">Name of the container to use for internal state, defaults to "eventhubs".</param>
/// <param name="storageBlobPrefix">If you are planning to use the same container for multiple event hubs, you can pass an optional prefix here.</param>
public static IMessenger AzureEventHub(this IMessagingFactory factory,
string connectionString,
string azureBlobStorageConnectionString = null,
string consumerGroupName = null,
string leaseContainerName = null,
string storageBlobPrefix = null
)
{
return(new AzureEventHubMessenger(
connectionString,
azureBlobStorageConnectionString,
consumerGroupName,
leaseContainerName,
storageBlobPrefix));
}
public Host(
ICacheFactory cacheFactory,
IMessagingFactory messagingFactory,
IDatabaseFactory databaseFactory,
IOrchestratorService orchestratorService,
IMessagingService messagingService,
IOptions <Messaging> messaging,
ILogger <Host> logger)
{
_messaging = messaging.Value ?? throw new ArgumentNullException(nameof(messaging));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_orchestratorService = orchestratorService ?? throw new ArgumentNullException(nameof(orchestratorService));
_messagingService = messagingService ?? throw new ArgumentNullException(nameof(messagingService));
_messagingFactory = messagingFactory ?? throw new ArgumentNullException(nameof(messagingFactory));
}
private AzureServiceBusEndpointProvider <TServiceMessage, TMessage, TCommand, TEvent, TRequest, TResponse> CreateProvider()
{
if (_messagingFactory == null)
{
_messagingFactory = new MessagingFactoryWrapper(MessagingFactory.Create(_namespaceManager.Address, _namespaceManager.Settings.TokenProvider));
}
if (_messagingEntityVerifier == null)
{
_messagingEntityVerifier = new MessagingEntityVerifier(_namespaceManager);
}
_messagingEntityVerifier.EnsureMessagingEntitiesExist(_messageTypePathMappings);
return(new AzureServiceBusEndpointProvider <TServiceMessage, TMessage, TCommand, TEvent, TRequest, TResponse>(_serviceName, _messagingFactory, _serializer, _deserializerFactory, _messageTypePathMappings, _assemblyFilter, _typeFilter, _messagePropertyProviderManager, _messageOutgoingPropertiesTable));
}
/// <summary>Create a <see cref="IMultiSubjectMessaging"/> for a <paramref name="address"/></summary>
/// <param name="address">The URL to create</param>
/// <example>To create a <see cref="IMultiSubjectMessaging"/> to an MSMQ public queue: msmq://Computer/queue</example>
/// <example>To create a <see cref="IMultiSubjectMessaging"/> to an MSMQ private queue: msmq://Computer/PRIVATE$/queue</example>
/// <exception cref="ArgumentNullException">If <paramref name="address"/> is null</exception>
/// <exception cref="ArgumentOutOfRangeException">If no transport can be created for the <paramref name="address"/></exception>
public static IMultiSubjectMessaging CreateMultiSubject(this IMessagingFactory factory, Uri address)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
IMultiSubjectMessaging messaging = null;
factory?.TryCreateMultiSubject(address, out messaging);
if (messaging == null)
{
throw new ArgumentOutOfRangeException(nameof(address), "Don't know how to create transport for " + address);
}
return(messaging);
}
public MessagingEntityFactory(IMessagingFactory messagingFactory, List <MessageTypeMessagingEntityMappingDetails> messageTypePathMappings)
{
if (messagingFactory == null)
{
throw new ArgumentNullException("messagingFactory");
}
if (messageTypePathMappings == null)
{
throw new ArgumentNullException("messageTypePathMappings");
}
if (messageTypePathMappings.Count == 0)
{
throw new ArgumentException("No message types have been mapped.", "messageTypePathMappings");
}
_messagingFactory = messagingFactory;
_messageTypePathMappings = messageTypePathMappings;
}
public CompetingEventMessageReceiverFactory(ApplicationNameSetting applicationName,
IClock clock,
IHandlerMapper handlerMapper,
IZombusLogger logger,
IMessageDispatcherFactory messageDispatcherFactory,
IMessagingFactory messagingFactory,
IRouter router,
ITypeProvider typeProvider)
{
_applicationName = applicationName;
_clock = clock;
_handlerMapper = handlerMapper;
_logger = logger;
_messagingFactory = messagingFactory;
_messageDispatcherFactory = messageDispatcherFactory;
_router = router;
_typeProvider = typeProvider;
}
public AzureServiceBusEndpointProvider(string serviceName, IMessagingFactory messagingFactory, IMessageSerializer messageSerializer, IMessageDeserializerFactory messageDeserializerFactory, List <MessageTypeMessagingEntityMappingDetails> messageTypePathMappings, Func <Assembly, bool> assemblyFilter, Func <Type, bool> typeFilter, MessagePropertyProviderManager <TMessage> messagePropertyProviderManager, IMessageOutgoingPropertiesTable messageOutgoingPropertiesTable)
: base(serviceName)
{
if (messagingFactory == null)
{
throw new ArgumentNullException(nameof(messagingFactory));
}
if (messageSerializer == null)
{
throw new ArgumentNullException(nameof(messageSerializer));
}
if (messageDeserializerFactory == null)
{
throw new ArgumentNullException(nameof(messageDeserializerFactory));
}
if (messageTypePathMappings == null)
{
throw new ArgumentNullException(nameof(messageTypePathMappings));
}
if (messageTypePathMappings.Count == 0)
{
throw new ArgumentException("An empty set of path mappings was specified.", nameof(messageTypePathMappings));
}
if (messagePropertyProviderManager == null)
{
throw new ArgumentNullException(nameof(messagePropertyProviderManager));
}
if (messageOutgoingPropertiesTable == null)
{
throw new ArgumentNullException(nameof(messageOutgoingPropertiesTable));
}
_messageSerializer = messageSerializer;
_messageDeserializerFactory = messageDeserializerFactory;
_assemblyFilter = assemblyFilter;
_typeFilter = typeFilter;
_messageTypePathMappings = messageTypePathMappings;
_messagePropertyProviderManager = messagePropertyProviderManager;
_messageOutgoingPropertiesTable = messageOutgoingPropertiesTable;
_messagingEntityFactory = new MessagingEntityFactory(messagingFactory, messageTypePathMappings);
}
public RequestMessagePumpsFactory(IClock clock,
IDispatchContextManager dispatchContextManager,
IHandlerMapper handlerMapper,
ILogger logger,
IMessageDispatcherFactory messageDispatcherFactory,
IMessagingFactory messagingFactory,
IRouter router,
ITaskFactory taskFactory,
ITypeProvider typeProvider)
{
_logger = logger;
_messageDispatcherFactory = messageDispatcherFactory;
_clock = clock;
_dispatchContextManager = dispatchContextManager;
_handlerMapper = handlerMapper;
_typeProvider = typeProvider;
_taskFactory = taskFactory;
_messagingFactory = messagingFactory;
_router = router;
}
public MessageDispatcherFactory(DefaultMessageLockDurationSetting defaultMessageLockDuration,
IBrokeredMessageFactory brokeredMessageFactory,
IClock clock,
IDependencyResolver dependencyResolver,
IInboundInterceptorFactory inboundInterceptorFactory,
IZombusLogger logger,
IMessagingFactory messagingFactory,
IOutboundInterceptorFactory outboundInterceptorFactory,
IPropertyInjector propertyInjector)
{
_brokeredMessageFactory = brokeredMessageFactory;
_clock = clock;
_dependencyResolver = dependencyResolver;
_inboundInterceptorFactory = inboundInterceptorFactory;
_logger = logger;
_messagingFactory = messagingFactory;
_outboundInterceptorFactory = outboundInterceptorFactory;
_defaultMessageLockDuration = defaultMessageLockDuration;
_propertyInjector = propertyInjector;
}
public MqttIotHubAdapter(
Settings settings,
ISessionStatePersistenceProvider sessionStateManager,
IDeviceIdentityProvider authProvider,
IQos2StatePersistenceProvider qos2StateProvider,
IMessagingFactory messagingFactory,
IMessageRouter messageRouter)
{
Contract.Requires(settings != null);
Contract.Requires(sessionStateManager != null);
Contract.Requires(authProvider != null);
Contract.Requires(messageRouter != null);
if (qos2StateProvider != null)
{
this.maxSupportedQosToClient = QualityOfService.ExactlyOnce;
this.qos2StateProvider = qos2StateProvider;
}
else
{
this.maxSupportedQosToClient = QualityOfService.AtLeastOnce;
}
this.settings = settings;
this.sessionStateManager = sessionStateManager;
this.authProvider = authProvider;
this.messagingFactory = messagingFactory;
this.messageRouter = messageRouter;
this.publishProcessor = new MessageAsyncProcessor <PublishPacket>(this.PublishToServerAsync);
this.publishProcessor.Completion.OnFault(ShutdownOnPublishToServerFaultAction);
TimeSpan?ackTimeout = this.settings.DeviceReceiveAckCanTimeout ? this.settings.DeviceReceiveAckTimeout : (TimeSpan?)null;
this.publishPubAckProcessor = new RequestAckPairProcessor <AckPendingMessageState, PublishPacket>(this.AcknowledgePublishAsync, this.RetransmitNextPublish, ackTimeout);
this.publishPubAckProcessor.Completion.OnFault(ShutdownOnPubAckFaultAction);
this.publishPubRecProcessor = new RequestAckPairProcessor <AckPendingMessageState, PublishPacket>(this.AcknowledgePublishReceiveAsync, this.RetransmitNextPublish, ackTimeout);
this.publishPubRecProcessor.Completion.OnFault(ShutdownOnPubRecFaultAction);
this.pubRelPubCompProcessor = new RequestAckPairProcessor <CompletionPendingMessageState, PubRelPacket>(this.AcknowledgePublishCompleteAsync, this.RetransmitNextPublishRelease, ackTimeout);
this.pubRelPubCompProcessor.Completion.OnFault(ShutdownOnPubCompFaultAction);
}
public MqttIotHubAdapter(
Settings settings,
ISessionStatePersistenceProvider sessionStateManager,
IDeviceIdentityProvider authProvider,
IQos2StatePersistenceProvider qos2StateProvider,
IMessagingFactory messagingFactory,
IMessageRouter messageRouter)
{
Contract.Requires(settings != null);
Contract.Requires(sessionStateManager != null);
Contract.Requires(authProvider != null);
Contract.Requires(messageRouter != null);
if (qos2StateProvider != null)
{
this.maxSupportedQosToClient = QualityOfService.ExactlyOnce;
this.qos2StateProvider = qos2StateProvider;
}
else
{
this.maxSupportedQosToClient = QualityOfService.AtLeastOnce;
}
this.settings = settings;
this.sessionStateManager = sessionStateManager;
this.authProvider = authProvider;
this.messagingFactory = messagingFactory;
this.messageRouter = messageRouter;
this.publishProcessor = new MessageAsyncProcessor<PublishPacket>(this.PublishToServerAsync);
this.publishProcessor.Completion.OnFault(ShutdownOnPublishToServerFaultAction);
TimeSpan? ackTimeout = this.settings.DeviceReceiveAckCanTimeout ? this.settings.DeviceReceiveAckTimeout : (TimeSpan?)null;
this.publishPubAckProcessor = new RequestAckPairProcessor<AckPendingMessageState, PublishPacket>(this.AcknowledgePublishAsync, this.RetransmitNextPublish, ackTimeout);
this.publishPubAckProcessor.Completion.OnFault(ShutdownOnPubAckFaultAction);
this.publishPubRecProcessor = new RequestAckPairProcessor<AckPendingMessageState, PublishPacket>(this.AcknowledgePublishReceiveAsync, this.RetransmitNextPublish, ackTimeout);
this.publishPubRecProcessor.Completion.OnFault(ShutdownOnPubRecFaultAction);
this.pubRelPubCompProcessor = new RequestAckPairProcessor<CompletionPendingMessageState, PubRelPacket>(this.AcknowledgePublishCompleteAsync, this.RetransmitNextPublishRelease, ackTimeout);
this.pubRelPubCompProcessor.Completion.OnFault(ShutdownOnPubCompFaultAction);
}
public MulticastRequestMessagePumpsFactory(ApplicationNameSetting applicationName,
IClock clock,
IDispatchContextManager dispatchContextManager,
IHandlerMapper handlerMapper,
ILogger logger,
IMessageDispatcherFactory messageDispatcherFactory,
IMessagingFactory messagingFactory,
IRouter router,
ITaskFactory taskFactory,
ITypeProvider typeProvider)
{
_applicationName = applicationName;
_clock = clock;
_dispatchContextManager = dispatchContextManager;
_handlerMapper = handlerMapper;
_logger = logger;
_messageDispatcherFactory = messageDispatcherFactory;
_messagingFactory = messagingFactory;
_router = router;
_taskFactory = taskFactory;
_typeProvider = typeProvider;
}
public static async Task PumpQueueUntil(IMessagingFactory factory, string queue, Func <bool> completionCondition)
{
var messagePump = factory.CreateMessagePump(queue);
await messagePump.Start().ConfigureAwait(false);
while (true)
{
if (completionCondition())
{
// Wait a few seconds before stopping, to allow any outgoing operations (e.g., dead lettering) to be flushed
await Task.Delay(5000).ConfigureAwait(false);
await messagePump.Stop().ConfigureAwait(false);
break;
}
else
{
await Task.Delay(1000).ConfigureAwait(false);
}
}
}
public UserService(
ILogger <UserService> logger,
IAuthenticatedService authenticatedService,
IValidator <User> userValidator,
IValidationService validationService,
IUserRepository userRepository,
IMessagingFactory messagingFactory,
ICacheFactory cacheFactory,
IMessagingService messagingService,
ICacheService cacheService,
IOptions <Messaging> messaging)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_authenticatedService = authenticatedService ?? throw new ArgumentNullException(nameof(authenticatedService));
_userValidator = userValidator ?? throw new ArgumentNullException(nameof(userValidator));
_validationService = validationService ?? throw new ArgumentNullException(nameof(validationService));
_userRepository = userRepository ?? throw new ArgumentNullException(nameof(userRepository));
_messagingFactory = messagingFactory ?? throw new ArgumentNullException(nameof(messagingFactory));
_cacheFactory = cacheFactory ?? throw new ArgumentNullException(nameof(cacheFactory));
_messagingService = messagingService ?? throw new ArgumentNullException(nameof(messagingService));
_cacheService = cacheService ?? throw new ArgumentNullException(nameof(cacheService));
_messaging = messaging.Value ?? throw new ArgumentNullException(nameof(messaging));
}
