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);
    }
Example #2
0
        /// <summary>
        /// Tries to process the unhandled <paramref name="message"/> through an potential registered <see cref="IAzureServiceBusFallbackMessageHandler"/> instance.
        /// </summary>
        /// <param name="messageReceiver">
        ///     The instance that can receive Azure Service Bus <see cref="ServiceBusReceivedMessage"/>; used within <see cref="IAzureServiceBusFallbackMessageHandler"/>s with Azure Service Bus specific operations.
        /// </param>
        /// <param name="message">The message that was received by the <paramref name="messageReceiver"/>.</param>
        /// <param name="messageContext">The context in which the <paramref name="message"/> should be processed.</param>
        /// <param name="correlationInfo">The information concerning correlation of telemetry and processes by using a variety of unique identifiers.</param>
        /// <param name="cancellationToken">The token to cancel the message processing.</param>
        /// <exception cref="ArgumentNullException">
        ///     Thrown when the <paramref name="messageReceiver"/>, <paramref name="message"/>, <paramref name="messageContext"/>, or <paramref name="correlationInfo"/> is <c>null</c>.
        /// </exception>
        protected async Task TryServiceBusFallbackMessageAsync(
            ServiceBusReceiver messageReceiver,
            ServiceBusReceivedMessage message,
            AzureServiceBusMessageContext messageContext,
            MessageCorrelationInfo correlationInfo,
            CancellationToken cancellationToken)
        {
            Guard.NotNull(message, nameof(message), "Requires an Azure Service Bus message to be processed by the registered fallback message handler");
            Guard.NotNull(messageContext, nameof(messageContext), "Requires an Azure Service Bus message context in which the incoming message can be processed");
            Guard.NotNull(correlationInfo, nameof(correlationInfo), "Requires an correlation information to correlate between incoming Azure Service Bus messages");

            if (HasAzureServiceBusFallbackHandler)
            {
                if (_fallbackMessageHandler.Value is AzureServiceBusMessageHandlerTemplate template)
                {
                    if (messageReceiver is null)
                    {
                        Logger.LogWarning("Fallback message handler '{MessageHandlerType}' uses specific Azure Service Bus operations, but is unable to be configured during message routing because the message router didn't receive a Azure Service Bus message receiver; use other '{RouteMessageAsync}' method overload",
                                          _fallbackMessageHandler.Value.GetType().Name, nameof(RouteMessageAsync));
                    }
                    else
                    {
                        var args = new ProcessMessageEventArgs(message, messageReceiver, cancellationToken);
                        template.SetProcessMessageEventArgs(args);
                    }
                }

                string fallbackMessageHandlerTypeName = _fallbackMessageHandler.Value.GetType().Name;
                Logger.LogTrace("Fallback on registered '{FallbackMessageHandlerType}' because none of the message handlers w ere able to process the message", fallbackMessageHandlerTypeName);
                await _fallbackMessageHandler.Value.ProcessMessageAsync(message, messageContext, correlationInfo, cancellationToken);

                Logger.LogTrace("Fallback message handler '{FallbackMessageHandlerType}' has processed the message", fallbackMessageHandlerTypeName);
            }
        }
Example #3
0
        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);
        }
Example #4
0
        public void ProcessMessageAsync_LogsWarning_Disposed()
        {
            try
            {
                _listener.Disposed = true;
                var message = ServiceBusModelFactory.ServiceBusReceivedMessage(
                    messageId: Guid.NewGuid().ToString(),
                    sequenceNumber: 1,
                    deliveryCount: 55,
                    enqueuedTime: DateTimeOffset.Now,
                    lockedUntil: DateTimeOffset.Now);
                var receiver = new Mock <ServiceBusReceiver>().Object;
                var args     = new ProcessMessageEventArgs(message, receiver, CancellationToken.None);

                Assert.That(
                    async() => await _listener.ProcessMessageAsync(args),
                    Throws.InstanceOf <InvalidOperationException>());

                Assert.NotNull(_loggerProvider.GetAllLogMessages()
                               .SingleOrDefault(
                                   x => x.FormattedMessage.StartsWith("Message received for a listener that is not in a running state. The message will not be delivered to the function, " +
                                                                      "and instead will be abandoned. (Listener started = True, Listener disposed = True") && x.Level == LogLevel.Warning));
            }
            finally
            {
                _listener.Disposed = false;
                _loggerProvider.ClearAllLogMessages();
            }
        }
        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");
            }
        }
