private async Task <object> ExecuteConsumer(TMessage msg, object message, object response, object consumerInstance) { if (_consumerWithContext && _consumerContextInitializer != null) { var consumerContext = new ConsumerContext(); _consumerContextInitializer(msg, consumerContext); var consumerWithContext = (IConsumerContextAware)consumerInstance; consumerWithContext.Context.Value = consumerContext; } // the consumer just subscribes to the message var task = _consumerSettings.ConsumerMethod(consumerInstance, message, _consumerSettings.Topic); await task.ConfigureAwait(false); if (_consumerSettings.ConsumerMode == ConsumerMode.RequestResponse) { // the consumer handles the request (and replies) response = _consumerSettings.ConsumerMethodResult(task); } return(response); }
private async Task <Task> ExecuteConsumer(Type messageType, object message, byte[] messagePayload, ConsumerSettings consumerSettings) { var createMessageScope = IsMessageScopeEnabled(consumerSettings); if (createMessageScope) { _logger.LogDebug("Creating message scope for {message} of type {messageType}", message, consumerSettings.MessageType); } var messageScope = createMessageScope ? Settings.DependencyResolver.CreateScope() : Settings.DependencyResolver; try { MessageScope.Current = messageScope; // obtain the consumer from chosen DI container (root or scope) _logger.LogDebug("Resolving consumer type {consumerType}", consumerSettings.ConsumerType); var consumerInstance = messageScope.Resolve(consumerSettings.ConsumerType); if (consumerInstance == null) { throw new ConfigurationMessageBusException($"The dependency resolver does not know how to create an instance of {consumerSettings.ConsumerType}"); } Task consumerTask = null; try { var messageForConsumer = !ProviderSettings.EnableMessageSerialization ? message // prevent deep copy of the message : consumerSettings.ConsumerMode == ConsumerMode.RequestResponse ? DeserializeRequest(messageType, messagePayload, out var _) // will pass a deep copy of the message : DeserializeMessage(messageType, messagePayload); // will pass a deep copy of the message _logger.LogDebug("Executing consumer instance {consumer} of type {consumerType} for message {message}", consumerInstance, consumerSettings.ConsumerType, message); consumerTask = consumerSettings.ConsumerMethod(consumerInstance, messageForConsumer, consumerSettings.Topic); await consumerTask.ConfigureAwait(false); } finally { if (consumerSettings.IsDisposeConsumerEnabled && consumerInstance is IDisposable consumerInstanceDisposable) { _logger.LogDebug("Dosposing consumer instance {consumer} of type {consumerType}", consumerInstance, consumerSettings.ConsumerType); consumerInstanceDisposable.DisposeSilently("ConsumerInstance", _logger); } } return(consumerTask); } finally { MessageScope.Current = null; if (createMessageScope) { _logger.LogDebug("Disposing message scope for {message} of type {messageType}", message, messageType); messageScope.DisposeSilently("Scope", _logger); } } }
public virtual async Task <Exception> ProcessMessage(TMessage msg) { Exception exceptionResult = null; try { DeserializeMessage(msg, out var requestMessage, out var requestId, out var expires, out var message); // Verify if the request/message is already expired if (expires != null) { var currentTime = _messageBus.CurrentTime; if (currentTime > expires.Value) { _logger.LogWarning("The message arrived too late and is already expired (expires {0}, current {1})", expires.Value, currentTime); try { // Execute the event hook _consumerSettings.OnMessageExpired?.Invoke(_messageBus, _consumerSettings, message, msg); _messageBus.Settings.OnMessageExpired?.Invoke(_messageBus, _consumerSettings, message, msg); } catch (Exception eh) { MessageBusBase.HookFailed(_logger, eh, nameof(IConsumerEvents.OnMessageExpired)); } // Do not process the expired message return(null); } } object response = null; string responseError = null; var consumerInstance = await _instancesQueue.ReceiveAsync(_messageBus.CancellationToken).ConfigureAwait(false); try { if (_consumerWithContext && _consumerContextInitializer != null) { var consumerContext = new ConsumerContext(); _consumerContextInitializer(msg, consumerContext); var consumerWithContext = (IConsumerContextAware)consumerInstance; consumerWithContext.Context.Value = consumerContext; } try { // Execute the event hook _consumerSettings.OnMessageArrived?.Invoke(_messageBus, _consumerSettings, message, _consumerSettings.Topic, msg); _messageBus.Settings.OnMessageArrived?.Invoke(_messageBus, _consumerSettings, message, _consumerSettings.Topic, msg); } catch (Exception eh) { MessageBusBase.HookFailed(_logger, eh, nameof(IConsumerEvents.OnMessageArrived)); } // the consumer just subscribes to the message var task = _consumerSettings.ConsumerMethod(consumerInstance, message, _consumerSettings.Topic); await task.ConfigureAwait(false); if (_consumerSettings.ConsumerMode == ConsumerMode.RequestResponse) { // the consumer handles the request (and replies) response = _consumerSettings.ConsumerMethodResult(task); } } catch (Exception e) { if (_consumerSettings.ConsumerMode == ConsumerMode.RequestResponse) { _logger.LogError(e, "Handler execution failed"); // Save the exception responseError = e.ToString(); } else { _logger.LogError(e, "Consumer execution failed"); } try { // Execute the event hook _consumerSettings.OnMessageFault?.Invoke(_messageBus, _consumerSettings, message, e, msg); _messageBus.Settings.OnMessageFault?.Invoke(_messageBus, _consumerSettings, message, e, msg); } catch (Exception eh) { MessageBusBase.HookFailed(_logger, eh, nameof(IConsumerEvents.OnMessageFault)); } exceptionResult = e; } finally { await _instancesQueue.SendAsync(consumerInstance).ConfigureAwait(false); } if (response != null || responseError != null) { // send the response (or error response) _logger.LogDebug("Serializing the response {0} of type {1} for RequestId: {2}...", response, _consumerSettings.ResponseType, requestId); var responseMessage = new MessageWithHeaders(); responseMessage.SetHeader(ReqRespMessageHeaders.RequestId, requestId); responseMessage.SetHeader(ReqRespMessageHeaders.Error, responseError); await _messageBus.ProduceResponse(message, requestMessage, response, responseMessage, _consumerSettings).ConfigureAwait(false); } } catch (Exception e) { _logger.LogError(e, "Processing of the message {0} of type {1} failed", msg, _consumerSettings.MessageType); exceptionResult = e; } return(exceptionResult); }
public virtual async Task ProcessMessage(TMessage msg) { var msgPayload = _messagePayloadProvider(msg); MessageWithHeaders requestMessage = null; string requestId = null; DateTimeOffset? expires = null; _log.Debug("Deserializing message..."); var message = _consumerSettings.IsRequestMessage ? _messageBus.DeserializeRequest(_consumerSettings.MessageType, msgPayload, out requestMessage) : _messageBus.Settings.Serializer.Deserialize(_consumerSettings.MessageType, msgPayload); if (requestMessage != null) { requestMessage.TryGetHeader(ReqRespMessageHeaders.RequestId, out requestId); requestMessage.TryGetHeader(ReqRespMessageHeaders.Expires, out expires); } // Verify if the request/message is already expired if (expires.HasValue) { var currentTime = _messageBus.CurrentTime; if (currentTime > expires.Value) { _log.WarnFormat(CultureInfo.InvariantCulture, "The message arrived too late and is already expired (expires {0}, current {1})", expires.Value, currentTime); try { // Execute the event hook (_consumerSettings.OnMessageExpired ?? _messageBus.Settings.OnMessageExpired)?.Invoke(_consumerSettings, message); } catch (Exception eh) { // When the hook itself error out, catch the exception _log.ErrorFormat(CultureInfo.InvariantCulture, "{0} method failed", eh, nameof(IConsumerEvents.OnMessageExpired)); } // Do not process the expired message return; } } object response = null; string responseError = null; var consumerInstance = await _instancesQueue.ReceiveAsync(_messageBus.CancellationToken).ConfigureAwait(false); try { if (_consumerWithContext && _consumerContextInitializer != null) { var consumerContext = new ConsumerContext(); _consumerContextInitializer(msg, consumerContext); var consumerWithContext = (IConsumerContextAware)consumerInstance; consumerWithContext.Context.Value = consumerContext; } // the consumer just subscribes to the message var task = _consumerSettings.ConsumerMethod(consumerInstance, message, _consumerSettings.Topic); await task.ConfigureAwait(false); if (_consumerSettings.ConsumerMode == ConsumerMode.RequestResponse) { // the consumer handles the request (and replies) response = _consumerSettings.ConsumerMethodResult(task); } } catch (Exception e) { if (_consumerSettings.ConsumerMode == ConsumerMode.RequestResponse) { _log.ErrorFormat(CultureInfo.InvariantCulture, "Handler execution failed", e); // Save the exception responseError = e.ToString(); } else { _log.ErrorFormat(CultureInfo.InvariantCulture, "Consumer execution failed", e); } try { // Execute the event hook (_consumerSettings.OnMessageFault ?? _messageBus.Settings.OnMessageFault)?.Invoke(_consumerSettings, message, e); } catch (Exception eh) { // When the hook itself error out, catch the exception _log.ErrorFormat(CultureInfo.InvariantCulture, "{0} method failed", eh, nameof(IConsumerEvents.OnMessageFault)); } } finally { await _instancesQueue.SendAsync(consumerInstance).ConfigureAwait(false); } if (response != null || responseError != null) { // send the response (or error response) _log.DebugFormat(CultureInfo.InvariantCulture, "Serializing the response {0} of type {1} for RequestId: {2}...", response, _consumerSettings.ResponseType, requestId); var responseMessage = new MessageWithHeaders(); responseMessage.SetHeader(ReqRespMessageHeaders.RequestId, requestId); responseMessage.SetHeader(ReqRespMessageHeaders.Error, responseError); await _messageBus.ProduceResponse(message, requestMessage, response, responseMessage, _consumerSettings).ConfigureAwait(false); } }