/// <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>();
object temp;
if (transactionContext.Items.TryGetValue(HandlerInvoker.CurrentHandlerInvokerItemsKey, out temp))
{
var handlerInvoker = (HandlerInvoker)temp;
if (handlerInvoker.HasSaga)
{
var idempotentSagaData = handlerInvoker.GetSagaData() as IIdempotentSagaData;
if (idempotentSagaData != null)
{
var idempotencyData = idempotentSagaData.IdempotencyData;
var transportMessage = context.Load<TransportMessage>();
var destinationAddresses = context.Load<DestinationAddresses>();
var incomingStepContext = transactionContext.Items.GetOrThrow<IncomingStepContext>(StepContext.StepContextKey);
var messageId = incomingStepContext.Load<Message>().GetMessageId();
idempotencyData.AddOutgoingMessage(messageId, destinationAddresses, 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 CanCaptureIdentityInTheMessage()
{
var step = new CapturePrincipalInOutgoingMessage(new DummySerializer());
var instance = new Message(new Dictionary<string, string>(), new object());
var context = new OutgoingStepContext(instance, new DefaultTransactionContext(),
new DestinationAddresses(new[] { "Larry" }));
context.Save(instance);
await step.Process(context, async () => { });
Assert.That(instance.Headers.ContainsKey(CapturePrincipalInOutgoingMessage.PrincipalCaptureKey));
Assert.AreEqual(instance.Headers[CapturePrincipalInOutgoingMessage.PrincipalCaptureKey], "Larry");
}
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var message = context.Load<Message>();
var headers = message.Headers;
var currentClaimsPrincipal = ClaimsPrincipal.Current;
if (currentClaimsPrincipal != null && !headers.ContainsKey(PrincipalCaptureKey))
{
headers[PrincipalCaptureKey] = _serializer.Serialize(currentClaimsPrincipal);
}
await next();
}
/// <summary>
/// Invokes the pipeline of <see cref="IOutgoingStep"/> steps, passing the given <see cref="OutgoingStepContext"/> to each step as it is invoked
/// </summary>
public async Task Invoke(OutgoingStepContext context, IEnumerable<IOutgoingStep> pipeline)
{
var receivePipeline = pipeline.ToArray();
var step = TerminationStep;
for (var index = receivePipeline.Length - 1; index >= 0; index--)
{
var nextStep = step;
var stepToInvoke = receivePipeline[index];
step = () => stepToInvoke.Process(context, nextStep);
}
await step();
}
/// <summary>
/// Invokes the pipeline of <see cref="IOutgoingStep"/> steps, passing the given <see cref="OutgoingStepContext"/> to each step as it is invoked
/// </summary>
public Task Invoke(OutgoingStepContext context, IEnumerable <IOutgoingStep> pipeline)
{
var receivePipeline = GetPipeline(pipeline);
var step = TerminationStep;
for (var index = receivePipeline.Length - 1; index >= 0; index--)
{
var nextStep = step;
var stepToInvoke = receivePipeline[index];
step = () => stepToInvoke.Process(context, nextStep);
}
return(step());
}
/// <summary>
/// Invokes the pipeline of <see cref="IOutgoingStep"/> steps, passing the given <see cref="OutgoingStepContext"/> to each step as it is invoked
/// </summary>
public async Task Invoke(OutgoingStepContext context, IEnumerable <IOutgoingStep> pipeline)
{
var receivePipeline = pipeline.ToArray();
var step = TerminationStep;
for (var index = receivePipeline.Length - 1; index >= 0; index--)
{
var nextStep = step;
var stepToInvoke = receivePipeline[index];
step = () => stepToInvoke.Process(context, nextStep);
}
await step();
}
/// <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>();
var headers = transportMessage.Headers.Clone();
var bodyBytes = transportMessage.Body;
var encryptedData = _encryptor.Encrypt(bodyBytes);
headers[EncryptionHeaders.ContentEncryption] = "rijndael";
headers[EncryptionHeaders.ContentInitializationVector] = Convert.ToBase64String(encryptedData.Iv);
context.Save(new TransportMessage(headers, encryptedData.Bytes));
await next();
}
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);
MapSpecialHeaders(newHeaders);
context.Save(new TransportMessage(newHeaders, body));
await next();
}
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var transportMessage = context.Load<TransportMessage>();
if (IsPublishedMessage(transportMessage))
{
var transactionContext = context.Load<ITransactionContext>();
var clone = transportMessage.Clone();
clone.Headers[Headers.AuditTime] = RebusTime.Now.ToString("O");
await _transport.Send(_auditQueue, clone, transactionContext);
}
await next();
}
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var transportMessage = context.Load<TransportMessage>();
if (IsPublishedMessage(transportMessage))
{
var transactionContext = context.Load<ITransactionContext>();
var clone = transportMessage.Clone();
_auditingHelper.SetCommonHeaders(clone);
await _transport.Send(_auditingHelper.AuditQueue, clone, transactionContext);
}
await next();
}
void PossiblyCompressTransportMessage(OutgoingStepContext context)
{
var transportMessage = context.Load<TransportMessage>();
if (transportMessage.Body == null) return;
if (transportMessage.Body.Length < _bodySizeThresholdBytes) return;
var headers = transportMessage.Headers.Clone();
var compressedBody = _zipper.Zip(transportMessage.Body);
headers[Headers.ContentEncoding] = GzipEncodingHeader;
var compressedTransportMessage = new TransportMessage(headers, compressedBody);
context.Save(compressedTransportMessage);
}
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
var message = context.Load<Message>();
var body = message.Body;
if (body != null)
{
var interfaces = body.GetType().GetInterfaces();
if (interfaces.Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IFailed<>)))
{
throw new InvalidOperationException($"Tried to send {body} - it is not allowed to send an IFailed<TMessage> anywhere because a) it most likely is an error, because you accidentally called Send/Defer with 'failed' and not with 'failed.Message' as the argument, and b) it could confuse things a lot - we like to avoid confusing things");
}
}
await next();
}
async Task SendUsingTransactionContext(IEnumerable<string> destinationAddresses, Message logicalMessage, ITransactionContext transactionContext)
{
var context = new OutgoingStepContext(logicalMessage, transactionContext, new DestinationAddresses(destinationAddresses));
await _pipelineInvoker.Invoke(context, _pipeline.SendPipeline());
}
/// <summary>
/// Compresses theo outgoing transport message body
/// </summary>
public async Task Process(OutgoingStepContext context, Func<Task> next)
{
PossiblyCompressTransportMessage(context);
await next();
}
