private void RegisterSubscriptionClientMessageHandler()
{
subscriptionClient.RegisterMessageHandler(
async(message, token) => {
var eventName = message.Label;
var messageData = Encoding.UTF8.GetString(message.Body);
if (await ProcessEvent(eventName, messageData))
{
await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 10, AutoComplete = false
});
}
private void RegisterOnMessageHandlerAndReceiveMessages(MessageOptions options)
{
// Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
// Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
// Set it according to how many messages the application wants to process in parallel.
MaxConcurrentCalls = options.ConcurrentCalls,
MaxAutoRenewDuration = options.MaximumExecutionTime.Value,
// Indicates whether the message pump should automatically complete the messages after returning from user callback.
// False below indicates the complete operation is handled by the user callback as in ProcessMessagesAsync().
AutoComplete = false
};
// Register the function that processes messages.
subscriptionClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
private void RegisterSubscriptionClientMessageHandler()
{
_subscriptionClient.RegisterMessageHandler(
async(message, token) =>
{
var eventName = $"{message.Label}{INTEGRATION_EVENT_SUFIX}";
var messageData = Encoding.UTF8.GetString(message.Body);
await ProcessEvent(eventName, messageData);
// Complete the message so that it is not received again.
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 10, AutoComplete = false
});
}
public void Listening(TimeSpan timeout, CancellationToken cancellationToken)
{
_consumerClient.RegisterMessageHandler(OnConsumerReceived,
new MessageHandlerOptions(OnExceptionReceived)
{
AutoComplete = false,
MaxConcurrentCalls = 10,
MaxAutoRenewDuration = TimeSpan.FromSeconds(30)
});
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
cancellationToken.WaitHandle.WaitOne(timeout);
}
// ReSharper disable once FunctionNeverReturns
}
Task IHostedService.StartAsync(CancellationToken cancellationToken)
{
_subscriptionClient = new SubscriptionClient(
_configuration["ServiceBusConnectionString"],
"camerastopic", "fakecrm"
);
_subscriptionClient.RegisterMessageHandler(
async(m, c) => {
var bytes = m.Body;
var json = Encoding.UTF8.GetString(bytes);
var content = JsonConvert.DeserializeObject <JObject>(json);
var id = Guid.Parse(content.Value <string>("Id"));
var cameraName = content.Value <string>("CameraName");
var imageUri = content.Value <string>("ImageUri");
var documentClient =
new DocumentClient(
new Uri(_configuration["CosmosDbUri"]),
_configuration["CosmosDbKey"]
);
var db = documentClient
.CreateDatabaseQuery()
.ToList()
.SingleOrDefault(xx => xx.Id == "fakecrm");
var coll = documentClient
.CreateDocumentCollectionQuery(db.SelfLink)
.ToList()
.SingleOrDefault(xx => xx.Id == "docs");
var result = await documentClient.CreateDocumentAsync(
new Uri(coll.SelfLink, UriKind.Relative),
new {
id, imageUri, cameraName
}
);
await _subscriptionClient.CompleteAsync(m.SystemProperties.LockToken);
},
async(e) => {
});
return(Task.CompletedTask);
}
private async Task StartListeningImpl()
{
//Always use with _semaphoreStartStop
if (_subscriptionClient != null)
{
return;
}
try
{
if (string.IsNullOrEmpty(_sasToken))
{
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(Config.ServiceBus.KeyName, Config.ServiceBus.SharedAccessKey, TimeSpan.FromMinutes(30));
_sasToken = (await tokenProvider.GetTokenAsync(Config.ServiceBus.Url, TimeSpan.FromMinutes(30))).TokenValue;
}
//TODO correct endpoints
_subscriptionClient = new SubscriptionClient(Config.ServiceBus.Url,
TopicPath,
SubscriptionName,
TokenProvider.CreateSharedAccessSignatureTokenProvider(_sasToken),
receiveMode: ReceiveMode.PeekLock,
retryPolicy: _retryPolicy);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return;
}
// register the RegisterMessageHandler callback
_subscriptionClient.RegisterMessageHandler(
async(message, cancellationToken1) =>
{
if (_subscriptionClient != null && !_subscriptionClient.IsClosedOrClosing)
{
await MessageHandler(message, cancellationToken1, _subscriptionClient);
}
},
new MessageHandlerOptions(LogMessageHandlerException)
{
AutoComplete = false, MaxConcurrentCalls = MAX_CONCURRENT_CALLS
});
}
/// <summary>
/// Method to Receive a message from a subscription
/// </summary>
/// <param name="userName">the username of the user to get messages</param>
public static void ReceiveMessageSubscription(string TopicName, string userName)
{
lop = userName;
if (string.IsNullOrWhiteSpace(userName))
{
throw new ArgumentNullException(nameof(userName));
}
//to avoid any typo, lower the string
string userNameLow = userName.ToLowerInvariant();
if (ConnectionString != null)
{
Task.Run(() =>
{
try
{
Client = new SubscriptionClient(ConnectionString, TopicName, userName);
// Configure message handler
// Values are default but set for illustration
var messageHandlerOptions =
new MessageHandlerOptions(ExceptionReceivedHandler)
{
AutoComplete = false,
// ExceptionReceivedHandler = set in constructor
MaxAutoRenewDuration = new TimeSpan(0, 5, 0), // 5 minutes
MaxConcurrentCalls = 1,
};
// Register the function that processes messages.
// Once set new message will be received
Client.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message + ", " + ex.StackTrace);
}
Console.ReadKey();
Client.CloseAsync();
});
}
}
public static void Main(string[] args)
{
Console.WriteLine("Enter the subscription name:");
var subscriptionName = Console.ReadLine();
subscriptionClient = new SubscriptionClient(connectionString, topicName, subscriptionName);
subscriptionClient.RegisterMessageHandler(
MessageReceivedHandler,
new MessageHandlerOptions(async handlerArgs => await Task.Run(() => Console.WriteLine(handlerArgs.Exception)))
{
MaxConcurrentCalls = 1,
AutoComplete = false
});
Thread.Sleep(Timeout.Infinite);
}
static void Listen()
{
try
{
_subscriptionClient.RegisterMessageHandler(MessageHandler, new MessageHandlerOptions(ErrorHandler)
{
AutoComplete = false,
MaxConcurrentCalls = 20,
MaxAutoRenewDuration = TimeSpan.FromMinutes(10)
});
Console.WriteLine("Press ENTER to quit");
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public void Receive(Action <Message <TKey, TValue> > action)
{
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false,
};
_subscriptionClient.RegisterMessageHandler((Message message, CancellationToken token) =>
{
action(new Message <TKey, TValue>
{
Key = JsonConvert.DeserializeObject <TKey>(message.MessageId),
Value = JsonConvert.DeserializeObject <TValue>(Encoding.UTF8.GetString(message.Body))
});
return(_subscriptionClient.CompleteAsync(message.SystemProperties.LockToken));
}, messageHandlerOptions);
}
static async Task Main()
{
Console.WriteLine("Starting SpeedTestLogger");
_config = new LoggerConfiguration();
var options = new MessageHandlerOptions(HandleException)
{
MaxConcurrentCalls = 1,
AutoComplete = true
};
_subscriptionClient = new SubscriptionClient(_config.ServiceBus.ConnectionString, _config.ServiceBus.TopicName, _config.ServiceBus.SubscriptionName);
_subscriptionClient.RegisterMessageHandler(HandleSpeedTestMessage, options);
Console.ReadKey();
await _subscriptionClient.CloseAsync();
}
public async void Start(Func <SyncRequest, object, SyncResult> onRequest)
{
Stop();
var topic = config.Transport.Settings.First(x => x.Name.AllEquals(TransportConstants.KeyTopic)).Value;
var topicFilter = config.Transport.Settings.First(x => x.Name.AllEquals(TransportConstants.KeyTopicFilter)).Value;
var transportId = config.Transport.Settings.First(x => x.Name.AllEquals(TransportConstants.KeyId)).Value;
var connectionString = config.Transport.Settings.First(x => x.Name.AllEquals(TransportConstants.KeyConnectionString)).Value;
var managementClient = new ManagementClient(connectionString);
var subscription = string.Format("{0}{1}", topicFilter, transportId).Replace("-", string.Empty);
if (!(await managementClient.TopicExistsAsync(topic)))
{
var td = new TopicDescription(topic)
{
MaxSizeInMB = Convert.ToInt64(config.Transport.Settings.First(x => x.Name.AllEquals(TransportConstants.KeyMaxSizeInMegabytes)).Value),
DefaultMessageTimeToLive = TimeSpan.FromSeconds(Convert.ToInt64(config.Transport.Settings.First(x => x.Name.AllEquals(TransportConstants.KeyDefaultMessageTimeToLiveInSecond)).Value))
};
await managementClient.CreateTopicAsync(td);
Progress?.Invoke(this, new ProgressEventArgs {
Level = LogLevel.Important, Message = $"Topic created: {topic}"
});
}
if (!(await managementClient.SubscriptionExistsAsync(topic, subscription)))
{
Progress?.Invoke(this, new ProgressEventArgs {
Level = LogLevel.Important, Message = $"Subscription created: {subscription}"
});
await managementClient.CreateSubscriptionAsync(topic, subscription);
}
this.onRequest = onRequest;
var options = new MessageHandlerOptions(ExceptionReceivedHandler)
{
AutoComplete = false,
MaxAutoRenewDuration = TimeSpan.FromSeconds(Convert.ToInt32(config.Transport.Settings.First(x => x.Name.AllEquals(TransportConstants.KeyAutoRenewTimeoutInSecond)).Value))
};
subscriptionClient = new SubscriptionClient(connectionString, topic, subscription, ReceiveMode.PeekLock);
subscriptionClient.RegisterMessageHandler(ProcessMessageAsync, options);
}
static async Task Main(string[] args)
{
var host = new HostBuilder()
.ConfigureAppConfiguration(configure =>
{
configure
.AddJsonFile("appsettings.json")
.AddUserSecrets("c1804010-ee78-4f49-acdc-9830c502fd8a")
.AddCommandLine(args);
})
.ConfigureLogging(configure => configure.AddConsole())
.Build();
var logger = host.Services.GetService <ILogger <Program> >();
var config = host.Services.GetService <IConfiguration>();
logger.LogInformation("Receiving message from the Sales Performance Messages topic...");
try
{
var cs = config.GetConnectionString(config["ServiceBus:ConnectionStringName"]);
var name = config["ServiceBus:TopicName"];
var subname = config["Servicebus:SubscriptionName"];
var client = new TopicClient(cs, name);
var subscription = new SubscriptionClient(cs, name, subname);
var messageHandlerOptions = new MessageHandlerOptions(e => ExceptionReceivedHandler(e, logger))
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
subscription.RegisterMessageHandler((m, ct) => ProcessMessagesAsync(m, subscription, logger), messageHandlerOptions);
Console.ReadLine();
await client.CloseAsync();
}
catch (Exception error)
{
logger.LogError(error, error.Message);
return;
}
}
public Task StartReceivingMessages(MessageHandlerExecutor messageHandlerExecutor)
{
subscriptionClient = new SubscriptionClient(connectionString, TopicName, configuration.ReceiveOptions.QueueName);
subscriptionClient.RegisterMessageHandler(
(message, cancellationToken) => messageHandlerExecutor.Execute(GetMessageBody(message, MessageTypeNames), new AzureServiceBusMessageContext(message), cancellationToken),
new MessageHandlerOptions(_ => Task.CompletedTask)
{
});
return(Task.CompletedTask);
object GetMessageBody(ServiceBusMessage message, IMessageTypeNames messageTypeNames)
{
var messageTypeName = message.UserProperties[UserProperties.MessageTypeKey].ToString();
var type = messageTypeNames.GetTypeByMessageTypeName(messageTypeName);
return(JsonConvert.DeserializeObject(Encoding.UTF8.GetString(message.Body), type));
}
}
private static void Authenticate()
{
try
{
Console.WriteLine("....Authenticating");
TokenProvider tokenProvider = TokenProvider.CreateManagedIdentityTokenProvider();
_subscriptionClient = new SubscriptionClient(_endpoint, _topicName, _subName, tokenProvider);
Console.WriteLine("....Authenticated");
_subscriptionClient.RegisterMessageHandler(OnMessageReceived, new MessageHandlerOptions(OnErrorOccured)
{
AutoComplete = false,
MaxConcurrentCalls = 2
});
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
private void AddIntegrationEventHandler()
{
_subscriptionClient.RegisterMessageHandler(
async(message, token) =>
{
string eventName = $"{message.Label}{INTEGRATION_EVENT_SUFFIX}";
string messageData = Encoding.UTF8.GetString(message.Body);
// Complete the message so that it is not received again.
if (await ProcessEvent(eventName, messageData))
{
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
},
new MessageHandlerOptions((e) => Task.CompletedTask)
{
MaxConcurrentCalls = 10, AutoComplete = false
});
}
static async Task RegisterHandlers()
{
IEnumerable <SubscriptionDescription> subscriptionDescriptions = await _managementClient.GetSubscriptionsAsync(_topic);
foreach (var sub in subscriptionDescriptions)
{
SubscriptionClient subscriptionClient = new SubscriptionClient(_connectionString, _topic, sub.SubscriptionName);
subscriptionClient.RegisterMessageHandler(async(message, token) =>
{
Person person = JsonConvert.DeserializeObject <Person>(Encoding.UTF8.GetString(message.Body));
Console.WriteLine($"[{sub.SubscriptionName}] {person.ToString()}");
await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}, new MessageHandlerOptions(GlobalErrorHandler)
{
AutoComplete = false,
MaxConcurrentCalls = 1
});
}
}
private void RegisterOnMessageHandlerAndReceiveMessages()
{
// Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
// Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
// Set it according to how many messages the application wants to process in parallel.
MaxConcurrentCalls = 1,
// Indicates whether the message pump should automatically complete the messages after returning from user callback.
// False below indicates the complete operation is handled by the user callback as in ProcessMessagesAsync().
AutoComplete = false
};
// Register the function that processes messages.
_logClient.RegisterMessageHandler(ProcessLogMessagesAsync, messageHandlerOptions);
_orderClient.RegisterMessageHandler(ProcessOrderMessagesAsync, messageHandlerOptions);
_machineClient.RegisterMessageHandler(ProcessMachineMessagesAsync, messageHandlerOptions);
_analyticsClient.RegisterMessageHandler(ProcessAnalyticsMessagesAsync, messageHandlerOptions);
}
public AzureEventBus(ILogger <AzureEventBus> logger, IOptions <AzureEventBusConfig> options, IServiceProvider serviceProvider)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
var eventBusConfig = options.Value ?? throw new ArgumentNullException();
_topicClient = new TopicClient(eventBusConfig.ConnectionString, eventBusConfig.TopicName, RetryPolicy.Default);
_subscriptionClient = new SubscriptionClient(eventBusConfig.ConnectionString, eventBusConfig.TopicName,
eventBusConfig.SubscriptionName);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 5,
AutoComplete = false
};
_subscriptionClient.RegisterMessageHandler(ProcessEvent, messageHandlerOptions);
}
public Receiver(string connectionString, string topicName, string subscriptionName, ConsoleColor textColour)
{
_subscriptionClient = new SubscriptionClient(
connectionString,
topicName,
subscriptionName);
_subscriptionClient.RegisterMessageHandler(
(message, cancellation) => {
var alertBody = System.Text.Encoding.UTF8.GetString(message.Body);
Console.ForegroundColor = textColour;
Console.WriteLine($"{subscriptionName} | {alertBody}");
return(Task.CompletedTask);
},
(exceptionArgs) => {
return(Task.CompletedTask);
});
}
private void RegisterSubscriptionClientMessageHandler()
{
_subscriptionClient.RegisterMessageHandler(
async(message, token) =>
{
var eventName = $"{message.Label}{INTEGRATION_EVENT_SUFIX}";
var messageData = Encoding.UTF8.GetString(message.Body);
// Complete the message so that it is not received again.
if (await ProcessEvent(eventName, messageData)) //Manjunath : this is where Azure Service Bus based integration events are triggered....
{
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 10, AutoComplete = false
});
}
public void RegisterMessageHandler(
string name,
Func <MagnetMessage, CancellationToken, Task> handler)
{
var client = new SubscriptionClient(_options.ConnectionString, _options.Topic, name);
client.RegisterMessageHandler(async(message, token) =>
{
string json = Encoding.UTF8.GetString(message.Body);
MagnetMessage magnetMsg = JsonConvert.DeserializeObject <MagnetMessage>(json);
await handler(magnetMsg, token);
await client.CompleteAsync(message.SystemProperties.LockToken);
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1, AutoComplete = false
});
}
public Task ListenEvent <T>(Func <T, Task> onReceivedAsync, string topicKey, string subscriptionName) where T : Event
{
var subscriptionClient = new SubscriptionClient(_connectionString, topicKey, subscriptionName);
var messageHandlerOptions = CreateMessageHandlerOptions();
subscriptionClient.RegisterMessageHandler(async(msg, token) =>
{
var content = Encoding.UTF8.GetString(msg.Body);
var message = JsonConvert.DeserializeObject <T>(content);
await onReceivedAsync(message);
await subscriptionClient.CompleteAsync(msg.SystemProperties.LockToken);
}, messageHandlerOptions);
return(Task.CompletedTask);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogDebug($"{_nameToken} is starting in the background.");
var serviceBusConnectionString = await _azureKeyVaultService.GetSecret(_serviceBusConnectionStringSecretName);
_logger.LogInformation(string.IsNullOrWhiteSpace(serviceBusConnectionString) ? "ServiceBusConnectionString was not retrieved from the Key Vault." : "ServiceBusConnectionString was retrieved from the Key Vault.");
_logger.LogInformation(string.IsNullOrWhiteSpace(_topicName) ? "TopicName was not retrieved from configuration." : $"TopicName: {_topicName} was retrieved from configuration.");
_logger.LogInformation(string.IsNullOrWhiteSpace(_subscriptionName) ? "SubscriptionName was not retrieved from configuration." : $"SubscriptionName: {_subscriptionName} was retrieved from configuration.");
_subscriptionClient = new SubscriptionClient(serviceBusConnectionString, _topicName, _subscriptionName);
cancellationToken.Register(async() =>
{
await _subscriptionClient.CloseAsync();
_logger.LogDebug($"{_nameToken} has called CloseAsync because of cancel.");
});
var processors = Environment.ProcessorCount;
_logger.LogDebug($"Number of logical processors: {processors}, using {processors + 1} as the number of MaxConcurrentCalls for processing messages.");
// Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
// Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
// Set it according to how many messages the application wants to process in parallel.
//MaxConcurrentCalls = 1,
MaxConcurrentCalls = processors + 1,
// Indicates whether the message pump should automatically complete the messages after returning from user callback.
// False below indicates the complete operation is handled by the user callback as in ProcessMessagesAsync().
AutoComplete = false
};
// Register the function that processes messages.
_subscriptionClient.RegisterMessageHandler(
async(message, handlerCancellationToken) =>
{
await ProcessMessagesAsync(message, handlerCancellationToken);
},
messageHandlerOptions);
}
public async Task sub(string cs)
{
var nm = new ManagementClient(cs);
//var nm = NamespaceManager.CreateFromConnectionString(cs);
var td = await nm.CreateTopicAsync("KDR.Topic.Test.1");
var sd = await nm.CreateSubscriptionAsync(td.Path, "KRD.Sub");
var sb = new SubscriptionClient(cs, td.Path, sd.SubscriptionName, ReceiveMode.PeekLock, RetryPolicy.Default);
//var messagingFactory = await MessagingFactory.CreateAsync("connectionString");
//var s = SubscriptionClient.CreateFromConnectionString("cs", "topic", "subscriptionName", ReceiveMode.PeekLock);
//s.AddRule("", new TrueFilter() { Parameters = { } });
//var sc = new SubscriptionClient(messagingFactory, "topic", "subscriptionName", ReceiveMode.PeekLock);
//var messageSender = await messagingFactory.CreateMessageSenderAsync("entityPath");
//var messageReceiver = await messagingFactory.CreateMessageReceiverAsync("entityPath", ReceiveMode.PeekLock);
//messageSender.SendAsync(new BrokeredMessage(MemoryStream.in "dead"))
Message m = null;
sb.RegisterMessageHandler(
(message, token) =>
{
m = message;
return(Task.CompletedTask);
},
new MessageHandlerOptions(args => Task.CompletedTask)
{
AutoComplete = false,
MaxConcurrentCalls = 1
});
//path to receive:
//for topic: topic/subscriptions/applicationName
//for command: queue
//new BrokeredMessage()
//messageSender.SendAsync()
//_messageReceiver.
}
internal Binding(AzureBusTopicSettings settings, ILogger <AzureTopicSubscriber> logging,
AzureBusTopicManagement queueManagement, BlockingCollection <IBinding> errorActions)
{
_excludeTopicsFromLogging = new LoggingConfiguration().ExcludeTopicsFromLogging();
var topicName = settings.TopicNameBuilder(typeof(T));
var subscriptionName = $"{topicName}.{settings.TopicSubscriberId}";
queueManagement.CreateSubscriptionIfMissing(topicName, subscriptionName, typeof(T));
var subscriptionClient = new SubscriptionClient(settings.ConnectionString, topicName, subscriptionName);
UpdateRules(subscriptionClient, settings);
subscriptionClient.RegisterMessageHandler(
async(message, _) =>
{
try
{
var body = Encoding.UTF8.GetString(message.Body);
if (!_excludeTopicsFromLogging.Contains(topicName))
{
logging.LogInformation("Received '{subscription}': {body} with Azure MessageId: '{messageId}'", subscriptionName, body, message.MessageId);
}
var asObject = AsObject(body);
Subject.OnNext(asObject);
}
catch (Exception ex)
{
logging.LogError(ex, "Message {subscription}': {message} -> consumer error: {exception}", subscriptionName, message, ex);
}
}, new MessageHandlerOptions(async e =>
{
logging.LogError(e.Exception, "At route '{subscription}' error occurred: {exception}.", subscriptionName, e.Exception);
if (e.Exception is ServiceBusCommunicationException || e.Exception is MessagingEntityNotFoundException)
{
errorActions.Add(this);
}
}));
}
public async Task DispatchAsync_should_publish_events()
{
var topicFactory = new TopicClientFactory(_connStr);
var logger = NSubstitute.Substitute.For <ILogger <EventProducer <DummyAggregate, Guid> > >();
var sut = new EventProducer <DummyAggregate, Guid>(topicFactory, "test", _eventSerializer, logger);
await CreateTopicAsync(sut.TopicName);
int expectedMessagesCount = 3;
var subscriptionClient = new SubscriptionClient(_connStr, sut.TopicName, SubscriptionName);
subscriptionClient.RegisterMessageHandler(
async(msg, tkn) =>
{
--expectedMessagesCount;
await subscriptionClient.CompleteAsync(msg.SystemProperties.LockToken);
},
(ex) => Task.CompletedTask);
var aggregate = new DummyAggregate(Guid.NewGuid());
aggregate.DoSomething("lorem");
aggregate.DoSomething("ipsum");
await sut.DispatchAsync(aggregate);
var timeout = 30 * 1000;
var timer = new Stopwatch();
timer.Start();
while (true)
{
if (expectedMessagesCount < 1 || timer.ElapsedMilliseconds > timeout)
{
break;
}
await Task.Delay(200);
}
expectedMessagesCount.Should().Be(0);
}
public virtual async Task StartAsync(CancellationToken cancellationToken)
{
try
{
await _managementClient.CreateSubscriptionAsync(new SubscriptionDescription(_topicName, _subName)
{
DefaultMessageTimeToLive = TimeSpan.FromDays(14),
LockDuration = TimeSpan.FromSeconds(30),
EnableDeadLetteringOnFilterEvaluationExceptions = true,
EnableDeadLetteringOnMessageExpiration = true,
}, new RuleDescription("default", new SqlFilter($"sys.Label != '{_subName}'")));
}
catch (MessagingEntityAlreadyExistsException) { }
_subscriptionClient.RegisterMessageHandler(ProcessMessageAsync,
new MessageHandlerOptions(ExceptionReceivedHandlerAsync)
{
MaxConcurrentCalls = 2,
AutoComplete = false,
});
}
protected override void SubscribeCore(Func <SubscriberBase, MessageReceivedEventArgs, Func <EventMessage, Task>, Task> receiveCallback, Func <EventMessage, Task> onMessageCallback)
{
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
AutoComplete = false
};
_subscriptionClient.RegisterMessageHandler(async(sbMessage, cancellationToken) =>
{
cancellationToken.ThrowIfCancellationRequested();
var messageReceivedEventArgs = new MessageReceivedEventArgs(
new Message(sbMessage.Body,
DateTime.UtcNow),
sbMessage.SystemProperties.LockToken,
cancellationToken);
await receiveCallback(this, messageReceivedEventArgs, onMessageCallback);
}, messageHandlerOptions);
}
public InboundEventProvider(IEventAggregator eventAggregator)
{
_eventAggregator = eventAggregator;
if (SystemBehaviorConfig.ServiceBusType != ServiceBusTypes.Rabbit)
{
_topicClient = new SubscriptionClient(ServiceBusConfig.AzureEventingTopicConnectionString,
Topics.EventingTopic, ServiceBusConfig.EventingTopicQueueName);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = true,
MaxAutoRenewDuration = TimeSpan.FromMinutes(1)
};
// Register the function that processes messages.
_topicClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
}