Example #6
0
        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);
        }
Example #7
0
        public async Task ProcessMessageAsync_Success()
        {
            var message = ServiceBusModelFactory.ServiceBusReceivedMessage(
                messageId: Guid.NewGuid().ToString(),
                sequenceNumber: 1,
                deliveryCount: 55,
                enqueuedTime: DateTimeOffset.Now,
                lockedUntil: DateTimeOffset.Now);
            var receiver = new Mock <ServiceBusReceiver>().Object;
            var args     = new ProcessMessageEventArgs(message, receiver, CancellationToken.None);

            _mockMessageProcessor.Setup(p => p.BeginProcessingMessageAsync(It.IsAny <ServiceBusMessageActions>(), message, It.IsAny <CancellationToken>())).ReturnsAsync(true);

            FunctionResult result = new FunctionResult(true);

            _mockExecutor.Setup(p => p.TryExecuteAsync(It.Is <TriggeredFunctionData>(q => ((ServiceBusTriggerInput)q.TriggerValue).Messages[0] == message), It.IsAny <CancellationToken>())).ReturnsAsync(result);

            _mockMessageProcessor.Setup(p => p.CompleteProcessingMessageAsync(It.IsAny <ServiceBusMessageActions>(), message, result, It.IsAny <CancellationToken>())).Returns(Task.FromResult(0));

            await _listener.ProcessMessageAsync(args);

            _mockMessageProcessor.VerifyAll();
            _mockExecutor.VerifyAll();
            _mockMessageProcessor.VerifyAll();
        }
        static async Task MessageHandler(ProcessMessageEventArgs args)
        {
            string body = args.Message.Body.ToString();

            Console.WriteLine($"Received: {body}");
            await args.CompleteMessageAsync(args.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));
        }
    }
Example #10
0
 private void WriteProcessLog(ProcessMessageEventArgs e)
 {
     lock (_processLogsLocker)
     {
         Application.Current.Dispatcher.Invoke(() => this.ProcessLogs.Insert(0, e));
     }
 }
Example #11
0
        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 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);
                }
            }
        }
Example #13
0
        internal async Task ProcessMessageAsync(ProcessMessageEventArgs args)
        {
            EnsureIsRunning();

            _concurrencyUpdateManager?.MessageProcessed();

            using (CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(args.CancellationToken, _cancellationTokenSource.Token))
            {
                var actions = new ServiceBusMessageActions(args);
                if (!await _messageProcessor.Value.BeginProcessingMessageAsync(actions, args.Message, linkedCts.Token).ConfigureAwait(false))
                {
                    return;
                }

                var receiveActions           = new ServiceBusReceiveActions(args);
                ServiceBusTriggerInput input = ServiceBusTriggerInput.CreateSingle(args.Message, actions, receiveActions, _client.Value);

                TriggeredFunctionData data = input.GetTriggerFunctionData();

                FunctionResult result = await _triggerExecutor.TryExecuteAsync(data, linkedCts.Token).ConfigureAwait(false);

                try
                {
                    await _messageProcessor.Value.CompleteProcessingMessageAsync(actions, args.Message, result, linkedCts.Token)
                    .ConfigureAwait(false);
                }
                finally
                {
                    receiveActions.EndExecutionScope();
                }
            }
        }
Example #14
0
        private async Task OnMessageReceivedAsync(ProcessMessageEventArgs args)
        {
            var message = args.Message;

            _logger.LogDebug("Message received with ID {MessageId}", message.MessageId);
            await TriggerWorkflowsAsync(new ServiceBusMessage(message), CancellationToken.None);
        }
Example #15
0
        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));
        }
Example #16
0
        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);
                }
            }
        }
Example #17
0
        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;
            }
        }
    }
Example #18
0
        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);
        }
