/// <summary> /// Invokes the routing function and performs some action depending on the returned <see cref="ForwardAction"/> result /// </summary> public async Task Process(IncomingStepContext context, Func<Task> next) { var transportMessage = context.Load<TransportMessage>(); var routingResult = (await _routingFunction(transportMessage)) ?? ForwardAction.None; var actionType = routingResult.ActionType; switch (actionType) { case ActionType.Forward: var destinationAddresses = routingResult.DestinationAddresses; var transactionContext = context.Load<ITransactionContext>(); _log.Debug("Forwarding {0} to {1}", transportMessage.GetMessageLabel(), string.Join(", ", destinationAddresses)); await Task.WhenAll( destinationAddresses .Select(address => _transport.Send(address, transportMessage, transactionContext)) ); break; case ActionType.None: await next(); break; default: await next(); break; } }
public async Task Process(IncomingStepContext context, Func<Task> next) { await next(); var message = context.Load<Message>(); var handlerInvokers = context.Load<HandlerInvokers>(); var createdAndUpdatedSagaData = handlerInvokers .Where(i => i.HasSaga) .Select(i => new { Handler = i.Handler, SagaData = i.GetSagaData() }) .ToList(); var saveTasks = createdAndUpdatedSagaData .Select(sagaData => { var metadata = GetMetadata(sagaData.SagaData, sagaData.Handler, message); return _sagaSnapshotStorage.Save(sagaData.SagaData, metadata); }); await Task.WhenAll(saveTasks); }
public async Task Process(IncomingStepContext context, Func<Task> next) { var handlerInvokersForSagas = context.Load<HandlerInvokers>() .Where(l => l.HasSaga) .ToList(); var message = context.Load<Message>(); var messageId = message.GetMessageId(); var transactionContext = context.Load<ITransactionContext>(); foreach (var handlerInvoker in handlerInvokersForSagas) { var sagaData = handlerInvoker.GetSagaData() as IIdempotentSagaData; if (sagaData == null) continue; var idempotencyData = sagaData.IdempotencyData ?? (sagaData.IdempotencyData = new IdempotencyData()); if (idempotencyData.HasAlreadyHandled(messageId)) { _log.Info("Message with ID {0} has already been handled by saga with ID {1}", messageId, sagaData.Id); var outgoingMessages = idempotencyData .GetOutgoingMessages(messageId) .ToList(); if (outgoingMessages.Any()) { _log.Info("Found {0} outgoing messages to be (re-)sent... will do that now", outgoingMessages.Count); foreach (var messageToResend in outgoingMessages) { foreach (var destinationAddress in messageToResend.DestinationAddresses) { await _transport.Send(destinationAddress, messageToResend.TransportMessage, transactionContext); } } } else { _log.Info("Found no outgoing messages to be (re-)sent..."); } handlerInvoker.SkipInvocation(); } else { idempotencyData.MarkMessageAsHandled(messageId); } } await next(); }
/// <summary> /// Executes the entire message processing pipeline in an exception handler, tracking the number of failed delivery attempts. /// Forwards the message to the error queue when the max number of delivery attempts has been exceeded. /// </summary> public async Task Process(IncomingStepContext context, Func<Task> next) { var transportMessage = context.Load<TransportMessage>(); var transactionContext = context.Load<ITransactionContext>(); var messageId = transportMessage.Headers.GetValueOrNull(Headers.MessageId); if (string.IsNullOrWhiteSpace(messageId)) { await MoveMessageToErrorQueue("<no message ID>", transportMessage, transactionContext, string.Format("Received message with empty or absent '{0}' header! All messages must be" + " supplied with an ID . If no ID is present, the message cannot be tracked" + " between delivery attempts, and other stuff would also be much harder to" + " do - therefore, it is a requirement that messages be supplied with an ID.", Headers.MessageId), shortErrorDescription: string.Format("Received message with empty or absent '{0}' header", Headers.MessageId)); return; } if (_errorTracker.HasFailedTooManyTimes(messageId)) { // if we don't have 2nd level retries, just get the message out of the way if (!_simpleRetryStrategySettings.SecondLevelRetriesEnabled) { await MoveMessageToErrorQueue(messageId, transportMessage, transactionContext, GetErrorDescriptionFor(messageId), GetErrorDescriptionFor(messageId, brief: true)); _errorTracker.CleanUp(messageId); return; } // change the identifier to track by to perform this 2nd level of delivery attempts var secondLevelMessageId = messageId + "-2nd-level"; if (_errorTracker.HasFailedTooManyTimes(secondLevelMessageId)) { await MoveMessageToErrorQueue(messageId, transportMessage, transactionContext, GetErrorDescriptionFor(messageId), GetErrorDescriptionFor(messageId, brief: true)); _errorTracker.CleanUp(messageId); _errorTracker.CleanUp(secondLevelMessageId); return; } context.Save(DispatchAsFailedMessageKey, true); await DispatchWithTrackerIdentifier(next, secondLevelMessageId, transactionContext); return; } await DispatchWithTrackerIdentifier(next, messageId, transactionContext); }
public async Task Process(IncomingStepContext context, Func<Task> next) { var transactionContext = context.Load<ITransactionContext>(); var transportMessage = context.Load<TransportMessage>(); var clone = transportMessage.Clone(); clone.Headers[Headers.AuditTime] = RebusTime.Now.ToString("O"); await _transport.Send(_auditQueue, clone, transactionContext); await next(); }
/// <summary> /// For each <see cref="HandlerInvoker"/> found in the current <see cref="IncomingStepContext"/>'s <see cref="HandlerInvokers"/>, /// this step will see if the invoker's handler is actually a <see cref="Saga"/>. If that is the case, the saga's correlation properties /// are used to see if a piece of existing saga data can be retrieved and mounted on the <see cref="Saga{TSagaData}.Data"/> property. /// If no existing instance was found, but the saga implements <see cref="IAmInitiatedBy{TMessage}"/> for the current message, /// a new saga data instance will be created (and mounted). Otherwise, the message is ignored. /// </summary> public async Task Process(IncomingStepContext context, Func<Task> next) { // first we get the relevant handler invokers var handlerInvokersForSagas = context.Load<HandlerInvokers>() .Where(l => l.HasSaga) .ToList(); // maybe short-circuit? this makes it slightly faster if (!handlerInvokersForSagas.Any()) { await next(); return; } var message = context.Load<Message>(); var label = message.GetMessageLabel(); var body = message.Body; // keep track of saga data instances in these two lists var loadedSagaData = new List<RelevantSagaInfo>(); var newlyCreatedSagaData = new List<RelevantSagaInfo>(); // and then we process them foreach (var sagaInvoker in handlerInvokersForSagas) { await TryMountSagaDataOnInvoker(sagaInvoker, body, label, loadedSagaData, newlyCreatedSagaData); } // invoke the rest of the pipeline (most likely also dispatching the incoming message to the now-ready saga handlers) await next(); // everything went well - let's divide saga data instances into those to insert, update, and delete var newlyCreatedSagaDataToSave = newlyCreatedSagaData.Where(s => !s.Saga.WasMarkedAsComplete && !s.Saga.WasMarkedAsUnchanged); var loadedSagaDataToUpdate = loadedSagaData.Where(s => !s.Saga.WasMarkedAsComplete && !s.Saga.WasMarkedAsUnchanged); var loadedSagaDataToDelete = loadedSagaData.Where(s => s.Saga.WasMarkedAsComplete); foreach (var sagaDataToInsert in newlyCreatedSagaDataToSave) { await SaveSagaData(sagaDataToInsert, insert: true); } foreach (var sagaDataToUpdate in loadedSagaDataToUpdate) { await SaveSagaData(sagaDataToUpdate, insert: false); } foreach (var sagaDataToUpdate in loadedSagaDataToDelete) { await _sagaStorage.Delete(sagaDataToUpdate.SagaData); } }
public async Task Process(IncomingStepContext context, Func<Task> next) { var message = context.Load<Message>(); var headers = message.Headers; if (headers.ContainsKey(MapLegacyHeadersIncomingStep.LegacyMessageHeader)) { var body = message.Body; var array = body as object[]; if (array == null) { throw new FormatException( $"Incoming message has the '{MapLegacyHeadersIncomingStep.LegacyMessageHeader}' header, but the message body {body} is not an object[] as expected"); } foreach (var bodyToDispatch in array) { var messageBodyToDispatch = PossiblyConvertBody(bodyToDispatch, headers); context.Save(new Message(headers, messageBodyToDispatch)); await next(); } return; } await next(); }
public async Task Process(IncomingStepContext context, Func<Task> next) { var message = context.Load<Message>(); string correlationId; var hasCorrelationId = message.Headers.TryGetValue(Headers.CorrelationId, out correlationId); if (hasCorrelationId) { var isRequestReplyCorrelationId = correlationId.StartsWith(SpecialCorrelationIdPrefix); if (isRequestReplyCorrelationId) { string dummy; var isRequest = message.Headers.TryGetValue(SpecialRequestTag, out dummy); if (!isRequest) { // it's the reply! _messages[correlationId] = message; return; } } } await next(); }
void PossiblyDecompressTransportMessage(IncomingStepContext context) { var transportMessage = context.Load<TransportMessage>(); string contentEncoding; if (!transportMessage.Headers.TryGetValue(Headers.ContentEncoding, out contentEncoding)) return; if (contentEncoding != ZipMessagesOutgoingStep.GzipEncodingHeader) { var message = $"The message {transportMessage.GetMessageLabel()} has a '{Headers.ContentEncoding}' with the" + $" value '{contentEncoding}', but this middleware only knows how to decompress" + $" '{ZipMessagesOutgoingStep.GzipEncodingHeader}'"; throw new ArgumentException(message); } var headers = transportMessage.Headers.Clone(); var compressedBody = transportMessage.Body; headers.Remove(Headers.ContentEncoding); var body = _zipper.Unzip(compressedBody); context.Save(new TransportMessage(headers, body)); }
public async Task Process(IncomingStepContext context, Func<Task> next) { var begin = RebusTime.Now; await next(); var transactionContext = context.Load<ITransactionContext>(); var transportMessage = context.Load<TransportMessage>(); var clone = transportMessage.Clone(); _auditingHelper.SetCommonHeaders(clone); clone.Headers[AuditHeaders.HandleTime] = begin.ToString("O"); await _transport.Send(_auditingHelper.AuditQueue, clone, transactionContext); }
public async Task Process(IncomingStepContext context, Func<Task> next) { var statsContext = context.Load<StatsContext>(); using (statsContext.Measure(_nextStep)) { await next(); } }
/// <summary> /// Executes the entire message processing pipeline in an exception handler, tracking the number of failed delivery attempts. /// Forwards the message to the error queue when the max number of delivery attempts has been exceeded. /// </summary> public async Task Process(IncomingStepContext context, Func<Task> next) { var transportMessage = context.Load<TransportMessage>(); var transactionContext = context.Load<ITransactionContext>(); var messageId = transportMessage.Headers.GetValueOrNull(Headers.MessageId); if (string.IsNullOrWhiteSpace(messageId)) { await MoveMessageToErrorQueue("<no message ID>", transportMessage, transactionContext, string.Format("Received message with empty or absent '{0}' header! All messages must be" + " supplied with an ID . If no ID is present, the message cannot be tracked" + " between delivery attempts, and other stuff would also be much harder to" + " do - therefore, it is a requirement that messages be supplied with an ID.", Headers.MessageId), shortErrorDescription: "Received message with empty or absent 'rbs2-msg-id' header"); return; } if (HasFailedTooManyTimes(messageId)) { await MoveMessageToErrorQueue(messageId, transportMessage, transactionContext, GetErrorDescriptionFor(messageId), GetErrorDescriptionFor(messageId, brief: true)); RemoveErrorTracking(messageId); return; } try { await next(); } catch (Exception exception) { var errorTracking = _trackedErrors.AddOrUpdate(messageId, id => new ErrorTracking(exception), (id, tracking) => tracking.AddError(exception)); _log.Warn("Unhandled exception {0} while handling message with ID {1}: {2}", errorTracking.Errors.Count(), messageId, exception); transactionContext.Abort(); } }
/// <summary> /// Reorders the handler invokers if necessary /// </summary> public async Task Process(IncomingStepContext context, Func<Task> next) { var handlerInvokers = context.Load<HandlerInvokers>(); var orderedHandlerInvokers = handlerInvokers.OrderBy(i => _configuration.GetIndex(i.Handler)); var newHandlerInvokers = new HandlerInvokers(handlerInvokers.Message, orderedHandlerInvokers); context.Save(newHandlerInvokers); await next(); }
/// <summary> /// Carries out whichever logic it takes to do something good for the incoming message :) /// </summary> public async Task Process(IncomingStepContext context, Func<Task> next) { var message = context.Load<Message>(); var newPrincipal = GetClaimsPrincipalOrNull(message); using (new CurrentPrincipalRewriter(newPrincipal)) { await next(); } }
public async Task Process(IncomingStepContext context, Func<Task> next) { var resetEvents = DequeueResetEvents(); context.Load<ITransactionContext>() .OnDisposed(() => { resetEvents.ForEach(resetEvent => resetEvent.Set()); }); await next(); }
public async Task Process(IncomingStepContext context, Func<Task> next) { var transportMessage = context.Load<TransportMessage>(); var headers = transportMessage.Headers; if (headers.ContainsKey("rebus-msg-id")) { MutateLegacyTransportMessage(context, headers, transportMessage); } await next(); }
/// <summary> /// Executes the entire message processing pipeline in an exception handler, tracking the number of failed delivery attempts. /// Forwards the message to the error queue when the max number of delivery attempts has been exceeded. /// </summary> public async Task Process(IncomingStepContext context, Func<Task> next) { var transportMessage = context.Load<TransportMessage>(); var transactionContext = context.Load<ITransactionContext>(); var messageId = transportMessage.Headers.GetValueOrNull(Headers.MessageId); if (string.IsNullOrWhiteSpace(messageId)) { await MoveMessageToErrorQueue("<no message ID>", transportMessage, transactionContext, string.Format("Received message with empty or absent '{0}' header! All messages must be" + " supplied with an ID . If no ID is present, the message cannot be tracked" + " between delivery attempts, and other stuff would also be much harder to" + " do - therefore, it is a requirement that messages be supplied with an ID.", Headers.MessageId), shortErrorDescription: "Received message with empty or absent 'rbs2-msg-id' header"); return; } if (_errorTracker.HasFailedTooManyTimes(messageId)) { await MoveMessageToErrorQueue(messageId, transportMessage, transactionContext, GetErrorDescriptionFor(messageId), GetErrorDescriptionFor(messageId, brief: true)); _errorTracker.CleanUp(messageId); return; } try { await next(); } catch (Exception exception) { _errorTracker.RegisterError(messageId, exception); transactionContext.Abort(); } }
public async Task InvokesInOrder() { var invoker = new DefaultPipelineInvoker(); var stepContext = new IncomingStepContext(new TransportMessage(new Dictionary<string, string>(), new byte[0]), null); await invoker.Invoke(stepContext, new IIncomingStep[] { new NamedStep("first"), new NamedStep("second"), new NamedStep("third"), }); Console.WriteLine(string.Join(Environment.NewLine, stepContext.Load<List<string>>())); }
/// <summary> /// Descrypts the incoming <see cref="TransportMessage"/> if it has the <see cref="EncryptionHeaders.ContentEncryption"/> header /// </summary> public async Task Process(IncomingStepContext context, Func<Task> next) { var transportMessage = context.Load<TransportMessage>(); if (transportMessage.Headers.ContainsKey(EncryptionHeaders.ContentEncryption)) { var headers = transportMessage.Headers.Clone(); var encryptedBodyBytes = transportMessage.Body; var iv = GetIv(headers); var bodyBytes = _encryptor.Decrypt(encryptedBodyBytes, iv); context.Save(new TransportMessage(headers, bodyBytes)); } await next(); }
/// <summary> /// Descrypts the incoming <see cref="TransportMessage"/> if it has the <see cref="EncryptionHeaders.ContentEncryption"/> header /// </summary> public async Task Process(IncomingStepContext context, Func<Task> next) { var transportMessage = context.Load<TransportMessage>(); string contentEncryptionValue; if (transportMessage.Headers.TryGetValue(EncryptionHeaders.ContentEncryption, out contentEncryptionValue) && contentEncryptionValue == _encryptor.ContentEncryptionValue) { var headers = transportMessage.Headers.Clone(); var encryptedBodyBytes = transportMessage.Body; var iv = GetIv(headers); var bodyBytes = _encryptor.Decrypt(new EncryptedData(encryptedBodyBytes, iv)); context.Save(new TransportMessage(headers, bodyBytes)); } await next(); }
/// <summary> /// For each <see cref="HandlerInvoker"/> found in the current <see cref="IncomingStepContext"/>'s <see cref="HandlerInvokers"/>, /// this step will see if the invoker's handler is actually a <see cref="Saga"/>. If that is the case, the saga's correlation properties /// are used to see if a piece of existing saga data can be retrieved and mounted on the <see cref="Saga{TSagaData}.Data"/> property. /// If no existing instance was found, but the saga implements <see cref="IAmInitiatedBy{TMessage}"/> for the current message, /// a new saga data instance will be created (and mounted). Otherwise, the message is ignored. /// </summary> public async Task Process(IncomingStepContext context, Func<Task> next) { var handlerInvokersForSagas = context.Load<HandlerInvokers>() .Where(l => l.HasSaga) .ToList(); var message = context.Load<Message>(); var label = message.GetMessageLabel(); var body = message.Body; var loadedSagaData = new List<RelevantSagaInfo>(); var newlyCreatedSagaData = new List<RelevantSagaInfo>(); foreach (var sagaInvoker in handlerInvokersForSagas) { var foundExistingSagaData = false; var correlationProperties = _sagaHelper.GetCorrelationProperties(body, sagaInvoker.Saga); var correlationPropertiesRelevantForMessage = correlationProperties.ForMessage(body); foreach (var correlationProperty in correlationPropertiesRelevantForMessage) { var valueFromMessage = correlationProperty.ValueFromMessage(body); var sagaData = await _sagaStorage.Find(sagaInvoker.Saga.GetSagaDataType(), correlationProperty.PropertyName, valueFromMessage); if (sagaData == null) continue; sagaInvoker.SetSagaData(sagaData); foundExistingSagaData = true; loadedSagaData.Add(new RelevantSagaInfo(sagaData, correlationProperties, sagaInvoker.Saga)); _log.Debug("Found existing saga data with ID {0} for message {1}", sagaData.Id, label); break; } if (!foundExistingSagaData) { var messageType = body.GetType(); var canBeInitiatedByThisMessageType = sagaInvoker.CanBeInitiatedBy(messageType); if (canBeInitiatedByThisMessageType) { var newSagaData = _sagaHelper.CreateNewSagaData(sagaInvoker.Saga); sagaInvoker.SetSagaData(newSagaData); _log.Debug("Created new saga data with ID {0} for message {1}", newSagaData.Id, label); newlyCreatedSagaData.Add(new RelevantSagaInfo(newSagaData, correlationProperties, sagaInvoker.Saga)); } else { _log.Debug("Could not find existing saga data for message {0}", label); sagaInvoker.SkipInvocation(); } } } await next(); var newlyCreatedSagaDataToSave = newlyCreatedSagaData.Where(s => !s.Saga.WasMarkedAsComplete && !s.Saga.WasMarkedAsUnchanged); var loadedSagaDataToUpdate = loadedSagaData.Where(s => !s.Saga.WasMarkedAsComplete && !s.Saga.WasMarkedAsUnchanged); var loadedSagaDataToDelete = loadedSagaData.Where(s => s.Saga.WasMarkedAsComplete); foreach (var sagaDataToInsert in newlyCreatedSagaDataToSave) { await _sagaStorage.Insert(sagaDataToInsert.SagaData, sagaDataToInsert.CorrelationProperties); } foreach (var sagaDataToUpdate in loadedSagaDataToUpdate) { await _sagaStorage.Update(sagaDataToUpdate.SagaData, sagaDataToUpdate.CorrelationProperties); } foreach (var sagaDataToUpdate in loadedSagaDataToDelete) { await _sagaStorage.Delete(sagaDataToUpdate.SagaData); } }