/// <summary>
/// Carries out the auto-header logic
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
var headers = message.Headers;
var body = message.Body;
var messageType = body.GetType();
var headersToAssign = _headersToAssign.GetOrAdd(messageType, type => messageType
.GetTypeInfo()
.GetCustomAttributes(typeof(HeaderAttribute), true)
.OfType <HeaderAttribute>()
.ToArray());
for (var index = 0; index < headersToAssign.Length; index++)
{
var autoHeader = headersToAssign[index];
if (headers.ContainsKey(autoHeader.Key))
{
continue;
}
headers[autoHeader.Key] = autoHeader.Value;
}
await next().ConfigureAwait(false);
}
/// <summary>
/// Carries out whichever logic it takes to do something good for the outgoing message :)
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var transactionContext = context.Load <ITransactionContext>();
var items = transactionContext.Items;
if (items.TryGetValue(HandlerInvoker.CurrentHandlerInvokerItemsKey, out var item))
{
if (item is HandlerInvoker handlerInvoker)
{
if (handlerInvoker.HasSaga)
{
if (handlerInvoker.GetSagaData() is IIdempotentSagaData idempotentSagaData)
{
var idempotencyData = idempotentSagaData.IdempotencyData;
var transportMessage = context.Load <TransportMessage>();
var destinationAddresses = context.Load <DestinationAddresses>();
var incomingStepContext = items.GetOrThrow <IncomingStepContext>(StepContext.StepContextKey);
var messageId = incomingStepContext.Load <Message>().GetMessageId();
idempotencyData.AddOutgoingMessage(messageId, destinationAddresses, transportMessage);
}
}
}
}
await next();
}
private static void SendAfterSendEvent(OutgoingStepContext context)
{
if (DiagnosticListener.IsEnabled(AfterSendMessage.EventName))
{
DiagnosticListener.Write(AfterSendMessage.EventName, new AfterSendMessage(context));
}
}
/// <summary>
/// Executes the step and sets the default headers
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
var headers = message.Headers;
if (!headers.ContainsKey(Headers.MessageId))
{
headers[Headers.MessageId] = Guid.NewGuid().ToString();
}
if (_hasOwnAddress && !headers.ContainsKey(Headers.ReturnAddress))
{
headers[Headers.ReturnAddress] = _returnAddress;
}
headers[Headers.SentTime] = _rebusTime.Now.ToString("O");
if (_hasOwnAddress)
{
headers[Headers.SenderAddress] = _senderAddress;
}
else
{
headers.Remove(Headers.SenderAddress);
}
if (!headers.ContainsKey(Headers.Type))
{
var messageType = message.Body.GetType();
headers[Headers.Type] = _messageTypeNameConvention.GetTypeName(messageType);
}
await next();
}
public async Task StartsNoActivityIfThereIsNoCurrentActivity()
{
var step = new OutgoingDiagnosticsStep();
var headers = GetMessageHeaders("id", Headers.IntentOptions.PublishSubscribe);
var message = new Message(headers, new object());
var transportMessage = new TransportMessage(headers, Array.Empty <byte>());
var destinations = new DestinationAddresses(new List <string> {
"MyQueue"
});
var context = new OutgoingStepContext(message, AmbientTransactionContext.Current, destinations);
context.Save(transportMessage);
var hadActivity = false;
var callbackWasInvoked = false;
await step.Process(context, () =>
{
hadActivity = Activity.Current != null;
callbackWasInvoked = true;
return(Task.CompletedTask);
});
Assert.That(hadActivity, Is.False);
Assert.That(headers, Has.No.ContainKey(RebusDiagnosticConstants.TraceStateHeaderName));
Assert.That(callbackWasInvoked, Is.True);
}
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
foreach (var e in _beforeMessageSent)
{
e(_bus, message.Headers, message.Body, context);
}
try
{
await next();
foreach (var e in _afterMessageSent)
{
e(_bus, message.Headers, message.Body, context);
}
}
catch (Exception exception)
{
context.Save(exception);
foreach (var e in _afterMessageSent)
{
e(_bus, message.Headers, message.Body, context);
}
throw;
}
}
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var transportMessage = context.Load <TransportMessage>();
var body = transportMessage.Body;
var headers = transportMessage.Headers;
var newHeaders = MapTrivialHeaders(headers);
var allHeaders = newHeaders.Union(headers).ToDictionary(x => x.Key, x => x.Value);
MapSpecialHeaders(allHeaders);
AddCustomHeaders(allHeaders);
AddMulticastHeader(allHeaders);
if (_propagateAutoCorrelationSagaId)
{
PropagateAutoCorrelationSagaIdToHeaders(allHeaders);
}
context.Save(new TransportMessage(allHeaders, body));
await next();
}
/// <summary>
/// Encrypts the outgoing <see cref="TransportMessage"/> and adds appropriate headers
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var transportMessage = context.Load <TransportMessage>();
if (transportMessage.Headers.ContainsKey(EncryptionHeaders.DisableEncryptionHeader))
{
await next();
return;
}
var headers = transportMessage.Headers.Clone();
var bodyBytes = transportMessage.Body;
var encryptedData = await _encryptor.Encrypt(bodyBytes);
headers[EncryptionHeaders.ContentEncryption] = _encryptor.ContentEncryptionValue;
headers[EncryptionHeaders.ContentInitializationVector] = Convert.ToBase64String(encryptedData.Iv);
if (!string.IsNullOrEmpty(encryptedData.KeyId))
{
headers[EncryptionHeaders.KeyId] = encryptedData.KeyId;
}
context.Save(new TransportMessage(headers, encryptedData.Bytes));
await next();
}
/// <summary>
/// Carries out the auto-header logic
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
var headers = message.Headers;
var body = message.Body;
var messageType = body.GetType();
var headersToAssign = _headersToAssign.GetOrAdd(messageType, type => messageType
.GetCustomAttributes(typeof(HeaderAttribute), true)
.OfType <HeaderAttribute>()
.ToList());
foreach (var autoHeader in headersToAssign)
{
if (headers.ContainsKey(autoHeader.Key))
{
continue;
}
headers[autoHeader.Key] = autoHeader.Value;
}
await next();
}
public Task Process(OutgoingStepContext context, Func <Task> next)
{
Message message = context.Load <Message>();
if (message.Headers.ContainsKey(Headers.CorrelationId))
{
return(next());
}
string correlationId = _correlationContextAccessor.CorrelationContext?.CorrelationId ?? _correlationIdFactory.Create();
message.Headers[Headers.CorrelationId] = correlationId;
int correlationSequence = 0;
ITransactionContext transactionContext = context.Load <ITransactionContext>();
IncomingStepContext incomingStepContext = transactionContext.GetOrNull <IncomingStepContext>(StepContext.StepContextKey);
if (incomingStepContext != null)
{
correlationSequence = GetCorrelationSequence(incomingStepContext) + 1;
}
message.Headers[Headers.CorrelationSequence] = correlationSequence.ToString(CultureInfo.InvariantCulture);
_logger.Debug("Correlation ID: {CorrelationId}, sequence: {CorrelationSequence}", correlationId, correlationSequence);
return(next());
}
/// <summary>
/// Carries out whichever logic it takes to do something good for the outgoing message :)
/// </summary>
/// <param name="context"></param>
/// <param name="next"></param>
/// <returns></returns>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
next = next ?? throw new ArgumentNullException(nameof(next));
context = context ?? throw new ArgumentNullException(nameof(context));
var message = context.Load <Messages.Message>();
var body = message.Body;
var processor = _snsAttributeMapperFactory.Create(body.GetType());
if (processor != null)
{
var attributes = processor.GetAttributes(body, message.Headers);
if (attributes.Count > 10)
{
throw new InvalidOperationException($"You can only map up to 10 attributes with an sns message. The number of attributes mapped is {attributes.Count} and the keys are {string.Join(", ", attributes.Keys)}");
}
context.Load <ITransactionContext>().Items.AddOrUpdate(SnsAttributeKey, s => attributes, (s, o) => attributes);
}
await next();
}
/// <summary>
/// Executes the step and sets the default headers
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
var headers = message.Headers;
var messageType = message.Body.GetType();
if (!headers.ContainsKey(Headers.MessageId))
{
headers[Headers.MessageId] = Guid.NewGuid().ToString();
}
if (_hasOwnAddress && !headers.ContainsKey(Headers.ReturnAddress))
{
headers[Headers.ReturnAddress] = _address;
}
headers[Headers.SentTime] = RebusTime.Now.ToString("O");
if (!headers.ContainsKey(Headers.Type))
{
headers[Headers.Type] = messageType.GetSimpleAssemblyQualifiedName();
}
await next().ConfigureAwait(false);
}
private static void SendBeforeSendEvent(OutgoingStepContext context)
{
if (DiagnosticListener.IsEnabled(BeforeSendMessage.EventName, context))
{
DiagnosticListener.Write(BeforeSendMessage.EventName, new BeforeSendMessage(context));
}
}
private static void InjectHeaders(Activity activity, OutgoingStepContext context)
{
var message = context.Load <Message>();
var headers = message.Headers;
if (activity.IdFormat == ActivityIdFormat.W3C)
{
if (!headers.ContainsKey(TracingConstants.TraceParentHeaderName))
{
headers[TracingConstants.TraceParentHeaderName] = activity.Id;
if (activity.TraceStateString != null)
{
headers[TracingConstants.TraceStateHeaderName] = activity.TraceStateString;
}
}
}
else
{
if (!headers.ContainsKey(TracingConstants.RequestIdHeaderName))
{
headers[TracingConstants.RequestIdHeaderName] = activity.Id;
}
}
}
public Task Process(OutgoingStepContext context, Func <Task> next)
{
var transportMessage = context.Load <TransportMessage>();
transportMessage = StandardAdapter.ConvertOutgoingTransportMessage(transportMessage, StandardHeaderOptions);
context.Save(transportMessage);
return(next());
}
private static Activity StartActivity(OutgoingStepContext context)
{
var activity = new Activity(TracingConstants.ProducerActivityName);
activity.Start();
return(activity);
}
static OutgoingStepContext GetOutgoingStepContext()
{
var message = new Message(new Dictionary <string, string>(), new byte[] { 1, 2, 3 });
var transactionContext = new TransactionContext();
var context = new OutgoingStepContext(message, transactionContext, new DestinationAddresses(new string[0]));
context.Save(new List <string>());
return(context);
}
/// <summary>
/// Sets the <see cref="Headers.SentTime"/> header
/// </summary>
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var message = context.Load<Message>();
var headers = message.Headers;
headers[Headers.SentTime] = RebusTime.Now.ToString("O");
await next();
}
private static void StopActivity(Activity activity, OutgoingStepContext context)
{
if (activity.Duration == TimeSpan.Zero)
{
activity.SetEndTime(DateTime.UtcNow);
}
activity.Stop();
}
/// <summary>
/// Executes the step
/// </summary>
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var message = context.Load<TransportMessage>();
var headers = message.Headers;
CheckDeferHeaders(headers);
await next();
}
/// <summary>
/// Sets the <see cref="Headers.SentTime"/> header
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
var headers = message.Headers;
headers[Headers.SentTime] = RebusTime.Now.ToString("O");
await next();
}
/// <summary>
/// Serializes the outgoing message by invoking the currently configured <see cref="ISerializer"/> on the <see cref="Message"/> found in the context,
/// storing the result as the <see cref="TransportMessage"/> returned by the serializer
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var logicalMessage = context.Load <Message>();
var transportMessage = await _serializer.Serialize(logicalMessage);
context.Save(transportMessage);
await next();
}
/// <summary>
/// Executes the step
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <TransportMessage>();
var headers = message.Headers;
CheckDeferHeaders(headers);
await next();
}
/// <summary>
/// Serializes the outgoing message by invoking the currently configured <see cref="ISerializer"/> on the <see cref="Message"/> found in the context,
/// storing the result as the <see cref="TransportMessage"/> returned by the serializer
/// </summary>
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var logicalMessage = context.Load<Message>();
var transportMessage = await _serializer.Serialize(logicalMessage);
context.Save(transportMessage);
await next();
}
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var events = context.Load <List <string> >();
events.Add($"{_name} before");
await next();
events.Add($"{_name} after");
}
/// <summary>
/// Dehydrates the message, if it's too big
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var transportMessage = context.Load <TransportMessage>();
if (transportMessage.Body.Length > _messageSizeLimitBytes)
{
await DehydrateTransportMessage(context, transportMessage);
}
await next();
}
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
var headers = message.Headers;
var messageBodyToSend = PossiblyConvertBody(headers, message.Body);
var body = new[] { messageBodyToSend };
context.Save(new Message(headers, body));
await next();
}
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
var state = stateBuilder();
message.Headers.WriteKeyAndIv(state.keyId, state.algorithm.IV);
using (factory.GetEncryptSession(state.algorithm))
{
await next();
}
}
public Task Process(OutgoingStepContext context, Func <Task> next)
{
var transactionContext = context.Load <ITransactionContext>(SafeRebusContextTags.TransactionContextTag);
var scope = transactionContext.GetOrAdd(SafeRebusContextTags.ScopeContextTag, () => ServiceProvider.CreateScope());
var adapter = scope.ServiceProvider.GetService <ISafeStandardAdapter>();
var transportMessage = context.Load <TransportMessage>();
transportMessage = adapter.AppendAdapterSpecificHeaders(transportMessage);
context.Save(transportMessage);
return(next());
}
public Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
if (message.Body is IMessage m)
{
message.Headers[Headers.MessageId] = m.MessageId;
}
return(next());
}
/// <summary>
/// If no return address has been added to the message, the sender's input queue address is automatically added as the <see cref="Headers.ReturnAddress"/>
/// header
/// </summary>
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var message = context.Load<Message>();
var headers = message.Headers;
if (_hasOwnAddress && !headers.ContainsKey(Headers.ReturnAddress))
{
headers[Headers.ReturnAddress] = _address;
}
await next();
}
/// <summary>
/// Sets the <see cref="Headers.MessageId"/>. The message ID is a new <see cref="Guid"/>
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
var headers = message.Headers;
if (!headers.ContainsKey(Headers.MessageId))
{
headers[Headers.MessageId] = Guid.NewGuid().ToString();
}
await next();
}
/// <summary>
/// If no return address has been added to the message, the sender's input queue address is automatically added as the <see cref="Headers.ReturnAddress"/>
/// header
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
var headers = message.Headers;
if (_hasOwnAddress && !headers.ContainsKey(Headers.ReturnAddress))
{
headers[Headers.ReturnAddress] = _address;
}
await next();
}
/// <summary>
/// Sets the <see cref="Headers.MessageId"/>. The message ID is a new <see cref="Guid"/>
/// </summary>
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var message = context.Load<Message>();
var headers = message.Headers;
if (!headers.ContainsKey(Headers.MessageId))
{
headers[Headers.MessageId] = Guid.NewGuid().ToString();
}
await next();
}
/// <summary>
/// Sets the <see cref="Headers.Type"/> to the simple assembly-qualified type name of the sent object, unless
/// the header has not already been added
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
var headers = message.Headers;
var messageType = message.Body.GetType();
if (!headers.ContainsKey(Headers.Type))
{
headers[Headers.Type] = messageType.GetSimpleAssemblyQualifiedName();
}
await next().ConfigureAwait(false);
}
/// <summary>
/// Sets the <see cref="Headers.Type"/> to the simple assembly-qualified type name of the sent object, unless
/// the header has not already been added
/// </summary>
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var message = context.Load<Message>();
var headers = message.Headers;
var messageType = message.Body.GetType();
if (!headers.ContainsKey(Headers.Type))
{
headers[Headers.Type] = messageType.GetSimpleAssemblyQualifiedName();
}
await next();
}
/// <summary>
/// Flows the correlation ID like it should
/// </summary>
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var outgoingMessage = context.Load<Message>();
var transactionContext = context.Load<ITransactionContext>();
var incomingStepContext = transactionContext.GetOrNull<IncomingStepContext>(StepContext.StepContextKey);
if (!outgoingMessage.Headers.ContainsKey(Headers.CorrelationId))
{
var correlationId = GetCorrelationIdToAssign(incomingStepContext, outgoingMessage);
outgoingMessage.Headers[Headers.CorrelationId] = correlationId;
}
await next();
}
/// <summary>
/// Sends the outgoing message using the configured <see cref="ITransport"/>, sending to the <see cref="DestinationAddresses"/>
/// found in the <see cref="OutgoingStepContext"/>.
/// </summary>
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var logicalMessage = context.Load<Message>();
var transportMessage = context.Load<TransportMessage>();
var currentTransactionContext = context.Load<ITransactionContext>();
var destinationAddressesList = context.Load<DestinationAddresses>().ToList();
var hasOneOrMoreDestinations = destinationAddressesList.Any();
_log.Debug("Sending {0} -> {1}",
logicalMessage.Body ?? "<empty message>",
hasOneOrMoreDestinations ? string.Join(";", destinationAddressesList) : "<no destinations>");
await Send(destinationAddressesList, transportMessage, currentTransactionContext);
await next();
}
/// <summary>
/// Carries out the auto-header logic
/// </summary>
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var message = context.Load<Message>();
var headers = message.Headers;
var body = message.Body;
var messageType = body.GetType();
var headersToAssign = _headersToAssign.GetOrAdd(messageType, type => messageType
.GetCustomAttributes(typeof (HeaderAttribute), true)
.OfType<HeaderAttribute>()
.ToList());
foreach (var autoHeader in headersToAssign)
{
if (headers.ContainsKey(autoHeader.Key)) continue;
headers[autoHeader.Key] = autoHeader.Value;
}
await next();
}
