public static void CallSerializer() { HeaderSerializer.Serialize(new Dictionary <string, string>() { { "key1", "value1" }, { "key2", "value2" } }); }
async Task ProcessFile(ILearningTransportTransaction transaction, string messageId, CancellationToken messageProcessingCancellationToken) { var message = await AsyncFile.ReadText(transaction.FileToProcess, messageProcessingCancellationToken) .ConfigureAwait(false); var bodyPath = Path.Combine(bodyDir, $"{messageId}{BodyFileSuffix}"); var headers = HeaderSerializer.Deserialize(message); if (headers.TryGetValue(LearningTransportHeaders.TimeToBeReceived, out var ttbrString)) { headers.Remove(LearningTransportHeaders.TimeToBeReceived); var ttbr = TimeSpan.Parse(ttbrString); //file.move preserves create time var sentTime = File.GetCreationTimeUtc(transaction.FileToProcess); var utcNow = DateTime.UtcNow; if (sentTime + ttbr < utcNow) { await transaction.Commit(messageProcessingCancellationToken) .ConfigureAwait(false); log.InfoFormat("Dropping message '{0}' as the specified TimeToBeReceived of '{1}' expired since sending the message at '{2:O}'. Current UTC time is '{3:O}'", messageId, ttbrString, sentTime, utcNow); return; } } var body = await AsyncFile.ReadBytes(bodyPath, messageProcessingCancellationToken) .ConfigureAwait(false); var transportTransaction = new TransportTransaction(); if (transactionMode == TransportTransactionMode.SendsAtomicWithReceive) { transportTransaction.Set(transaction); } var processingContext = new ContextBag(); var messageContext = new MessageContext(messageId, headers, body, transportTransaction, processingContext); try { await onMessage(messageContext, messageProcessingCancellationToken) .ConfigureAwait(false); } catch (OperationCanceledException ex) when(messageProcessingCancellationToken.IsCancellationRequested) { log.Info("Message processing cancelled. Rolling back transaction.", ex); transaction.Rollback(); return; } catch (Exception exception) { transaction.ClearPendingOutgoingOperations(); var processingFailures = retryCounts.AddOrUpdate(messageId, id => 1, (id, currentCount) => currentCount + 1); headers = HeaderSerializer.Deserialize(message); headers.Remove(LearningTransportHeaders.TimeToBeReceived); var errorContext = new ErrorContext(exception, headers, messageId, body, transportTransaction, processingFailures, processingContext); ErrorHandleResult result; try { result = await onError(errorContext, messageProcessingCancellationToken).ConfigureAwait(false); } catch (OperationCanceledException ex) when(messageProcessingCancellationToken.IsCancellationRequested) { log.Info("Message processing cancelled. Rolling back transaction.", ex); transaction.Rollback(); return; } catch (Exception ex) { criticalErrorAction($"Failed to execute recoverability policy for message with native ID: `{messageContext.NativeMessageId}`", ex, messageProcessingCancellationToken); result = ErrorHandleResult.RetryRequired; } if (result == ErrorHandleResult.RetryRequired) { transaction.Rollback(); return; } } await transaction.Commit(messageProcessingCancellationToken).ConfigureAwait(false); }
async Task WriteMessage(string destination, IOutgoingTransportOperation transportOperation, TransportTransaction transaction) { var message = transportOperation.Message; var headerPayload = HeaderSerializer.Serialize(message.Headers); var headerSize = Encoding.UTF8.GetByteCount(headerPayload); if (headerSize + message.Body.Length > maxMessageSizeKB * 1024) { throw new Exception($"The total size of the '{message.Headers[Headers.EnclosedMessageTypes]}' message body ({message.Body.Length} bytes) plus headers ({headerSize} bytes) is larger than {maxMessageSizeKB} KB and will not be supported on some production transports. Consider using the NServiceBus DataBus or the claim check pattern to avoid messages with a large payload. Use 'EndpointConfiguration.UseTransport<LearningTransport>().NoPayloadSizeRestriction()' to disable this check and proceed with the current message size."); } var nativeMessageId = Guid.NewGuid().ToString(); var destinationPath = Path.Combine(basePath, destination); var bodyDir = Path.Combine(destinationPath, LearningTransportMessagePump.BodyDirName); Directory.CreateDirectory(bodyDir); var bodyPath = Path.Combine(bodyDir, nativeMessageId) + LearningTransportMessagePump.BodyFileSuffix; await AsyncFile.WriteBytes(bodyPath, message.Body) .ConfigureAwait(false); DateTime?timeToDeliver = null; if (transportOperation.DeliveryConstraints.TryGet(out DoNotDeliverBefore doNotDeliverBefore)) { timeToDeliver = doNotDeliverBefore.At; } else if (transportOperation.DeliveryConstraints.TryGet(out DelayDeliveryWith delayDeliveryWith)) { timeToDeliver = DateTime.UtcNow + delayDeliveryWith.Delay; } if (timeToDeliver.HasValue) { if (transportOperation.DeliveryConstraints.TryGet(out DiscardIfNotReceivedBefore timeToBeReceived) && timeToBeReceived.MaxTime < TimeSpan.MaxValue) { throw new Exception($"Postponed delivery of messages with TimeToBeReceived set is not supported. Remove the TimeToBeReceived attribute to postpone messages of type '{message.Headers[Headers.EnclosedMessageTypes]}'."); } // we need to "ceil" the seconds to guarantee that we delay with at least the requested value // since the folder name has only second resolution. if (timeToDeliver.Value.Millisecond > 0) { timeToDeliver += TimeSpan.FromSeconds(1); } destinationPath = Path.Combine(destinationPath, LearningTransportMessagePump.DelayedDirName, timeToDeliver.Value.ToString("yyyyMMddHHmmss")); Directory.CreateDirectory(destinationPath); } var messagePath = Path.Combine(destinationPath, nativeMessageId) + ".metadata.txt"; if (transportOperation.RequiredDispatchConsistency != DispatchConsistency.Isolated && transaction.TryGet(out ILearningTransportTransaction directoryBasedTransaction)) { await directoryBasedTransaction.Enlist(messagePath, headerPayload) .ConfigureAwait(false); } else { // atomic avoids the file being locked when the receiver tries to process it await AsyncFile.WriteTextAtomic(messagePath, headerPayload) .ConfigureAwait(false); } }
async Task ProcessFile(ILearningTransportTransaction transaction, string messageId) { var message = await AsyncFile.ReadText(transaction.FileToProcess) .ConfigureAwait(false); var bodyPath = Path.Combine(bodyDir, $"{messageId}{BodyFileSuffix}"); var headers = HeaderSerializer.Deserialize(message); if (headers.TryGetValue(LearningTransportHeaders.TimeToBeReceived, out var ttbrString)) { headers.Remove(LearningTransportHeaders.TimeToBeReceived); var ttbr = TimeSpan.Parse(ttbrString); //file.move preserves create time var sentTime = File.GetCreationTimeUtc(transaction.FileToProcess); var utcNow = DateTime.UtcNow; if (sentTime + ttbr < utcNow) { await transaction.Commit() .ConfigureAwait(false); log.InfoFormat("Dropping message '{0}' as the specified TimeToBeReceived of '{1}' expired since sending the message at '{2:O}'. Current UTC time is '{3:O}'", messageId, ttbrString, sentTime, utcNow); return; } } var tokenSource = new CancellationTokenSource(); var body = await AsyncFile.ReadBytes(bodyPath, cancellationToken) .ConfigureAwait(false); var transportTransaction = new TransportTransaction(); if (transactionMode == TransportTransactionMode.SendsAtomicWithReceive) { transportTransaction.Set(transaction); } var messageContext = new MessageContext(messageId, headers, body, transportTransaction, tokenSource, new ContextBag()); try { await onMessage(messageContext) .ConfigureAwait(false); } catch (Exception exception) { transaction.ClearPendingOutgoingOperations(); var processingFailures = retryCounts.AddOrUpdate(messageId, id => 1, (id, currentCount) => currentCount + 1); var errorContext = new ErrorContext(exception, headers, messageId, body, transportTransaction, processingFailures); // the transport tests assume that all transports use a circuit breaker to be resilient against exceptions // in onError. Since we don't need that robustness, we just retry onError once should it fail. ErrorHandleResult actionToTake; try { actionToTake = await onError(errorContext) .ConfigureAwait(false); } catch (Exception) { actionToTake = await onError(errorContext) .ConfigureAwait(false); } if (actionToTake == ErrorHandleResult.RetryRequired) { transaction.Rollback(); return; } } if (tokenSource.IsCancellationRequested) { transaction.Rollback(); return; } await transaction.Commit() .ConfigureAwait(false); }