private async Task ProcessPayments(ProcessMessageEventArgs args) { var message = args.Message; var body = Encoding.UTF8.GetString(message.Body); PaymentRequestMessage paymentRequestMessage = JsonConvert.DeserializeObject <PaymentRequestMessage>(body); var result = _processPayment.PaymentProcessor(); UpdatePaymentResultMessage updatePaymentResultMessage = new() { Status = result, OrderId = paymentRequestMessage.OrderId, Email = paymentRequestMessage.Email }; try { await _messageBus.PublishMessage(updatePaymentResultMessage, orderupdatepaymentresulttopic); await args.CompleteMessageAsync(args.Message); } catch (Exception e) { throw; } } }
private async Task MessageHandlerAsync(ProcessMessageEventArgs arg) { var message = arg.Message; var body = Encoding.UTF8.GetString(message.Body.ToArray()); var data = JsonSerializer.Deserialize <TEntity>(body, new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); if (ValidateMessage(data)) { if (await ProcessDataAsync(data).ConfigureAwait(false)) { // Now that we're done with "processing" the message, we tell the broker about that being the // case. The MessageReceiver.CompleteAsync operation will settle the message transfer with // the broker and remove it from the broker. await arg.CompleteMessageAsync(message) .ConfigureAwait(false); } else { // If the message does not meet our processing criteria, we will dead letter it, meaning // it is put into a special queue for handling defective messages. The broker will automatically // dead letter the message, if delivery has been attempted too many times. await arg.DeadLetterMessageAsync(message) .ConfigureAwait(false); } } }
static async Task MessageHandler(ProcessMessageEventArgs args) { string body = args.Message.Body.ToString(); Console.WriteLine($"Received: {body}"); await args.CompleteMessageAsync(args.Message); }
private static async Task MessageHandler(ProcessMessageEventArgs args, string subscription) { var message = args.Message; Console.WriteLine($"Received: {message.Body}, id {message.MessageId}, subscription {subscription}"); await args.CompleteMessageAsync(message); }
private async Task Processor_ProcessMessageAsync(ProcessMessageEventArgs arg) { try { var message = arg.Message.Body.ToObjectFromJson <AzureInvalidationMessage>(EntityJsonContext.FullJsonSerializerOptions); if (message.CreationDate < StartTime) { return; } if (message.OriginMachineName == Environment.MachineName && message.OriginApplicationName == Schema.Current.ApplicationName) { return; } Receive?.Invoke(message.MethodName, message.Argument); await arg.CompleteMessageAsync(arg.Message); }catch (Exception ex) { ex.LogException(ex => ex.ControllerName = nameof(AzureServiceBusBroadcast)); } }
public Task onMessage(ProcessMessageEventArgs arg) { string body = arg.Message.Body.ToString(); var message = JsonTool.Deserialize <PubSubMessage>(body); switch (message.ContentType) { case ContentType.NMS_UPDATE: { var obj = JsonTool.Deserialize <ModelUpdateEvent>(message.Content); Handle(obj, null); break; } case ContentType.SCADA_UPDATE: { var obj = JsonTool.Deserialize <ScadaUpdateEvent>(message.Content); Handle(obj, null); break; } case ContentType.SCADA_HISTORY: { var obj = JsonTool.Deserialize <HistoryUpdateEvent>(message.Content); Handle(obj, null); break; } case ContentType.SCADA_DOM: { var obj = JsonTool.Deserialize <DomUpdateEvent>(message.Content); Handle(obj, null); break; } case ContentType.SCADA_HISTORY_GRAPH: { var obj = JsonTool.Deserialize <HistoryGraphicalEvent>(message.Content); Handle(obj, null); break; } case ContentType.CE_UPDATE: { var obj = JsonTool.Deserialize <CeUpdateEvent>(message.Content); Handle(obj, null); break; } case ContentType.CE_HISTORY_GRAPH: { var obj = JsonTool.Deserialize <CeGraphicalEvent>(message.Content); Handle(obj, null); break; } default: break; } return(arg.CompleteMessageAsync(arg.Message)); }
private async Task MessageHandler(ProcessMessageEventArgs arg) { var eventName = arg.Message.Subject; if (_subscriptionManager.HasSubscriptionsForEvent(eventName)) { var subscriptions = _subscriptionManager.GetHandlersForEvent(eventName); foreach (var subscription in subscriptions) { var handler = _serviceProvider.GetService(subscription.HandlerType); if (handler == null) { continue; } var eventType = _subscriptionManager.GetEventTypeByName(eventName); var messageData = Encoding.UTF8.GetString(arg.Message.Body); var integrationEvent = JsonSerializer.Deserialize(messageData, eventType); var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType); await(Task) concreteType.GetMethod("HandleAsync").Invoke(handler, new object[] { integrationEvent }); await arg.CompleteMessageAsync(arg.Message); } } }
private async Task ProcessMessageAsync(ProcessMessageEventArgs args) { var eventTypeName = args.Message.ApplicationProperties["event-type"].ToString(); var(eventType, eventHandlerTypes) = _eventHandlerTypesMap.FirstOrDefault(mapper => mapper.Key.FullName == eventTypeName); if (eventHandlerTypes != null && eventHandlerTypes.Count > 0) { var taskSelect = eventHandlerTypes.Select(eventHandlerType => { using var scope = _autofac.BeginLifetimeScope(AUTOFAC_SCOPE_NAME); var eventHandler = scope.ResolveOptional(eventHandlerType); if (eventHandler == null) { return(Task.CompletedTask); } var integrationEvent = JsonConvert.DeserializeObject(args.Message.Body.ToString(), eventType); var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType); return((Task)concreteType.GetMethod("HandleAsync") ?.Invoke(eventHandler, new object[] { integrationEvent })); }); await Task.WhenAll(taskSelect); } await args.CompleteMessageAsync(args.Message); }
private async Task MessageHandler(ProcessMessageEventArgs args) { try { _logger.LogInformation($"client '{_systemInfo.ClientId}' received message '{args.Message.MessageId}'. Processing..."); var message = await _messageParser.DeserializeAsync <TM>(args.Message.Body); await _messageProcessor.ProcessAsync((dynamic)message, args.CancellationToken); await args.CompleteMessageAsync(args.Message).ConfigureAwait(false); } catch (Exception ex) { _logger.LogError(ex, $"an error has occurred while processing message '{args.Message.MessageId}': {ex.Message}"); if (args.Message.DeliveryCount > 3) { await args.DeadLetterMessageAsync(args.Message).ConfigureAwait(false); } else { await args.AbandonMessageAsync(args.Message).ConfigureAwait(false); } } }
public async Task UserSettledPropertySetCorrectly() { var msg = new ServiceBusReceivedMessage(); var args = new ProcessMessageEventArgs( msg, new Mock <ServiceBusReceiver>().Object, CancellationToken.None); Assert.IsFalse(msg.IsSettled); msg.IsSettled = false; await args.AbandonMessageAsync(msg); Assert.IsTrue(msg.IsSettled); await args.CompleteMessageAsync(msg); Assert.IsTrue(msg.IsSettled); msg.IsSettled = false; await args.DeadLetterMessageAsync(msg); Assert.IsTrue(msg.IsSettled); msg.IsSettled = false; await args.DeadLetterMessageAsync(msg, "reason"); Assert.IsTrue(msg.IsSettled); msg.IsSettled = false; await args.DeferMessageAsync(msg); Assert.IsTrue(msg.IsSettled); }
private async Task HandleMessageAsync(ProcessMessageEventArgs processMessageEventArgs) { try { var rawMessageBody = Encoding.UTF8.GetString(processMessageEventArgs.Message.Body.ToBytes().ToArray()); Logger.LogInformation("Received message {MessageId} with body {MessageBody}", processMessageEventArgs.Message.MessageId, rawMessageBody); var order = JsonConvert.DeserializeObject <TMessage>(rawMessageBody); if (order != null) { await ProcessMessage(order, processMessageEventArgs.Message.MessageId, processMessageEventArgs.Message.ApplicationProperties, processMessageEventArgs.CancellationToken); } else { Logger.LogError( "Unable to deserialize to message contract {ContractName} for message {MessageBody}", typeof(TMessage), rawMessageBody); } Logger.LogInformation("Message {MessageId} processed", processMessageEventArgs.Message.MessageId); await processMessageEventArgs.CompleteMessageAsync(processMessageEventArgs.Message); } catch (Exception ex) { Logger.LogError(ex, "Unable to handle message"); } }
private async Task ProcessMessagesAsync(ProcessMessageEventArgs args) { var message = args.Message; var messageText = message.Body.ToString(); Console.WriteLine($"Received message: {messageText}, delivery count: {message.DeliveryCount}"); /* * Note: Un-commenting below line will cause message to be 'abandoned' immediately. * Message delivery will be retried if max delivery count has not been exceeded. */ // throw new Exception("thrown deliberately"); /* * Note: un-commenting below line will cause message to be 'abandoned' immediately. * Message delivery will be retried if max delivery count has not been exceeded. */ // await args.AbandonMessageAsync(message); /* * Note: un-commenting below line will cause message to be 'deadlettered' immediately. * Message delivery will NOT be retried (irrespective of whether the message delivery count * has been exceeded or not). */ // await args.DeadLetterMessageAsync(message); /* * Note: un-commenting below line will cause message to be marked 'completed' immediately. * Technically this is not required since MessageHandlerOptions's 'autoComplete' is set to true by default. */ await args.CompleteMessageAsync(message); }
private async Task MessageHandler(ProcessMessageEventArgs e) { string data = e.Message.Body.ToString(); mensajes.Add(data); //DEBEMOS IR ELIMINANDO LOS MENSAJES DE LA COLA COMO LEIDOS/PROCESADOS await e.CompleteMessageAsync(e.Message); }
private async Task MessageHandlerAsync(ProcessMessageEventArgs args) { var messageAsString = args.Message.Body.ToString(); await _messageHandler(messageAsString); await args.CompleteMessageAsync(args.Message); }
// handle received messages async Task MessageHandler(ProcessMessageEventArgs args) { var body = args.Message.Body.ToString(); _cacheContainerService.RefreshCache(body); // complete the message. messages is deleted from the subscription. await args.CompleteMessageAsync(args.Message); }
private async Task OnMessageReceivedAsync <TEvent, TConsumer>(EventRegistration ereg, EventConsumerRegistration creg, ProcessMessageEventArgs args) where TEvent : class where TConsumer : IEventConsumer <TEvent> { var message = args.Message; var messageId = message.MessageId; var cancellationToken = args.CancellationToken; message.ApplicationProperties.TryGetValue(AttributeNames.ActivityId, out var parentActivityId); using var log_scope = Logger.BeginScopeForConsume(id: messageId, correlationId: message.CorrelationId, sequenceNumber: message.SequenceNumber, extras: new Dictionary <string, string> { ["EnqueuedSequenceNumber"] = message.EnqueuedSequenceNumber.ToString(), }); // Instrumentation using var activity = EventBusActivitySource.StartActivity(ActivityNames.Consume, ActivityKind.Consumer, parentActivityId?.ToString()); activity?.AddTag(ActivityTagNames.EventBusEventType, typeof(TEvent).FullName); activity?.AddTag(ActivityTagNames.EventBusConsumerType, typeof(TConsumer).FullName); activity?.AddTag(ActivityTagNames.MessagingSystem, Name); var destination = TransportOptions.UseBasicTier || ereg.UseQueueInsteadOfTopic() ? ereg.EventName : creg.ConsumerName; activity?.AddTag(ActivityTagNames.MessagingDestination, destination); // name of the queue/subscription activity?.AddTag(ActivityTagNames.MessagingDestinationKind, "queue"); // the spec does not know subscription so we can only use queue for both try { Logger.LogDebug("Processing '{MessageId}'", messageId); using var scope = CreateScope(); using var ms = message.Body.ToStream(); var contentType = new ContentType(message.ContentType); var context = await DeserializeAsync <TEvent>(body : ms, contentType : contentType, registration : ereg, scope : scope, cancellationToken : cancellationToken); Logger.LogInformation("Received message: '{MessageId}' containing Event '{Id}'", messageId, context.Id); await ConsumeAsync <TEvent, TConsumer>(@event : context, scope : scope, cancellationToken : cancellationToken); // Complete the message Logger.LogDebug("Completing message: {MessageId}.", messageId); await args.CompleteMessageAsync(message : message, cancellationToken : cancellationToken); } catch (Exception ex) { Logger.LogError(ex, "Event processing failed. Moving to deadletter."); await args.DeadLetterMessageAsync(message : message, cancellationToken : cancellationToken); } }
static async Task MessageHandler(ProcessMessageEventArgs args) { var body = args.Message.Body.ToString(); Console.WriteLine($"Received Message: { body }"); // we can evaluate application logic and use that to determine how to settle the message. await args.CompleteMessageAsync(args.Message); }
private static async Task MessageHandler(ProcessMessageEventArgs args) { var result = args.Message.Body.ToObjectFromJson <MessageTest <MyClass> >(); Console.WriteLine($"Received: {result}"); // complete the message. messages is deleted from the queue. await args.CompleteMessageAsync(args.Message); }
// handle received messages static async Task MessageHandler(ProcessMessageEventArgs args) { string body = args.Message.Body.ToString(); _nomes.Add(body); // complete the message. messages is deleted from the queue. await args.CompleteMessageAsync(args.Message); }
// handle received messages static async Task MessageHandler(ProcessMessageEventArgs args) { string body = args.Message.Body.ToString(); Console.WriteLine($"Received: {body}"); // complete the message. messages is deleted from the queue. await args.CompleteMessageAsync(args.Message); }
static async Task MessageHandler(ProcessMessageEventArgs args) { var body = args.Message.Body.ToString(); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine($"Received: {body}"); await args.CompleteMessageAsync(args.Message); }
static async Task ProcessMessagesAsync(ProcessMessageEventArgs args) { // Process the message. Console.WriteLine($"Received message: SequenceNumber:{args.Message.SequenceNumber} Body:{Encoding.UTF8.GetString(args.Message.Body)}"); // Complete the message so that it is not received again. // This can be done only if the queue Client is created in ReceiveMode.PeekLock mode (which is the default). await args.CompleteMessageAsync(args.Message); }
private async Task ProcessQueueMessageAsync(ProcessMessageEventArgs arg) { string body = arg.Message.Body.ToString(); QueueMessageModel queueMessageModel = JsonConvert.DeserializeObject <QueueMessageModel>(body); System.Console.WriteLine($"The queue message body is {queueMessageModel.TransactionId}"); await arg.CompleteMessageAsync(arg.Message); }
private async Task MessageHandler(ProcessMessageEventArgs args) { var eventName = $"{args.Message.Subject}{INTEGRATION_EVENT_SUFFIX}"; var messageData = Encoding.UTF8.GetString(args.Message.Body.ToArray()); // Complete the message so that it is not received again. if (await ProcessEvent(eventName, messageData)) { await args.CompleteMessageAsync(args.Message); } }
static async Task MessageHandler(ProcessMessageEventArgs args) { string body = args.Message.Body.ToString(); var payload = JsonConvert.DeserializeObject <Notification>(body); Console.WriteLine("Received notification"); //Update table await getTable(payload.Url); await args.CompleteMessageAsync(args.Message); }
static async Task MessageHandler(ProcessMessageEventArgs args) { string body = args.Message.Body.ToString(); Console.WriteLine($"Received: {body}"); var signUpCourse = JsonConvert.DeserializeObject <SignUpToCourseDto>(body); //process the msg and verify if the student is able to enter the course based in some rules as capacity of the course, etc. await args.CompleteMessageAsync(args.Message); }
/// <summary> /// Handles service bus messages. /// </summary> private async Task ServiceBusMessageHandler(ProcessMessageEventArgs args) { string body = args.Message.Body.ToString(); NotificationData notificationData = null; try { notificationData = JsonConvert.DeserializeObject <NotificationData>(body); } catch (JsonSerializationException ex) { Log.Warning(ex, "Failed to deserialize notification"); } if (notificationData != null) { // If it's a system notification, handle it directly, otherwise pass it along if (notificationData.Type == NotificationType.System) { switch (notificationData.SubType) { case SubType.SettingsUpdate: await this.UpdateSettingsAsync(); break; case SubType.Shutdown: Log.Information("Shutdown notification received"); this.exitCode = (int)ExitCode.ExpectedShutdown; break; default: Log.Error($"Error processing notification, unrecognized subtype: {notificationData.SubType}"); break; } } else { try { await this.SendNotification(notificationData); } catch (Exception ex) { Log.Error(ex, "Error processing notification"); } } } // For now, no retries. Regardless of notification send success, complete it. await args.CompleteMessageAsync(args.Message); }
private async Task OnOrderPaymentUpdateReceived(ProcessMessageEventArgs args) { var messageBody = Encoding.UTF8.GetString(args.Message.Body); var orderPaymentUpdateMessage = JsonConvert.DeserializeObject <OrderPaymentUpdateMessage>(messageBody); await using var _orderDbContext = new OrderDbContext(_options); var order = await _orderDbContext.Orders.FindAsync(orderPaymentUpdateMessage.OrderId); order.OrderPaid = orderPaymentUpdateMessage.PaymentSuccess; await _orderDbContext.SaveChangesAsync(); await args.CompleteMessageAsync(args.Message); }
static async Task ActionSuccesReception(ProcessMessageEventArgs consommateur) { string contenuMessage = consommateur.Message.Body.ToString(); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("Message recu : " + contenuMessage); Console.ForegroundColor = ConsoleColor.White; await consommateur.CompleteMessageAsync(consommateur.Message); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("Confirmation de traitement Envoyée : " + contenuMessage); Console.ForegroundColor = ConsoleColor.White; }
static async Task MessageHandler(ProcessMessageEventArgs args) { string body = args.Message.Body.ToString(); var receivingPayload = JsonConvert.DeserializeObject <ReceptionPayload>(body); string rec_load = JsonConvert.SerializeObject(receivingPayload); var sendingPayload = JsonConvert.DeserializeObject <SendingPayload>(rec_load); File.WriteAllBytes(@"current.json", Convert.FromBase64String(receivingPayload.ContextImageJpg)); await CheckPreviousMatch(); await using (FileStream my_stream = new FileStream("current.json", FileMode.Open, FileAccess.Read)) { sendingPayload.ContextImageReference = await Problem3.UploadImage(@"current.json", my_stream); } Console.WriteLine("Current time: {0:HH:mm:ss.fff}", DateTime.Now); Console.WriteLine(receivingPayload.LicensePlate); Console.WriteLine("[{0}]", string.Join(", ", Table.table)); if (checkMatch(receivingPayload.LicensePlate)) { sendingPayload.LicensePlate = matched; string sen_load = JsonConvert.SerializeObject(sendingPayload); Console.WriteLine(sen_load); var response = await client.PostAsync(uri, new StringContent(sen_load, Encoding.UTF8, "application/json")); Console.WriteLine("Sent data to server, response : " + response); Console.WriteLine("Found match !"); } else { var result = await Problem5.MakeRequest(sendingPayload.ContextImageReference); string sendingPayloadString = JsonConvert.SerializeObject(sendingPayload); var waitingPayload = JsonConvert.DeserializeObject <WaitingPayload>(sendingPayloadString); waitingPayload.Id = result; queue.Enqueue(waitingPayload); Console.WriteLine("No match, sending to Azure recognition"); } Console.WriteLine(); Console.WriteLine(); Console.WriteLine(); Console.WriteLine(); // complete the message. messages is deleted from the queue. await args.CompleteMessageAsync(args.Message); }