public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag context)
{
var typedTransaction = (EventStoreOutboxTransaction)transaction;
typedTransaction.Persist(message);
return(Task.FromResult(0));
}
public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag context)
{
var session = ((MartenOutboxTransaction)transaction).Session;
var operations = new OutboxRecord.OutboxOperation[message.TransportOperations.Length];
var index = 0;
foreach (var transportOperation in message.TransportOperations)
{
operations[index] = new OutboxRecord.OutboxOperation
{
Message = transportOperation.Body,
Headers = transportOperation.Headers,
MessageId = transportOperation.MessageId,
Options = transportOperation.Options
};
index++;
}
session.Store(new OutboxRecord
{
Id = GetOutboxRecordId(message.MessageId),
MessageId = message.MessageId,
Dispatched = false,
TransportOperations = operations
});
return(Task.FromResult(0));
}
public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag context)
{
StupidTransaction tx = (StupidTransaction)transaction;
tx.Message = message;
return(Task.FromResult(0));
}
public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag context)
{
var session = ((RavenDBOutboxTransaction)transaction).AsyncSession;
var operations = new OutboxRecord.OutboxOperation[message.TransportOperations.Length];
var index = 0;
foreach (var transportOperation in message.TransportOperations)
{
operations[index] = new OutboxRecord.OutboxOperation
{
Message = transportOperation.Body,
Headers = transportOperation.Headers,
MessageId = transportOperation.MessageId,
Options = transportOperation.Options
};
index++;
}
return(session.StoreAsync(new OutboxRecord
{
MessageId = message.MessageId,
Dispatched = false,
TransportOperations = operations
}, GetOutboxRecordId(message.MessageId)));
}
public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag context)
{
var session = ((RavenDBOutboxTransaction)transaction).AsyncSession;
var operations = new OutboxRecord.OutboxOperation[message.TransportOperations.Length];
var index = 0;
foreach (var transportOperation in message.TransportOperations)
{
operations[index] = new OutboxRecord.OutboxOperation
{
Message = transportOperation.Body,
Headers = transportOperation.Headers,
MessageId = transportOperation.MessageId,
Options = transportOperation.Options
};
index++;
}
return session.StoreAsync(new OutboxRecord
{
MessageId = message.MessageId,
Dispatched = false,
TransportOperations = operations
}, GetOutboxRecordId(message.MessageId));
}
public Task Store(OutboxMessage message, OutboxTransaction outboxTransaction, ContextBag context)
{
var sqlOutboxTransaction = (SqlOutboxTransaction)outboxTransaction;
var transaction = sqlOutboxTransaction.Transaction;
var connection = sqlOutboxTransaction.Connection;
return(Store(message, transaction, connection));
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
var typedTransaction = transaction as EventStoreOutboxTransaction;
return(typedTransaction != null
? Task.FromResult <CompletableSynchronizedStorageSession>(new OutboxEventStoreSynchronizedStorageSession(typedTransaction.Connection, typedTransaction))
: EmptyResult);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
if (transaction is AcceptanceTestingOutboxTransaction inMemOutboxTransaction)
{
CompletableSynchronizedStorageSession session = new AcceptanceTestingSynchronizedStorageSession(inMemOutboxTransaction.Transaction);
return(Task.FromResult(session));
}
return(EmptyTask);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context, CancellationToken cancellationToken = default)
{
if (transaction is FakeOutboxTransaction inMemOutboxTransaction)
{
CompletableSynchronizedStorageSession session = new FakeSynchronizedStorageSession(inMemOutboxTransaction.Transaction);
return(Task.FromResult(session));
}
return(EmptyTask);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
//var outboxTransaction = transaction as SqlOutboxTransaction;
//if (outboxTransaction != null)
//{
// CompletableSynchronizedStorageSession session = new StorageSession(outboxTransaction.SqlConnection, outboxTransaction.SqlTransaction, false);
// return Task.FromResult(session);
//}
return(EmptyResult);
}
public Task<CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
var inMemOutboxTransaction = transaction as InMemoryOutboxTransaction;
if (inMemOutboxTransaction != null)
{
CompletableSynchronizedStorageSession session = new InMemorySynchronizedStorageSession(inMemOutboxTransaction.Transaction);
return Task.FromResult(session);
}
return EmptyTask;
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
if (transaction is RavenDBOutboxTransaction outboxTransaction)
{
return(Task.FromResult <CompletableSynchronizedStorageSession>(
new RavenDBSynchronizedStorageSession(outboxTransaction.AsyncSession, false)));
}
return(EmptyResult);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
if (!(transaction is SqlOutboxTransaction outboxTransaction))
{
return(EmptyResultTask);
}
CompletableSynchronizedStorageSession session = new StorageSession(outboxTransaction.Connection, outboxTransaction.Transaction, false, infoCache);
return(Task.FromResult(session));
}
public Task<CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
var outboxTransaction = transaction as SqlOutboxTransaction;
if (outboxTransaction != null)
{
CompletableSynchronizedStorageSession session = new StorageSession(outboxTransaction.Connection, outboxTransaction.Transaction, false);
return Task.FromResult(session);
}
return EmptyResult;
}
public Task<CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
var ravenTransaction = transaction as RavenDBOutboxTransaction;
if (ravenTransaction != null)
{
CompletableSynchronizedStorageSession session = new RavenDBSynchronizedStorageSession(ravenTransaction.AsyncSession, false);
return Task.FromResult(session);
}
return EmptyResult;
}
public OutboxTestsFixture()
{
Now = DateTime.UtcNow;
Connection = new Mock <DbConnection>();
UnitOfWorkContext = new Mock <IUnitOfWorkContext>();
Settings = new Mock <ReadOnlySettings>();
Transaction = new Mock <DbTransaction> {
CallBase = true
};
Command = new Mock <DbCommand>();
Parameters = new Mock <DbParameterCollection>();
OutboxTransaction = new OutboxTransaction(Transaction.Object);
EndpointName = "SFA.DAS.NServiceBus";
Events = new List <Event>
{
new FooEvent {
Created = Now.AddDays(-1)
},
new BarEvent {
Created = Now
}
};
EventsData = JsonConvert.SerializeObject(Events, new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.Auto
});
OutboxMessage = new OutboxMessage(GuidComb.NewGuidComb(), EndpointName, Events);
OutboxMessages = new List <IOutboxMessageAwaitingDispatch>();
Parameters.Setup(p => p.Add(It.IsAny <DbParameter>()));
Command.SetupSet(c => c.CommandText = It.IsAny <string>());
Command.SetupSet(c => c.Transaction = It.IsAny <DbTransaction>());
Command.Protected().Setup <DbParameter>("CreateDbParameter").Returns(() =>
{
var parameter = new Mock <DbParameter> {
CallBase = true
};
parameter.SetupProperty(p => p.ParameterName);
parameter.SetupProperty(p => p.Value);
return(parameter.Object);
});
Command.Protected().Setup <DbParameterCollection>("DbParameterCollection").Returns(Parameters.Object);
Connection.Protected().Setup <DbTransaction>("BeginDbTransaction", IsolationLevel.Unspecified).Returns(Transaction.Object);
Connection.Protected().Setup <DbCommand>("CreateDbCommand").Returns(Command.Object);
UnitOfWorkContext.Setup(c => c.Get <DbConnection>()).Returns(Connection.Object);
UnitOfWorkContext.Setup(c => c.Get <DbTransaction>()).Returns(Transaction.Object);
Settings.Setup(s => s.Get <string>("NServiceBus.Routing.EndpointName")).Returns(EndpointName);
Outbox = new Outbox(Connection.Object, UnitOfWorkContext.Object);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
var nhibernateTransaction = transaction as NHibernateOutboxTransaction;
if (nhibernateTransaction != null)
{
CompletableSynchronizedStorageSession session = new NHibernateNativeTransactionSynchronizedStorageSession(nhibernateTransaction.Session, nhibernateTransaction.Transaction);
return(Task.FromResult(session));
}
return(EmptyResult);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
var ravenTransaction = transaction as RavenDBOutboxTransaction;
if (ravenTransaction != null)
{
CompletableSynchronizedStorageSession session = new RavenDBSynchronizedStorageSession(ravenTransaction.AsyncSession, false);
return(Task.FromResult(session));
}
return(EmptyResult);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
var inMemOutboxTransaction = transaction as InMemoryOutboxTransaction;
if (inMemOutboxTransaction != null)
{
CompletableSynchronizedStorageSession session = new InMemorySynchronizedStorageSession(inMemOutboxTransaction.Transaction);
return(Task.FromResult(session));
}
return(EmptyTask);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context, CancellationToken cancellationToken = default)
{
if (transaction is RavenDBOutboxTransaction outboxTransaction)
{
sessionHolder?.SetCurrentSession(outboxTransaction.AsyncSession);
return(Task.FromResult <CompletableSynchronizedStorageSession>(
new RavenDBSynchronizedStorageSession(outboxTransaction.AsyncSession, context, false)));
}
return(EmptyResult);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
var outboxTransaction = transaction as ServiceFabricOutboxTransaction;
if (outboxTransaction != null)
{
// this session will not own the transaction, the outbox part owns the transaction
CompletableSynchronizedStorageSession session = new StorageSession(outboxTransaction.Transaction);
return(Task.FromResult(session));
}
return(EmptyTask);
}
public UnitOfWorkManagerTestsFixture SetupCommitTransactionBeforeSendingProcessOutboxMessageCommand()
{
OutboxTransaction.Setup(t => t.CommitAsync()).Callback(() =>
{
if (MessageSession.SentMessages.Any())
{
throw new Exception("Commit called too early");
}
});
return(this);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context, CancellationToken cancellationToken = default)
{
if (!(transaction is ISqlOutboxTransaction outboxTransaction))
{
return(EmptyResultTask);
}
var session = new StorageSession(outboxTransaction.Connection, outboxTransaction.Transaction, false, infoCache);
currentSessionHolder?.SetCurrentSession(session);
return(Task.FromResult <CompletableSynchronizedStorageSession>(session));
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
var martenTransaction = transaction as MartenOutboxTransaction;
if (martenTransaction != null)
{
CompletableSynchronizedStorageSession session = new MartenSynchronizedStorageSession(martenTransaction.Session, false);
return(Task.FromResult(session));
}
return(EmptyResult);
}
public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag context)
{
var tx = (InMemoryOutboxTransaction) transaction;
tx.Enlist(() =>
{
if (!storage.TryAdd(message.MessageId, new StoredMessage(message.MessageId, message.TransportOperations)))
{
throw new Exception($"Outbox message with id '{message.MessageId}' is already present in storage.");
}
});
return TaskEx.CompletedTask;
}
public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag context)
{
var tx = (InMemoryOutboxTransaction)transaction;
tx.Enlist(() =>
{
if (!storage.TryAdd(message.MessageId, new StoredMessage(message.MessageId, message.TransportOperations)))
{
throw new Exception($"Outbox message with id '{message.MessageId}' is already present in storage.");
}
});
return(TaskEx.CompletedTask);
}
public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag context, CancellationToken cancellationToken = default)
{
var tx = (AcceptanceTestingOutboxTransaction)transaction;
tx.Enlist(() =>
{
if (!storage.TryAdd(message.MessageId, new StoredMessage(message.MessageId, message.TransportOperations)))
{
throw new Exception($"Outbox message with id '{message.MessageId}' is already present in storage.");
}
});
return(Task.CompletedTask);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
var nhibernateTransaction = transaction as NHibernateOutboxTransaction;
if (nhibernateTransaction != null)
{
if (Transaction.Current != null)
{
Log.Warn("The endpoint is configured to use Outbox but a TransactionScope has been detected. Outbox mode is not compatible with "
+ "TransactionScope. Do not use config.UnitOfWork().WrapHandlersInATransactionScope() when Outbox is enabled.");
}
CompletableSynchronizedStorageSession session = new NHibernateOutboxTransactionSynchronizedStorageSession(nhibernateTransaction);
return(Task.FromResult(session));
}
return(EmptyResult);
}
public async Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag context)
{
var operations = new StoredTransportOperation[message.TransportOperations.Length];
for (var i = 0; i < message.TransportOperations.Length; i++)
{
var t = message.TransportOperations[i];
operations[i] = new StoredTransportOperation(t.MessageId, t.Options, t.Body, t.Headers);
}
var tx = ((ServiceFabricOutboxTransaction)transaction).Transaction.NativeTransaction;
if (!await Outbox.TryAddAsync(tx, message.MessageId, new StoredOutboxMessage(message.MessageId, operations)).ConfigureAwait(false))
{
throw new Exception($"Outbox message with id '{message.MessageId}' is already present in storage.");
}
}
public Task Store(OutboxMessage outboxMessage, OutboxTransaction transaction, ContextBag context)
{
var operations = outboxMessage.TransportOperations.Select(t => new OutboxOperation
{
Message = t.Body,
Headers = t.Headers,
MessageId = t.MessageId,
Options = t.Options,
});
var nhibernateTransaction = (NHibernateOutboxTransaction)transaction;
nhibernateTransaction.Session.Save(new OutboxRecord
{
MessageId = EndpointQualifiedMessageId(outboxMessage.MessageId),
Dispatched = false,
TransportOperations = ConvertObjectToString(operations)
});
return(Task.FromResult(0));
}
public Task Store(OutboxMessage message, OutboxTransaction outboxTransaction, ContextBag context)
{
var sqlOutboxTransaction = (SqlOutboxTransaction) outboxTransaction;
var transaction = sqlOutboxTransaction.Transaction;
var connection = sqlOutboxTransaction.Connection;
return Store(message, transaction, connection);
}
public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag context)
{
testContext.NumberOfOps += message.TransportOperations.Length;
return(Task.FromResult(0));
}
public Task<CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
return EmptyResult;
}
public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag options)
{
return TaskEx.CompletedTask;
}
public Task Store(OutboxMessage message, OutboxTransaction outboxTransaction, ContextBag context, CancellationToken cancellationToken = default) => ((ISqlOutboxTransaction)outboxTransaction).Complete(message, context, cancellationToken);
public Task Store(OutboxMessage message, OutboxTransaction transaction, ContextBag options)
{
return(TaskEx.CompletedTask);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context)
{
return(EmptyResult);
}
public Task <CompletableSynchronizedStorageSession> TryAdapt(OutboxTransaction transaction, ContextBag context, CancellationToken cancellationToken = default)
{
return(Task.FromResult <CompletableSynchronizedStorageSession>(null));
}