Example #19
0
        /// <summary>
        /// Handle a new <paramref name="message"/> that was received by routing them through registered <see cref="IAzureServiceBusMessageHandler{TMessage}"/>s
        /// and optionally through an registered <see cref="IFallbackMessageHandler"/> or <see cref="IAzureServiceBusFallbackMessageHandler"/> if none of the message handlers were able to process the <paramref name="message"/>.
        /// </summary>
        /// <param name="messageReceiver">
        ///     The instance that can receive Azure Service Bus <see cref="ServiceBusReceivedMessage"/>; used within <see cref="IMessageHandler{TMessage,TMessageContext}"/>s with Azure Service Bus specific operations.
        /// </param>
        /// <param name="message">The message that was received by the <paramref name="messageReceiver"/>.</param>
        /// <param name="messageContext">The context in which the <paramref name="message"/> should be processed.</param>
        /// <param name="correlationInfo">The information concerning correlation of telemetry and processes by using a variety of unique identifiers.</param>
        /// <param name="cancellationToken">The token to cancel the message processing.</param>
        /// <exception cref="ArgumentNullException">
        ///     Thrown when the <paramref name="messageReceiver"/>, <paramref name="message"/>, <paramref name="messageContext"/>, or <paramref name="correlationInfo"/> is <c>null</c>.
        /// </exception>
        /// <exception cref="InvalidOperationException">Thrown when no message handlers or none matching message handlers are found to process the message.</exception>
        protected async Task RouteMessageWithPotentialFallbackAsync(
            ServiceBusReceiver messageReceiver,
            ServiceBusReceivedMessage message,
            AzureServiceBusMessageContext messageContext,
            MessageCorrelationInfo correlationInfo,
            CancellationToken cancellationToken)
        {
            Guard.NotNull(message, nameof(message), "Requires an Azure Service Bus message to be processed by the registered message handlers");
            Guard.NotNull(messageContext, nameof(messageContext), "Requires an Azure Service Bus message context in which the incoming message can be processed");
            Guard.NotNull(correlationInfo, nameof(correlationInfo), "Requires an correlation information to correlate between incoming Azure Service Bus messages");

            try
            {
                MessageHandler[] messageHandlers = GetRegisteredMessageHandlers().ToArray();
                if (messageHandlers.Length <= 0 && !HasFallbackMessageHandler && !HasAzureServiceBusFallbackHandler)
                {
                    throw new InvalidOperationException(
                              $"Azure Service Bus message pump cannot correctly process the message in the '{nameof(AzureServiceBusMessageContext)}' "
                              + "because no 'IAzureServiceBusMessageHandler<>' was registered in the dependency injection container. "
                              + $"Make sure you call the correct 'WithServiceBusMessageHandler' extension on the {nameof(IServiceCollection)} "
                              + "during the registration of the Azure Service Bus message pump or message router to register a message handler");
                }

                Encoding encoding    = messageContext.GetMessageEncodingProperty(Logger);
                string   messageBody = encoding.GetString(message.Body.ToArray());

                foreach (MessageHandler messageHandler in messageHandlers)
                {
                    MessageResult result = await DeserializeMessageForHandlerAsync(messageBody, messageContext, messageHandler);

                    if (result.IsSuccess)
                    {
                        var args = new ProcessMessageEventArgs(message, messageReceiver, cancellationToken);
                        SetServiceBusPropertiesForSpecificOperations(messageHandler, args, messageContext);

                        await messageHandler.ProcessMessageAsync(result.DeserializedMessage, messageContext, correlationInfo, cancellationToken);

                        return;
                    }
                }

                if (!HasFallbackMessageHandler && !HasAzureServiceBusFallbackHandler)
                {
                    throw new InvalidOperationException(
                              $"Message pump cannot correctly process the message in the '{nameof(AzureServiceBusMessageContext)}' "
                              + "because none of the registered 'IAzureServiceBusMessageHandler<,>' implementations in the dependency injection container matches the incoming message type and context; "
                              + $"and no '{nameof(IFallbackMessageHandler)}' or '{nameof(IAzureServiceBusFallbackMessageHandler)}' was registered to fall back to."
                              + $"Make sure you call the correct '.WithServiceBusMessageHandler' extension on the {nameof(IServiceCollection)} during the registration of the message pump or message router to register a message handler");
                }

                await TryFallbackProcessMessageAsync(messageBody, messageContext, correlationInfo, cancellationToken);
                await TryServiceBusFallbackMessageAsync(messageReceiver, message, messageContext, correlationInfo, cancellationToken);
            }
            catch (Exception exception)
            {
                Logger.LogCritical(exception, "Unable to process message with ID '{MessageId}'", message.MessageId);
                throw;
            }
        }
