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}"); } }