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 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();
}
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;
}
}
/// <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();
}
public async Task Given_incoming_step_context_has_sequence_it_should_increment(int?incomingSequenceNr, int expectedOutgoingSequenceNr)
{
var incomingHeaders = new Dictionary <string, string>();
if (incomingSequenceNr.HasValue)
{
incomingHeaders.Add(Headers.CorrelationSequence, incomingSequenceNr.ToString());
}
var incomingStepContext = new IncomingStepContext(
new TransportMessage(
incomingHeaders, new byte[0]),
_transactionContextMock.Object
);
incomingStepContext.Save(new Message(incomingHeaders, new { }));
_stepContext.Save(incomingStepContext);
// Act
await _sut.Process(_stepContext, _next);
// Assert
_messageHeaders
.Should().ContainKey(Headers.CorrelationSequence)
.WhichValue
.Should().Be(expectedOutgoingSequenceNr.ToString());
}
public Task Process(OutgoingStepContext context, Func <Task> next)
{
var transportMessage = context.Load <TransportMessage>();
transportMessage = StandardAdapter.ConvertOutgoingTransportMessage(transportMessage, StandardHeaderOptions);
context.Save(transportMessage);
return(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();
}
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>
/// 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 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 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 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 FakeTransactionContext(),
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");
}
/// <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 StartsNewActivityIfThereIsAlreadyAParentActivity()
{
Assume.That(RebusDiagnosticConstants.ActivitySource.HasListeners(), Is.True);
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);
using var activity = new Activity("MyActivity");
activity.SetIdFormat(ActivityIdFormat.W3C);
activity.Start();
Assume.That(activity, Is.SameAs(Activity.Current));
var hadActivity = false;
var hadExpectedParent = false;
await step.Process(context, () =>
{
hadActivity = Activity.Current != null;
hadExpectedParent = Activity.Current?.ParentSpanId == activity.SpanId;
return(Task.CompletedTask);
});
Assert.That(hadActivity, Is.True);
Assert.That(hadExpectedParent, Is.True);
Assert.That(transportMessage.Headers, Contains.Key(RebusDiagnosticConstants.TraceStateHeaderName));
Assert.That(transportMessage.Headers[RebusDiagnosticConstants.TraceStateHeaderName], Is.Not.Null.And.Not.Empty);
}
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);
}
async Task DehydrateTransportMessage(OutgoingStepContext context, TransportMessage transportMessage)
{
var messageId = transportMessage.GetMessageId();
try
{
using (var source = new MemoryStream(transportMessage.Body))
{
var attachment = await _dataBus.CreateAttachment(source);
var headers = transportMessage.Headers.Clone();
headers[Headers.MessagePayloadAttachmentId] = attachment.Id;
context.Save(new TransportMessage(headers, EmptyMessageBody));
}
}
catch (Exception exception)
{
throw new RebusApplicationException(exception,
$"Could not create (automatic claim check) attachment for outgoing message with ID {messageId}");
}
}
