protected virtual async Task <TResponseMessage> SendInternal <TResponseMessage>(IRequestMessage <TResponseMessage> request, TimeSpan?timeout, string name, CancellationToken cancellationToken) { AssertActive(); AssertRequestResponseConfigured(); // check if the cancellation was already requested cancellationToken.ThrowIfCancellationRequested(); var requestType = request.GetType(); var producerSettings = GetProducerSettings(requestType); if (name == null) { name = GetDefaultName(requestType, producerSettings); } if (timeout == null) { timeout = GetDefaultRequestTimeout(requestType, producerSettings); } var created = CurrentTime; var expires = created.Add(timeout.Value); // generate the request guid var requestId = GenerateRequestId(); var requestMessage = new MessageWithHeaders(); requestMessage.SetHeader(ReqRespMessageHeaders.RequestId, requestId); requestMessage.SetHeader(ReqRespMessageHeaders.Expires, expires); // record the request state var requestState = new PendingRequestState(requestId, request, requestType, typeof(TResponseMessage), created, expires, cancellationToken); PendingRequestStore.Add(requestState); if (Log.IsTraceEnabled) { Log.TraceFormat(CultureInfo.InvariantCulture, "Added to PendingRequests, total is {0}", PendingRequestStore.GetCount()); } try { Log.DebugFormat(CultureInfo.InvariantCulture, "Sending request message {0} to name {1} with reply to {2}", requestState, name, Settings.RequestResponse.Topic); await ProduceRequest(request, requestMessage, name, producerSettings).ConfigureAwait(false); } catch (PublishMessageBusException e) { Log.DebugFormat(CultureInfo.InvariantCulture, "Publishing of request message failed", e); // remove from registry PendingRequestStore.Remove(requestId); throw; } // convert Task<object> to Task<TResponseMessage> var responseUntyped = await requestState.TaskCompletionSource.Task.ConfigureAwait(true); return((TResponseMessage)responseUntyped); }
private async Task ProduceResponse(MessageWithHeaders requestMessage, string requestId, object message, object response, string responseError) { // 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); }
public virtual byte[] SerializeResponse(Type responseType, object response, string requestId, string error) { var responsePayload = error == null?Settings.Serializer.Serialize(responseType, response) : null; // create the response wrapper message var responseMessage = new MessageWithHeaders(responsePayload); responseMessage.SetHeader(ReqRespMessageHeaders.RequestId, requestId); if (error != null) { responseMessage.SetHeader(ReqRespMessageHeaders.Error, error); } var responseMessagePayload = Settings.MessageWithHeadersSerializer.Serialize(typeof(MessageWithHeaders), responseMessage); return(responseMessagePayload); }
public virtual byte[] SerializeRequest(Type requestType, object request, string requestId, string replyTo, DateTimeOffset?expires) { var requestPayload = Settings.Serializer.Serialize(requestType, request); // create the request wrapper message var requestMessage = new MessageWithHeaders(requestPayload); requestMessage.SetHeader(ReqRespMessageHeaders.RequestId, requestId); requestMessage.SetHeader(ReqRespMessageHeaders.ReplyTo, replyTo); if (expires.HasValue) { requestMessage.SetHeader(ReqRespMessageHeaders.Expires, expires.Value); } var requestMessagePayload = Settings.MessageWithHeadersSerializer.Serialize(typeof(MessageWithHeaders), requestMessage); return(requestMessagePayload); }
public virtual Task ProduceRequest(object request, MessageWithHeaders requestMessage, string name, ProducerSettings producerSettings) { var requestType = request.GetType(); requestMessage.SetHeader(ReqRespMessageHeaders.ReplyTo, Settings.RequestResponse.Topic); var requestMessagePayload = SerializeRequest(requestType, request, requestMessage, producerSettings); return(ProduceToTransport(requestType, request, name, requestMessagePayload)); }
public virtual Task ProduceRequest(object request, MessageWithHeaders requestMessage, string name, ProducerSettings producerSettings) { if (request == null) { throw new ArgumentNullException(nameof(request)); } if (requestMessage == null) { throw new ArgumentNullException(nameof(requestMessage)); } var requestType = request.GetType(); requestMessage.SetHeader(ReqRespMessageHeaders.ReplyTo, Settings.RequestResponse.Topic); var requestMessagePayload = SerializeRequest(requestType, request, requestMessage, producerSettings); return(ProduceToTransport(requestType, request, name, requestMessagePayload, requestMessage)); }
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 = _consumerRuntimeInfo.OnHandle(consumerInstance, message); await task.ConfigureAwait(false); if (_consumerSettings.ConsumerMode == ConsumerMode.RequestResponse) { // the consumer handles the request (and replies) response = _consumerRuntimeInfo.GetResponseValue(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); } }