private async Task ProcessCreateProdutoMessagesAsync(Message message, CancellationToken token)
{
var produto = JsonConvert.DeserializeObject <CreateProdutoRequest>(Encoding.UTF8.GetString(message.Body));
await _produtoAppService.Create(produto);
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
//public override Task StartAsync(CancellationToken cancellationToken)
// {
// RegisterOnMessageHandlerAndReceiveMessages().GetAwaiter().GetResult();
//return base.StartAsync(cancellationToken);
// }
private async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
var myPayload = JsonConvert.DeserializeObject <AuditMessagePayload>(Encoding.UTF8.GetString(message.Body));
_processData.Process(myPayload).GetAwaiter().GetResult();
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
private async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
try
{
var bodyText = Encoding.UTF8.GetString(message.Body);
var result = await ProcessMessage(bodyText, token);
switch (result.Status)
{
case CommandExecutionStatus.Success:
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
break;
case CommandExecutionStatus.Failure:
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
Console.WriteLine($"Failure while processing command, message '{result.ErrorMessage}', error reason: {result.ErrorReason}");
break;
}
}
catch (Exception e)
{
Console.WriteLine($"Exception occured in service {Options.ServiceId} while processing message, exception: {e}, message text: {Encoding.UTF8.GetString(message.Body)}");
}
}
private async Task OnMessageAsync(Message message, CancellationToken cancellationToken, IMediator mediator)
{
try
{
var payload = JObject.Parse(Encoding.UTF8.GetString(message.Body));
var command = MapEvent(message.Label, payload);
if (command != null)
{
if (command is IRequest)
{
await mediator.Send((IRequest)command, cancellationToken);
}
else if (command is IRequest <int> )
{
await mediator.Send((IRequest <int>) command, cancellationToken);
}
else
{
logger.LogWarning($"Unsupported command type: {command.GetType()}");
}
}
await client.CompleteAsync(message.SystemProperties.LockToken);
}
catch (BusinessException ex)
{
logger.LogError($"Business exception occurred processing integration event. Details: {ex}");
await client.CompleteAsync(message.SystemProperties.LockToken);
}
catch (Exception ex)
{
logger.LogError($"Unexpected error occurred processing integration event. Details: {ex}");
await client.AbandonAsync(message.SystemProperties.LockToken);
}
}
private void RegisterOnMessageHandlerAndReceiveMessages <TResult>(Func <TResult, Task> callBack)
{
var messageHandlerOptions = new MessageHandlerOptions(ExceptionRecievedHanlder)
{
MaxConcurrentCalls = _serviceBusConfiguration.Topic.Subscription.MaxConcurrentCalls,
AutoComplete = _serviceBusConfiguration.Topic.Subscription.AutoComplete
};
_subscriptionClient.RegisterMessageHandler(async(message, token) =>
{
var result = JsonConvert.DeserializeObject <TResult>(Encoding.UTF8.GetString(message.Body));
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
await callBack(result);
}, messageHandlerOptions);
}
async Task ProcessMessageAsync(Message message, CancellationToken cancellationToken)
{
Progress?.Invoke(this, new ProgressEventArgs {
Message = $"Received message id {message.MessageId}"
});
if (message.UserProperties.TryGetValue(Constants.KeyName, out var name) && name is string nameValue)
{
if (message.UserProperties.TryGetValue(Constants.KeyId, out var id) && id is long idValue &&
message.UserProperties.TryGetValue(Constants.KeyTaskType, out var taskType) && taskType is string taskTypeValue &&
message.UserProperties.TryGetValue(Constants.KeyType, out var type) && type is int typeValue &&
message.UserProperties.TryGetValue(Constants.KeyOperation, out var operation) && operation is int operationValue &&
message.UserProperties.TryGetValue(Constants.KeyResourceId, out var resourceIds) && resourceIds is string resourceIdsValue &&
message.UserProperties.TryGetValue(Constants.KeyCreatedDate, out var createdDate) && createdDate is DateTime createdDateValue &&
message.UserProperties.TryGetValue(Constants.KeyPayload, out var payload))
{
var request = new SyncRequest {
Id = idValue, Type = typeValue, Operation = (Operation)operationValue, ResourceIds = Serializer.DeserializeText <List <object> >(resourceIdsValue), CreatedDate = createdDateValue
};
var result = onRequest(request, payload);
if (!result.IsSuccessful)
{
Progress?.Invoke(this, new ProgressEventArgs {
Message = $"Failed to process request for task {name}", Request = request
});
}
await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
else
{
Progress?.Invoke(this, new ProgressEventArgs {
Message = $"Missing request info find task {name}"
});
}
}
private static async Task ReceiveMessages_FromTopicSubscriptionsAsync(SubscriptionClient client, CancellationToken token, Color color)
{
var doneReceiving = new TaskCompletionSource <bool>();
token.Register(
async() => {
await client.CloseAsync();
doneReceiving.SetResult(true);
}
);
client.RegisterMessageHandler(
async(message, token1) =>
{
try
{
if (ProcessMessages(message, color))
{
await client.CompleteAsync(message.SystemProperties.LockToken);
}
else
{
await client.DeadLetterAsync(message.SystemProperties.LockToken, "Message is of the wrong type", "Cannot deserialize this message as the type in the Label prop is unknown.");
}
}
catch (Exception ex)
{
Log.Error($"[{message.MessageId}] -- {ex.Message}");
}
},
GetDefaultMessageHandlingOptions());
await doneReceiving.Task;
}
private static async Task HandleNewMessage(Message receivedMessage, SubscriptionClient subscriptionClient, CancellationToken cancellationToken, ILogger logger)
{
if (receivedMessage == null)
{
return;
}
logger.LogInformation("Message '{messageId}' was received", receivedMessage.MessageId);
string rawReceivedEvents = string.Empty;
try
{
rawReceivedEvents = Encoding.UTF8.GetString(receivedMessage.Body);
EventsReceived(rawReceivedEvents, logger);
await subscriptionClient.CompleteAsync(receivedMessage.SystemProperties.LockToken).ConfigureAwait(continueOnCapturedContext: false);
logger.LogInformation("Message '{messageId}' was successfully handled", receivedMessage.MessageId);
}
catch (Exception ex)
{
logger.LogError("Failed to persist raw events with exception '{exceptionMessage}'. Payload: {rawEventsPayload}", ex.Message, rawReceivedEvents);
}
}
private async Task MessageHandler(Message message, CancellationToken cancellationToken)
{
var jsonString = Encoding.UTF8.GetString(message.Body);
RaiseMessageReadyEvent?.Invoke(this, jsonString);
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
public Task StartAsync(CancellationToken cancellationToken)
{
string serviceBusTopicConnectionString = _configuration["ConnectionStrings:ServiceBusTopic"];
string topicName = _configuration["ServiceBusTopicName"];
string _subscriptionName = _configuration["ServiceBusTopicSubscriptionName"];
SubscriptionClient subscriptionClient = new SubscriptionClient(serviceBusTopicConnectionString, topicName, _subscriptionName);
subscriptionClient.RegisterMessageHandler(
async(m, c) =>
{
var bytes = m.Body;
var json = Encoding.UTF8.GetString(bytes);
var content = JsonConvert.DeserializeObject <ListTrainingResponse>(json);
var type = content.ResponseType;
var username = content.RunnerUsername;
switch (type)
{
case "ListTrainingResponse":
await _hub.Clients.Clients(_registry.ClientIdFromUsername(username)).SendAsync("ListTrainingResponse", content.Activities);
break;
default:
break;
}
await subscriptionClient.CompleteAsync(m.SystemProperties.LockToken);
},
new Func <ExceptionReceivedEventArgs, Task>(async(e) =>
{
}));
return(Task.CompletedTask);
}
private async Task ReceiveMessage(Message message, CancellationToken cancellationToken)
{
if (message != null && _nodeId != null)
{
_logger?.LogDebug(Resources.AzureServiceBus_Debug_MessageReceived, _topicName, _nodeId, message.MessageId);
try
{
if (message.UserProperties.ContainsKey(SubscriptionPingPropertyName))
{
ProcessSubscriptionIsAliveMessage(message);
}
else
{
var nodeMessage = MessageConverter.ConvertToNodeMessage(message);
_observableMessages.OnNext(nodeMessage);
}
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
_logger?.LogInformation(Resources.AzureServiceBus_Info_MessageProcessed, _topicName, _nodeId, message.MessageId);
}
catch (Exception ex)
{
_logger?.LogError(ex, Resources.AzureServiceBus_Error_MessageError, _topicName, _nodeId, message.MessageId);
await _subscriptionClient.AbandonAsync(message.SystemProperties.LockToken);
}
}
}
private void RegisterSubscriptionClientMessageHandler(SubscriptionClient subscriptionClient)
{
subscriptionClient.RegisterMessageHandler(
async(message, token) =>
{
_log.Trace($"Received Message {message.MessageId} {message.Label} for {subscriptionClient.ServiceBusConnection.Endpoint}");
if (!token.IsCancellationRequested && !subscriptionClient.IsClosedOrClosing)
{
await OnMessageReceived(message);
// Complete the message so that it is not received again.
await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
else
{
_log.Warn($"SubscriptionClient MessageReceived CancellationRequested or IsClosedOrClosing");
await subscriptionClient.AbandonAsync(message.SystemProperties.LockToken);
}
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 20,
AutoComplete = false,
MaxAutoRenewDuration = TimeSpan.FromSeconds(60)
});
}
public async Task <MagnetMessage> GetNextAsync(string name, CancellationToken cancellationToken)
{
var client = new SubscriptionClient(_options.ConnectionString, _options.Topic, name);
var completion = new TaskCompletionSource <MagnetMessage>();
cancellationToken.Register(() => completion.SetCanceled());
try
{
client.RegisterMessageHandler(async(message, token) =>
{
string json = Encoding.UTF8.GetString(message.Body);
MagnetMessage magnetMsg = JsonConvert.DeserializeObject <MagnetMessage>(json);
await client.CompleteAsync(message.SystemProperties.LockToken);
await client.CloseAsync();
completion.SetResult(magnetMsg);
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1, AutoComplete = false
});
}
catch (Exception ex)
{
completion.SetException(ex);
}
return(await completion.Task);
}
private static async Task OnMessageReceived(Message payload, CancellationToken cancellationToken)
{
string message = Encoding.UTF8.GetString(payload.Body);
Console.WriteLine($"[*] {message}");
await _subscriptionClient.CompleteAsync(payload.SystemProperties.LockToken);
}
/// <summary>
/// Process messages
/// </summary>
/// <param name="message"></param>
/// <param name="token"></param>
/// <returns></returns>
private async Task ProcessMessages(Message message, CancellationToken token)
{
var data = JsonConvert.DeserializeObject <dynamic>(Encoding.UTF8.GetString(message.Body));
await _processor.ProcessData(data);
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
private async Task ProcessMessageAsync(Message message, CancellationToken cancellationToken)
{
Console.WriteLine(
$"Received message: SequenceNumber: {message.SystemProperties.SequenceNumber} Body: {Encoding.UTF8.GetString(message.Body)}");
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
public void Start(IEnumerable <SubscriptionListenerConfig> subscriptionListenerConfig)
{
var subscriptionClient = new SubscriptionClient(
"Endpoint=sb://asos-pim-eun-bus.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=vDfWcAqx/kwUf1I6LsK6dYVQ56/SswsvAM9EpICv3Lo=",
"pim.adapter.spike",
"sizing.spike");
subscriptionClient.RegisterMessageHandler(async(message, token) =>
{
Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");
await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}, ExceptionReceivedHandler);
//foreach (var config in subscriptionListenerConfig)
//{
// var subscriptionClient = new SubscriptionClient(
// config.ServiceBusConnectionString,
// config.TopicName,
// config.SubscriptionName);
// subscriptionClient.RegisterMessageHandler(async (message, token) =>
// {
// await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
// }, ExceptionReceivedHandler);
//}
}
private void RegisterSubscriptionClientMessageHandler()
{
_subscriptionClient.RegisterMessageHandler(
async(message, token) =>
{
var responseId = message.CorrelationId;
var eventType = (EventType)Enum.Parse(typeof(EventType), message.UserProperties[ServiceBusConstants.UserPropertyEventType] as string);
//var eventName = (EventName)Enum.Parse(typeof(EventName), message.UserProperties[ServiceBusConstants.UserPropertyEventName] as string);
var eventName = (EventName)Enum.Parse(typeof(EventName), message.Label as string);
var eventIndexInFlowMap = Int32.Parse(message.UserProperties[ServiceBusConstants.UserPropertyEventIndexInFlowMap].ToString());
var messageData = Encoding.UTF8.GetString(message.Body);
var payLoad = JsonConvert.DeserializeObject <BasePayLoad>(messageData);
SedaEvent sedaEvent = new SedaEvent(
responseId,
eventType,
payLoad,
eventName,
eventIndexInFlowMap
);
await this._messageProcessor.ProcessMessageAsync(sedaEvent);
// Complete the message so that it is not received again.
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = this._azureServiceBusSettings.MaxConcurrentCalls, AutoComplete = false
});
}
private static async Task ReceiveMessages_FromTopicDeadLetterSubscriptions(MessageSender sender, SubscriptionClient client, CancellationToken token, ConsoleColor color)
{
var doneReceiving = new TaskCompletionSource <bool>();
token.Register(
async() =>
{
await client.CloseAsync();
doneReceiving.SetResult(true);
});
client.RegisterMessageHandler(
async(message, token1) =>
{
try
{
var resubmitMessage = message.Clone();
resubmitMessage.MessageId = $"{resubmitMessage.MessageId}|{Guid.NewGuid()}";
await sender.SendAsync(resubmitMessage);
await client.CompleteAsync(message.SystemProperties.LockToken);
Utils.ConsoleWrite($"[{message.MessageId}] -- Placed back in topic.\n", ConsoleColor.Blue, color);
}
catch (Exception ex)
{
Log.Error($"[{message.MessageId}] -- {ex.Message}");
await client.AbandonAsync(message.SystemProperties.LockToken);
}
},
GetDefaultMessageHandlingOptions());
await doneReceiving.Task;
}
private async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
var user = JsonConvert.DeserializeObject <User>(Encoding.UTF8.GetString(message.Body));
_processData.Process(user);
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
public static async Task Main(string[] args)
{
var subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler);
messageHandlerOptions.AutoComplete = false;
subscriptionClient.RegisterMessageHandler((message, cancellationToken) =>
{
Console.WriteLine($"UserName: {message.UserProperties["UserName"]}");
Console.WriteLine($"Stage: {message.UserProperties["Stage"]}");
Console.WriteLine($"ContentType: {message.ContentType}");
Console.WriteLine($"CorrelationId: {message.CorrelationId}");
Console.WriteLine(Encoding.UTF8.GetString(message.Body));
subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
Console.WriteLine();
return(Task.CompletedTask);
}
, messageHandlerOptions);
Console.ReadLine();
await subscriptionClient.CloseAsync();
}
private async Task ProcessEvent(Message message, CancellationToken cancellationToken)
{
var eventTypeName = message.Label;
var eventType = typeof(AzureEventBus).Assembly.GetTypes().FirstOrDefault(x => x.Name == eventTypeName);
var eventHandlerType = typeof(IntegrationEventHandler <>).MakeGenericType(eventType);
var handler = _serviceProvider.GetService(eventHandlerType);
if (!_subscribedEvents.Contains(eventTypeName) || handler == null)
{
_logger.LogWithProps(LogLevel.Critical,
$"Unable to process {eventTypeName} because there is no corresponding handler");
return;
}
var integrationEventStr = Encoding.UTF8.GetString(message.Body);
var integrationEvent = JsonConvert.DeserializeObject(integrationEventStr, eventType);
const string methodName = nameof(IntegrationEventHandler <IntegrationEvent> .Handle);
var method = eventHandlerType.GetMethod(methodName);
await(Task) method.Invoke(handler, new[] { integrationEvent });
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
private static void DoClientWork(IClusterClient client)
{
var subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, "accountTransferUpdates", "orleansSubscription");
subscriptionClient.PrefetchCount = 1000;
try
{
subscriptionClient.RegisterMessageHandler(
async(message, token) =>
{
var messageJson = Encoding.UTF8.GetString(message.Body);
var updateMessage = JsonConvert.DeserializeObject <AccountTransferMessage>(messageJson);
await client.GetGrain <IAccountGrain>(updateMessage.From).Withdraw(updateMessage.Amount);
await client.GetGrain <IAccountGrain>(updateMessage.To).Deposit(updateMessage.Amount);
await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
},
new MessageHandlerOptions(async args => Console.WriteLine(args.Exception + ", stack trace: " + args.Exception.StackTrace))
{
MaxConcurrentCalls = 1, AutoComplete = false
});
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
}
}
public void Receive()
{
var subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, "productRatingUpdates", "sampleSubscription");
try
{
subscriptionClient.RegisterMessageHandler(
async(message, token) =>
{
var messageJson = Encoding.UTF8.GetString(message.Body);
var updateMessage = JsonConvert.DeserializeObject <ProductRatingUpdateMessage>(messageJson);
Console.WriteLine($"Received message with productId: {updateMessage.ProductId}");
await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
},
new MessageHandlerOptions(async args => Console.WriteLine(args.Exception))
{
MaxConcurrentCalls = 1, AutoComplete = false
});
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
}
}
private void RegisterSubscriptionClientMessageHandler()
{
_subscriptionClient.RegisterMessageHandler(
async(message, token) =>
{
SedaEvent sedaEvent = new SedaEvent();
sedaEvent.ResponseId = message.CorrelationId;
sedaEvent.To = (SedaService)Enum.Parse(typeof(SedaService), message.To);
sedaEvent.From = (SedaService)Enum.Parse(typeof(SedaService), message.UserProperties[UserPropertyFrom] as string);
sedaEvent.CmsOperation = (CmsOperation)Enum.Parse(typeof(CmsOperation), message.UserProperties[UserPropertyCmsOperation] as string);
sedaEvent.EventType = (EventType)Enum.Parse(typeof(EventType), message.UserProperties[UserPropertyEventType] as string);
sedaEvent.Priority = (Priority)Enum.Parse(typeof(Priority), message.UserProperties[UserPropertyPriority] as string);
sedaEvent.EventName = (EventName)Enum.Parse(typeof(EventName), message.UserProperties[UserPropertyEventName] as string);
sedaEvent.EventIndexInFlowMap = Int32.Parse(message.UserProperties[UserPropertyEventIndexInFlowMap].ToString());
var messageData = Encoding.UTF8.GetString(message.Body);
sedaEvent.PayLoad = JsonConvert.DeserializeObject <BasePayLoad>(messageData);
await ProcessEvent(sedaEvent);
// Complete the message so that it is not received again.
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = this._azureServiceBusSettings.MaxConcurrentCalls, AutoComplete = false
});
}
private async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
// Deserialize the message to get the original json sent to the producer api
var simpleMessage = JsonConvert.DeserializeObject <SimpleMessage>(Encoding.UTF8.GetString(message.Body));
//await _processData.Process(simpleMessage);
// decide what to communicate back to the service bus
switch (simpleMessage.MessageType)
{
case SimpleMessageType.Complete:
await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
telemetryClient.TrackTrace($"Message with id {message.MessageId} successfully processed");
break;
case SimpleMessageType.SendToDlq:
await subscriptionClient.DeadLetterAsync(message.SystemProperties.LockToken);
telemetryClient.TrackTrace($"Message with id {message.MessageId} sent to DLQ");
break;
case SimpleMessageType.Error:
// increments the delivery count
throw new InvalidOperationException("Cannot process message");
default:
// increments the delivery count
await subscriptionClient.AbandonAsync(message.SystemProperties.LockToken);
telemetryClient.TrackTrace($"Message with id {message.MessageId} abandoned. Retrying shortly...");
break;
}
}
static async void processSub()
{
while (true)
{
var msg = await m_clientSub.ReceiveAsync();
if (msg != null)
{
Console.WriteLine($"SUB: {msg.MessageId}");
if (msg.DeliveryCount > 1)
{
Param p = msg.GetBody <Param>();
Console.WriteLine($"SUB: {msg.MessageId}, {DateTime.Now.Ticks}: {p.A}, {p.B}");
BrokeredMessage msgResp = new BrokeredMessage(p.A - p.B);
msgResp.SessionId = msg.ReplyToSessionId;
await m_queue.SendAsync(msgResp);
await m_clientSub.CompleteAsync(msg.LockToken);
}
else
{
Console.WriteLine($"SUB: {msg.MessageId}, Exception, bad processing - {msg.DeliveryCount}");
}
}
}
}
private async Task HandleSubscriptionMessage(Message message, CancellationToken cancellationToken)
{
var demoMessage = JsonSerializer.Deserialize <DemoMessage>(Encoding.UTF8.GetString(message.Body));
NewMessage?.Invoke(demoMessage);
await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
private async Task ProcessMessageAsync(Message message, CancellationToken cancellationToken)
{
if (message.Label != _subName && _applicationCacheService != null)
{
switch ((ApplicationCacheMessageType)message.UserProperties["type"])
{
case ApplicationCacheMessageType.UpsertOrganizationAbility:
var upsertedOrgId = (Guid)message.UserProperties["id"];
var upsertedOrg = await _organizationRepository.GetByIdAsync(upsertedOrgId);
if (upsertedOrg != null)
{
await _applicationCacheService.BaseUpsertOrganizationAbilityAsync(upsertedOrg);
}
break;
case ApplicationCacheMessageType.DeleteOrganizationAbility:
await _applicationCacheService.BaseDeleteOrganizationAbilityAsync(
(Guid)message.UserProperties["id"]);
break;
default:
break;
}
}
if (!cancellationToken.IsCancellationRequested)
{
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
}
private static async Task MessageHandler(Message message, CancellationToken cancellationToken)
{
string messageText = Encoding.UTF8.GetString(message.Body);
Console.WriteLine($"[{DateTime.Now}] ({message.MessageId}) {messageText}");
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
