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