Example #20
0
 public ServiceBusMessageStateHandler(ProcessMessageEventArgs processMessage, IMessageSerializer serializer, int deadLetterDeliveryLimit, IDependencyInjection messageScope)
 {
     DeadLetterDeliveryLimit = deadLetterDeliveryLimit;
     MessageScope            = messageScope;
     _processMessage         = processMessage;
     _sbMessage = processMessage.Message;
     _message   = serializer.Deserialize <T>(_sbMessage.Body.ToMemory());
 }
        private async Task MessageHandlerAsync(ProcessMessageEventArgs args)
        {
            var messageAsString = args.Message.Body.ToString();

            await _messageHandler(messageAsString);

            await args.CompleteMessageAsync(args.Message);
        }
        private async Task _processor_ProcessMessageAsync(ProcessMessageEventArgs arg)
        {
            EndedHow = Ended.Success;

            _wait.Set();

            await Task.CompletedTask;
        }
        // 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);
        }
Example #24
0
        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 ClientOnProcessMessageAsync(ProcessMessageEventArgs arg)
        {
            var stateHandler = new ServiceBusMessageStateHandler <TTopic>(arg, _serializer, _deadLetterLimit, _hostConfiguration.DependencyInjection);

            using (var cts = CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken, arg.CancellationToken))
            {
                await _processor.ProcessAsync(stateHandler, cts.Token).ConfigureAwait(false);
            }
        }
Example #26
0
        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);
        }
Example #27
0
        // 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);
        }
Example #28
0
        private async Task ProcessMessageAsync(ProcessMessageEventArgs args)
        {
            logger.LogDebug("Processing message received by Service Bus");

            // Services with scoped lifetime cannot be injected directly into a HostedService
            using var scope = serviceScopeFactory.CreateScope();
            var pushNotifyer = scope.ServiceProvider.GetRequiredService <IPushNotifyer>();
            await pushNotifyer.SendAsync(args.Message.Body.ToString(), "ANY");
        }
Example #29
0
        // 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);
        }
Example #30
0
        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);
        }
Example #31
0
        static void server_ProcessMessage(object sender, ProcessMessageEventArgs<MyContext> eventArgs)
        {
            Message request = eventArgs.Context.Request;

            Console.WriteLine();
            Console.WriteLine("==========");
            Console.WriteLine();
            Console.WriteLine("request:");

            Console.WriteLine("Timestamp: " + eventArgs.Timestamp);
            Console.WriteLine("TransportTime: " + eventArgs.TransitTime);
            Console.WriteLine(request.ToString());
            Message response = eventArgs.Context.Response;

            if (request.Values.ContainsKey("Action"))
            {
                switch (request.Values["Action"])
                {
                    case "Time?":
                        response.Values.Add("Return", "My local time is " + DateTime.Now);
                        break;
                    case "Write":
                        if (request.Values.ContainsKey("Text"))
                            Console.WriteLine(request.Values["Text"]);
                        else
                            response.ErrorMessage = "Text not set!";
                        break;
                    default:
                        response.ErrorMessage = "Unknown action '" + request.Values["Action"];
                        break;

                }
            }
            else
                response.ErrorMessage = "I don't know what to do with this message!";

            Console.WriteLine();
            Console.WriteLine("Response:");
            Console.WriteLine(response);
        }
Example #32
0
        private void server_ProcessMessage(object sender, ProcessMessageEventArgs<WebHookContext> eventArgs)
        {
            var context = eventArgs.Context;
            var request = context.Request;
            var response = context.Response;

            if (eventArgs.TransitTime == null)
            {
                throw new WebCommunicator.Exceptions.CommunicationException("Transit Time not set.");
            }
            if (eventArgs.TransitTime.Value.TotalMinutes > 5)
            {
                throw new WebCommunicator.Exceptions.CommunicationException("Transit Time too long. (max time is 5 minutes, transit time for this message was " + eventArgs.TransitTime + ")");
            }

            if (!request.Values.ContainsKey("Action"))
            {
                throw new WebCommunicator.Exceptions.CommunicationException("Action not set.");
            }

            string action = request.Values["Action"];

            if (!actionHandlers.ContainsKey(action))
            {
                throw new WebCommunicator.Exceptions.CommunicationException("I don't know how to handle that action. (" + action + ")");
            }

            if (context.Computer == null)
            {
                response.ErrorMessage = "computer is null. (14729)";
                return;
            }

            if (context.User == null)
            {
                response.ErrorMessage = "user is null. (85621)";
                return;
            }

            actionHandlers[action].ProcessMessage(context);

            context.Database.Dispose();
        }