static ActiveSagaInstance AssociateSagaWithMessage(FakeSaga saga, IInvokeHandlerContext behaviorContext)
{
var sagaInstance = new ActiveSagaInstance(saga, SagaMetadata.Create(typeof(FakeSaga), new List <Type>(), new Conventions()), () => DateTime.UtcNow);
behaviorContext.Extensions.Set(sagaInstance);
return(sagaInstance);
}
public static Task HandleCurrentMessageLater(IInvokeHandlerContext context)
{
if (context.HandleCurrentMessageLaterWasCalled)
{
return(TaskEx.CompletedTask);
}
var messageBeingProcessed = context.Extensions.Get <IncomingMessage>();
var settings = context.Builder.Build <ReadOnlySettings>();
if (settings.IsFeatureActive(typeof(Features.Outbox)))
{
// as HandleCurrentMessageLater reuses the incoming message's message id, this will cause the message to be deduplicated by the outbox causing a message loss.
throw new InvalidOperationException("HandleCurrentMessageLater cannot be used in conjunction with the Outbox. Use the recoverability mechanisms or delayed delivery instead.");
}
var cache = context.Extensions.Get <IPipelineCache>();
var pipeline = cache.Pipeline <IRoutingContext>();
var outgoingMessage = new OutgoingMessage(
messageBeingProcessed.MessageId,
messageBeingProcessed.Headers,
messageBeingProcessed.Body);
var routingContext = new RoutingContext(outgoingMessage, new UnicastRoutingStrategy(settings.LocalAddress()), context);
return(pipeline.Invoke(routingContext));
}
public static bool IsTimeoutMessage(this IInvokeHandlerContext message)
{
if (message.Headers.TryGetValue(Headers.IsSagaTimeoutMessage, out var isTimeoutString))
{
return(string.Equals(isTimeoutString, "true", StringComparison.OrdinalIgnoreCase));
}
return(false);
}
public static string OriginatingMachine(this IInvokeHandlerContext context)
{
if (context.Headers.TryGetValue(Headers.OriginatingMachine, out var intent))
{
return(intent);
}
return(string.Empty);
}
public static string OriginatingEndpoint(this IInvokeHandlerContext context)
{
if (context.Headers.TryGetValue(Headers.OriginatingEndpoint, out var endpoint))
{
return(endpoint);
}
return(string.Empty);
}
public static string MessageIntent(this IInvokeHandlerContext logicalMessage)
{
var headers = logicalMessage.Headers;
if (headers.TryGetValue(Headers.MessageIntent, out var intent))
{
return(intent);
}
return("Send");
}
public static bool IsTimeoutMessage(this IInvokeHandlerContext message)
{
string isTimeoutString;
if (message.Headers.TryGetValue(Headers.IsSagaTimeoutMessage, out isTimeoutString))
{
return(isTimeoutString == "true");
}
return(false);
}
private static string GetCheckMessageOrderType(IInvokeHandlerContext context)
{
context.MessageHeaders.TryGetValue("CheckMessageOrderType", out string checkMessageOrderType);
if (!string.IsNullOrEmpty(checkMessageOrderType))
{
return(checkMessageOrderType);
}
var messageType = context.MessageMetadata.MessageType;
var checkMessageOrder = ChecksMessageOrderBy(messageType, typeof(ICheckMessageOrder <>));
return(checkMessageOrder == null ? messageType.FullName : checkMessageOrder.GetGenericArguments()[0].FullName);
}
public override async Task Invoke(IInvokeHandlerContext context, Func <Task> next)
{
var session = context.SynchronizedStorageSession;
var sqlPersistenceSession = session.SqlPersistenceSession();
var dbContext = (TDataContext)Activator.CreateInstance(typeof(TDataContext), sqlPersistenceSession.Connection);
await using (dbContext)
{
dbContext.Database.UseTransaction(sqlPersistenceSession.Transaction);
context.Extensions.Set(dbContext);
await next();
await dbContext.SaveChangesAsync();
}
}
public override async Task Invoke(IInvokeHandlerContext context, Func <Task> next)
{
var session = context.SynchronizedStorageSession;
var sqlPersistenceSession = session.SqlPersistenceSession();
var dbContext = (InboxDbContext)Activator.CreateInstance(typeof(InboxDbContext), sqlPersistenceSession.Connection);
using (dbContext)
{
dbContext.Database.UseTransaction(sqlPersistenceSession.Transaction);
context.MessageHeaders.TryGetValue("ContentId", out string contentId);
long contentVersion = GetContentVersionFrom(context.MessageHeaders);
var checkMessageOrderType = GetCheckMessageOrderType(context);
var latestHandledVersion = await dbContext.GetLatestMessageVersion(contentId, checkMessageOrderType).ConfigureAwait(false);
var shouldBeHandled = latestHandledVersion == null || contentVersion > latestHandledVersion;
var inboxMessage = new InboxRecord
{
ContentId = contentId,
ContentVersion = contentVersion,
CheckMessageOrderType = checkMessageOrderType,
MessageId = Guid.Parse(context.MessageId),
ModifiedAtUtc = DateTime.UtcNow
};
if (shouldBeHandled)
{
log.Info($"Handling message: Type: {checkMessageOrderType}, ContentId: {contentId}, ContentVersion: {contentVersion}");
await dbContext.PersistHandledMessage(inboxMessage).ConfigureAwait(false);
await next().ConfigureAwait(false);
}
else
{
string discardedReason = $"Discarding message since a newer version has already been processed: Type: {checkMessageOrderType}, ContentId: {contentId}, ContentVersion: {contentVersion}";
log.Info(discardedReason);
await dbContext.PersistDiscardedMessage(inboxMessage, latestHandledVersion.GetValueOrDefault()).ConfigureAwait(false);
context.Headers.Add("InboxDiscardedReason", discardedReason);
}
}
}
public override async Task Invoke(IInvokeHandlerContext context, Func <Task> next)
{
var session = context.SynchronizedStorageSession;
var sqlPersistenceSession = session.SqlPersistenceSession();
var dbContext = (TDbContext)Activator.CreateInstance(typeof(TDbContext), sqlPersistenceSession.Connection);
using (dbContext)
{
dbContext.Database.UseTransaction(sqlPersistenceSession.Transaction);
context.Extensions.Set(dbContext);
await next()
.ConfigureAwait(false);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
//Here I also want to find all effected dbcontext modified entities and in them there aggregateroots
//and then publish the uncommitedevents that they have. I have removed this from this sample cause I do not
//think it is important to why it is not able to save without throwing exceptions and loosing data.
}
}
public static Task HandleCurrentMessageLater(IInvokeHandlerContext context)
{
if (context.HandleCurrentMessageLaterWasCalled)
{
return TaskEx.CompletedTask;
}
var messageBeingProcessed = context.Extensions.Get<IncomingMessage>();
var settings = context.Builder.Build<ReadOnlySettings>();
var cache = context.Extensions.Get<IPipelineCache>();
var pipeline = cache.Pipeline<IRoutingContext>();
var outgoingMessage = new OutgoingMessage(
messageBeingProcessed.MessageId,
messageBeingProcessed.Headers,
messageBeingProcessed.Body);
var routingContext = new RoutingContext(outgoingMessage, new UnicastRoutingStrategy(settings.LocalAddress()), context);
return pipeline.Invoke(routingContext);
}
public static Task HandleCurrentMessageLater(IInvokeHandlerContext context)
{
if (context.HandleCurrentMessageLaterWasCalled)
{
return(TaskEx.CompletedTask);
}
var messageBeingProcessed = context.Extensions.Get <IncomingMessage>();
var settings = context.Builder.Build <ReadOnlySettings>();
var cache = context.Extensions.Get <IPipelineCache>();
var pipeline = cache.Pipeline <IRoutingContext>();
var outgoingMessage = new OutgoingMessage(
messageBeingProcessed.MessageId,
messageBeingProcessed.Headers,
messageBeingProcessed.Body);
var routingContext = new RoutingContext(outgoingMessage, new UnicastRoutingStrategy(settings.LocalAddress()), context);
return(pipeline.Invoke(routingContext));
}
public Task Validate(IInvokeHandlerContext handlerContext)
{
return(Validate(handlerContext.MessageBeingHandled.GetType(), handlerContext.Builder, handlerContext.MessageBeingHandled, handlerContext.Headers, handlerContext.Extensions));
}
public static DateTime TimeSent(this IInvokeHandlerContext logicalMessage)
{
return(DateTimeExtensions.ToUtcDateTime(logicalMessage.Headers[Headers.TimeSent]));
}
public static DateTime TimeSent(this IInvokeHandlerContext context)
{
return(DateTimeExtensions.ToUtcDateTime(context.Headers[Headers.TimeSent]));
}
public static string MessageName(this IInvokeHandlerContext context)
{
return(context.MessageMetadata.MessageType.FullName);
}
public static string HandlerName(this IInvokeHandlerContext context)
{
return(context.MessageHandler.HandlerType.FullName);
}
public static string MessageIntent(this IInvokeHandlerContext context)
{
return(MessageIntent(context.Headers));
}
public static ActiveSagaInstance GetSagaInstance(this IInvokeHandlerContext context)
{
return(context.Extensions.TryGet(out ActiveSagaInstance saga) ? saga : null);
}
public static string MessageIntent(this IInvokeHandlerContext context) => MessageIntent(context.Headers);
public static string HandlerType(this IInvokeHandlerContext context) => context.MessageHandler.HandlerType.FullName !;
public static Type MessageType(this IInvokeHandlerContext context) => context.MessageMetadata.MessageType;
public static Type MessageType(this IInvokeHandlerContext context)
{
return(context.MessageMetadata.MessageType);
}
