/// <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>
/// 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>
/// 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 message = context.Load <Message>();
var state = stateBuilder();
message.Headers.WriteKeyAndIv(state.keyId, state.algorithm.IV);
using (factory.GetEncryptSession(state.algorithm))
{
await next();
}
}
/// <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();
}
/// <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>
/// 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.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();
}
public async Task Process(OutgoingStepContext outgoingStepContext, Func <Task> next)
{
HttpContext httpContext = m_httpContextAccessor.HttpContext;
if (httpContext != null)
{
var messsage = outgoingStepContext.Load <Message>();
messsage.Headers[Headers.CorrelationId] = httpContext.TraceIdentifier;
}
await next();
}
public Task Process(OutgoingStepContext context, Func <Task> next)
{
var correlationId = HttpContext.Current?.Items[CorrelationIdRequestFilter.CorrelationIdHttpContextItemsKey]?.ToString();
if (correlationId != null)
{
var message = context.Load <Message>();
message.Headers[Headers.CorrelationId] = correlationId;
}
return(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);
}
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>
/// 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 transactionContext = context.Load <ITransactionContext>();
object temp;
if (transactionContext.Items.TryGetValue(Keys.MessageData, out temp))
{
var msgData = (MessageData)temp;
if (msgData != null)
{
var transportMessage = context.Load <TransportMessage>();
var destinationAddresses = context.Load <DestinationAddresses>();
var incomingStepContext = transactionContext.Items.GetOrThrow <IncomingStepContext>(StepContext.StepContextKey);
var messageId = incomingStepContext.Load <Message>().GetMessageId();
_log.Info($"Adding outgoing message with ID {transportMessage.Headers[Headers.MessageId]} for message with ID {msgData.MessageId} onto the message data.");
msgData.AddOutgoingMessage(messageId, destinationAddresses, transportMessage);
}
}
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 message = context.Load <Message>();
var body = message.Body;
if (body != null)
{
var interfaces = body.GetType().GetInterfaces();
if (interfaces.Any(i => i.GetTypeInfo().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();
}
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var addresses = context.Load <DestinationAddresses>();
foreach (var a in addresses)
{
if (_stats.ContainsKey(a))
{
_stats[a]++;
}
else
{
_stats[a] = 1;
}
}
await next();
// Message sent! Log details of it to some kind of monitoring system; performance counters, whatever.
}
private static void InjectHeaders(Activity?activity, OutgoingStepContext context)
{
if (activity == null)
{
return;
}
var headers = context.Load <TransportMessage>().Headers;
if (!headers.ContainsKey(RebusDiagnosticConstants.TraceStateHeaderName))
{
headers[RebusDiagnosticConstants.TraceStateHeaderName] = activity.Id;
}
if (!headers.ContainsKey(RebusDiagnosticConstants.BaggageHeaderName))
{
headers[RebusDiagnosticConstants.BaggageHeaderName] = JsonConvert.SerializeObject(activity.Baggage);
}
}
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var userContext = _container.GetInstance <IContextProvider <ClaimsPrincipal> >();
if (userContext.Current?.Identity.IsAuthenticated == true)
{
var authType = userContext.Current?.Identity.AuthenticationType;
var userId = userContext.Current?.GetUserId();
var userEmail = userContext.Current?.GetUserEmail();
var scopes = userContext.Current?.FindFirst("scope")?.Value;
var roles = userContext.Current?.FindAll(ClaimTypes.Role).Select(x => x.Value) ?? Enumerable.Empty <string>();
var message = context.Load <Message>();
if (authType != null)
{
message.Headers["ark-auth-type"] = authType;
}
if (userId != null)
{
message.Headers["ark-user-id"] = userId;
}
if (userEmail != null)
{
message.Headers["ark-user-email"] = userEmail;
}
if (scopes != null)
{
message.Headers["ark-user-scopes"] = scopes;
}
if (roles.Any())
{
message.Headers["ark-user-roles"] = string.Join(",", roles);
}
}
await next();
}
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
using (var scope = _serviceProvider.CreateScope())
{
var userAccessor = scope.ServiceProvider.GetRequiredService <IUserAccessor>();
if (userAccessor.User != null)
{
var message = context.Load <Message>();
var claims = userAccessor.User.Claims;
foreach (var c in claims)
{
message.Headers[Prefix + c.Type] = c.Value;
}
message.Headers[AuthenticationTypeKey] = userAccessor.User.Identity.AuthenticationType;
}
}
await next();
}
/// <inheritdoc />
async Task IOutgoingStep.Process(OutgoingStepContext context, Func <Task> next)
{
Message message = context.Load <Message>();
object body = message.Body;
Type messageType = body.GetType();
IValidator validator = _validatorFactory.GetValidator(messageType);
if (validator != null && validator.CanValidateInstancesOfType(messageType))
{
ValidationResult validationResult = await validator.ValidateAsync(body).ConfigureAwait(false);
if (!validationResult.IsValid)
{
_logger.Debug(string.Format(CultureInfo.CurrentCulture, Resources.ValidationFailed, "{MessageType}", "{ValidationResult}"), messageType.GetSimpleAssemblyQualifiedName(), validationResult);
throw new ValidationException(validationResult.Errors);
}
}
await next().ConfigureAwait(false);
}
/// <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().ConfigureAwait(false);
return;
}
var headers = transportMessage.Headers.Clone();
var bodyBytes = transportMessage.Body;
var encryptedData = _encryptor.Encrypt(bodyBytes);
headers[EncryptionHeaders.ContentEncryption] = _encryptor.ContentEncryptionValue;
headers[EncryptionHeaders.ContentInitializationVector] = Convert.ToBase64String(encryptedData.Iv);
context.Save(new TransportMessage(headers, encryptedData.Bytes));
await next().ConfigureAwait(false);
}
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var message = context.Load <Message>();
if (message.Headers.TryGetValue(Headers.DeferredUntil, out _))
{
if (!message.Headers.TryGetValue(Headers.DeferredRecipient, out var temp) ||
temp == null)
{
try
{
message.Headers[Headers.DeferredRecipient] = await _router.GetDestinationAddress(message);
}
catch (Exception exception)
{
throw new RebusApplicationException(exception, "Could not automatically set recipient for deferred message");
}
}
}
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;
if (!headers.ContainsKey(Headers.MessageId))
{
headers[Headers.MessageId] = Guid.NewGuid().ToString();
}
if (_hasOwnAddress && !headers.ContainsKey(Headers.ReturnAddress))
{
headers[Headers.ReturnAddress] = _returnAddress;
}
if (!headers.ContainsKey(Headers.SentTime))
{
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();
}
/// <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();
}
private static void InjectHeaders(Activity activity, OutgoingStepContext context)
{
var headers = context.Load <Message>().Headers;
if (activity.IdFormat == ActivityIdFormat.W3C)
{
if (!headers.ContainsKey(Constants.TraceParentHeaderName))
{
headers[Constants.TraceParentHeaderName] = activity.Id;
if (activity.TraceStateString != null)
{
headers[Constants.TraceStateHeaderName] = activity.TraceStateString;
}
}
}
else
{
if (!headers.ContainsKey(Constants.RequestIdHeaderName))
{
headers[Constants.RequestIdHeaderName] = activity.Id;
}
}
}
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);
}
