public async Task Defaults_to_no_ttbr() { using (var connection = sqlConnectionFactory.OpenNewConnection().GetAwaiter().GetResult()) { using (var transaction = connection.BeginTransaction()) { var transportTransaction = new TransportTransaction(); transportTransaction.Set(connection); transportTransaction.Set(transaction); var context = new ContextBag(); context.Set(transportTransaction); var operation = new TransportOperation( new OutgoingMessage("1", new Dictionary <string, string>(), new byte[0]), new UnicastAddressTag(validAddress) ); await dispatcher.Dispatch(new TransportOperations(operation), transportTransaction, context).ConfigureAwait(false); transaction.Commit(); } var expired = await queue.PurgeBatchOfExpiredMessages(connection, 100).ConfigureAwait(false); Assert.AreEqual(0, expired); } }
public void ShouldShallowCloneContextBag() { var context = new ContextBag(); context.Set("someKey", "someValue"); var testee = new SubscribeContext(new RootContext(null, null, null), typeof(object), context); testee.Extensions.Set("someKey", "updatedValue"); testee.Extensions.Set("anotherKey", "anotherValue"); string value; string anotherValue; context.TryGet("someKey", out value); Assert.AreEqual("someValue", value); Assert.IsFalse(context.TryGet("anotherKey", out anotherValue)); string updatedValue; string anotherValue2; testee.Extensions.TryGet("someKey", out updatedValue); testee.Extensions.TryGet("anotherKey", out anotherValue2); Assert.AreEqual("updatedValue", updatedValue); Assert.AreEqual("anotherValue", anotherValue2); }
private async Task RunTestUsing(GetSagaDelegate getSaga) { var sagaId = StoreSagaDocuments(); using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency()) { var persister = new SagaPersister(); var context = new ContextBag(); context.Set(session); var synchronizedSession = new RavenDBSynchronizedStorageSession(session); var sagaData = await getSaga(persister, sagaId, synchronizedSession, context); Assert.IsNotNull(sagaData); Assert.AreEqual(42, sagaData.Counter); Assert.AreEqual("Alpha", sagaData.Name); await persister.Complete(sagaData, synchronizedSession, context); await session.SaveChangesAsync(); } using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency()) { var dataDocs = await session.Advanced.LoadStartingWithAsync <SagaDataContainer>("CountingSagaDatas/"); var uniqueDocs = await session.Advanced.LoadStartingWithAsync <SagaUniqueIdentity>("Raven3Sagas-"); Assert.IsEmpty(dataDocs); Assert.IsEmpty(uniqueDocs); } }
public async Task When_in_transaction_scope_with_sql_connection_should_hook_up_to_that_connection() { var data = new TimeoutData { Time = DateTime.Now, OwningTimeoutManager = "MyTestEndpoint", }; var contextBag = new ContextBag(); using (var tx = new TransactionScope()) { var connection = (SqlConnection)((SessionFactoryImpl)sessionFactory).ConnectionProvider.GetConnection(); var transaction = new TransportTransaction(); transaction.Set(Transaction.Current); transaction.Set(connection); contextBag.Set(transaction); await persister.Add(data, contextBag).ConfigureAwait(false); Assert.AreEqual(Guid.Empty, Transaction.Current.TransactionInformation.DistributedIdentifier); tx.Complete(); } using (var session = sessionFactory.OpenSession()) { Assert.NotNull(session.Get <TimeoutEntity>(new Guid(data.Id))); } }
public ContainerHolder ResolveAndSetIfAvailable(ContextBag context) { if (context.TryGet <ContainerHolder>(out var containerHolder)) { return(containerHolder); } ContainerInformation?information; if (context.TryGet <ContainerInformation>(out var containerInformation)) { information = containerInformation; } else { information = defaultContainerInformation; } if (!information.HasValue) { return(null); } var informationValue = information.Value; containerHolder = new ContainerHolder(provideCosmosClient.Client.GetContainer(databaseName, informationValue.ContainerName), informationValue.PartitionKeyPath); context.Set(containerHolder); return(containerHolder); }
public async Task is_delayed_delayed() { var bag = new ContextBag(); bool invoked = false; var handler = new MessageHandler((first, second, ctx) => { invoked = true; return(Task.CompletedTask); }, typeof(DelayedHandler)); var context = new Moq.Mock <IInvokeHandlerContext>(); var builder = new Moq.Mock <IBuilder>(); var channel = new Moq.Mock <IDelayedChannel>(); var next = new Moq.Mock <Func <PipelineTerminator <IInvokeHandlerContext> .ITerminatingContext, Task> >(); var container = new Moq.Mock <IContainer>(); bag.Set(container.Object); container.Setup(x => x.Resolve <IDelayedChannel>()).Returns(channel.Object); context.Setup(x => x.MessageHandler).Returns(handler); context.Setup(x => x.Builder).Returns(builder.Object); context.Setup(x => x.Extensions).Returns(bag); context.Setup(x => x.MessageBeingHandled).Returns(new DelayedMessage()); context.Setup(x => x.Headers).Returns(new Dictionary <string, string>()); await _terminator.Invoke(context.Object, next.Object); Assert.False(invoked); channel.Verify(x => x.AddToQueue(Moq.It.IsAny <string>(), Moq.It.IsAny <IDelayedMessage>(), Moq.It.IsAny <string>()), Moq.Times.Once); // Posibly optional channel.Verify(x => x.Age(Moq.It.IsAny <string>(), Moq.It.IsAny <string>()), Moq.Times.Once); channel.Verify(x => x.Size(Moq.It.IsAny <string>(), Moq.It.IsAny <string>()), Moq.Times.Once); }
static ContextBag CreateContextBag(string messageId) { var contextBag = new ContextBag(); contextBag.Set(new IncomingMessage(messageId, new Dictionary <string, string>(), new byte[0])); return(contextBag); }
public Task persistence_uow_bag_stored_on_fail() { var bag = new ContextBag(); bag.Set("test", "test"); var context = new Moq.Mock <IIncomingLogicalMessageContext>(); var next = new Moq.Mock <Func <Task> >(); var builder = new Moq.Mock <IBuilder>(); var uow = new Moq.Mock <IApplicationUnitOfWork>(); builder.Setup(x => x.BuildAll <IApplicationUnitOfWork>()).Returns(new IApplicationUnitOfWork[] { uow.Object }); context.Setup(x => x.MessageId).Returns("1"); context.Setup(x => x.Message).Returns(new LogicalMessage(new NServiceBus.Unicast.Messages.MessageMetadata(typeof(object)), new object())); context.Setup(x => x.Extensions).Returns(bag); context.Setup(x => x.Builder).Returns(builder.Object); context.Setup(x => x.Headers).Returns(new Dictionary <string, string>()); context.Setup(x => x.MessageHeaders) .Returns(new Dictionary <string, string> { [Headers.MessageIntent] = MessageIntentEnum.Send.ToString() }); uow.Setup(x => x.End(null)).Throws(new Exception("test")); uow.Setup(x => x.Bag).Returns(bag); Assert.ThrowsAsync <Exception>(() => _uow.Invoke(context.Object, next.Object)); _persistence.Verify(x => x.Save("1", uow.Object.GetType(), bag), Moq.Times.Once); _persistence.Verify(x => x.Clear("1"), Moq.Times.Never); next.Verify(x => x(), Moq.Times.Once); return(Task.CompletedTask); }
public async Task Delivery_constraint_is_respected() { using (var connection = sqlConnectionFactory.OpenNewConnection().GetAwaiter().GetResult()) { using (var transaction = connection.BeginTransaction()) { var transportTransaction = new TransportTransaction(); transportTransaction.Set(SettingsKeys.TransportTransactionSqlConnectionKey, connection); transportTransaction.Set(SettingsKeys.TransportTransactionSqlTransactionKey, transaction); var context = new ContextBag(); context.Set(transportTransaction); var operation = new TransportOperation( new OutgoingMessage("1", new Dictionary <string, string>(), new byte[0]), new UnicastAddressTag(validAddress), DispatchConsistency.Default, new List <DeliveryConstraint> { new DiscardIfNotReceivedBefore(TimeSpan.FromMinutes(-1)) //Discard immediately } ); await dispatcher.Dispatch(new TransportOperations(operation), transportTransaction, context).ConfigureAwait(false); transaction.Commit(); } var message = await queue.TryReceive(connection, null).ConfigureAwait(false); Assert.IsTrue(message.Message.Expired); } }
public static ContextBag CreateContextWithAsyncSessionPresent(this RavenDBPersistenceTestBase testBase, out IAsyncDocumentSession session) { var context = new ContextBag(); session = testBase.OpenAsyncSession(); context.Set(session); return context; }
public async Task persistence_uow_retreive_bag() { var bag = new ContextBag(); bag.Set("test", "test"); var context = new Moq.Mock <IIncomingLogicalMessageContext>(); var next = new Moq.Mock <Func <Task> >(); var builder = new Moq.Mock <IBuilder>(); var uow = new FakeUnitOfWork(); builder.Setup(x => x.BuildAll <IApplicationUnitOfWork>()).Returns(new IApplicationUnitOfWork[] { uow }); context.Setup(x => x.MessageId).Returns("1"); context.Setup(x => x.Message).Returns(new LogicalMessage(new NServiceBus.Unicast.Messages.MessageMetadata(typeof(object)), new object())); context.Setup(x => x.Extensions).Returns(bag); context.Setup(x => x.Builder).Returns(builder.Object); context.Setup(x => x.Headers).Returns(new Dictionary <string, string>()); context.Setup(x => x.MessageHeaders) .Returns(new Dictionary <string, string> { [Headers.MessageIntent] = MessageIntentEnum.Send.ToString() }); _persistence.Setup(x => x.Remove("1", uow.GetType())).Returns(Task.FromResult(bag)); await _uow.Invoke(context.Object, next.Object); next.Verify(x => x(), Moq.Times.Once); string test; Assert.True(uow.Bag.TryGet <string>("test", out test)); Assert.AreEqual("test", test); _persistence.Verify(x => x.Save("1", uow.GetType(), bag), Moq.Times.Once); _persistence.Verify(x => x.Clear("1"), Moq.Times.Once); }
public async Task <T> Get <T>(string propertyName, object propertyValue, SynchronizedStorageSession session, ContextBag context) where T : class, IContainSagaData { var documentSession = session.RavenSession(); var lookupId = SagaUniqueIdentity.FormatId(typeof(T), propertyName, propertyValue); var lookup = await documentSession .Include("SagaDocId") //tell raven to pull the saga doc as well to save us a round-trip .LoadAsync <SagaUniqueIdentity>(lookupId) .ConfigureAwait(false); if (lookup != null) { documentSession.Advanced.Evict(lookup); // If we have a saga id we can just load it, should have been included in the round-trip already var container = await documentSession.LoadAsync <SagaDataContainer>(lookup.SagaDocId).ConfigureAwait(false); if (container != null) { if (container.IdentityDocId == null) { container.IdentityDocId = lookupId; } context.Set($"{SagaContainerContextKeyPrefix}{container.Data.Id}", container); return((T)container.Data); } } return(default(T)); }
public async Task Diagnostic_headers_are_ignored() { using (var connection = sqlConnectionFactory.OpenNewConnection().GetAwaiter().GetResult()) { using (var transaction = connection.BeginTransaction()) { var transportTransaction = new TransportTransaction(); transportTransaction.Set(SettingsKeys.TransportTransactionSqlConnectionKey, connection); transportTransaction.Set(SettingsKeys.TransportTransactionSqlTransactionKey, transaction); var context = new ContextBag(); context.Set(transportTransaction); var headers = new Dictionary <string, string> { [Headers.TimeToBeReceived] = TimeSpan.FromMinutes(-1).ToString() }; var operation = new TransportOperation( new OutgoingMessage("1", headers, new byte[0]), new UnicastAddressTag(ValidAddress) ); await dispatcher.Dispatch(new TransportOperations(operation), transportTransaction).ConfigureAwait(false); transaction.Commit(); } var message = await queue.TryReceive(connection, null).ConfigureAwait(false); Assert.IsFalse(message.Message.Expired); } }
public static ContextBag GetContextBag(this IMessage amqpMessage) { var contextBag = new ContextBag(); contextBag.Set(amqpMessage); return(contextBag); }
public async Task Diagnostic_headers_are_ignored() { using (var connection = sqlConnectionFactory.OpenNewConnection().GetAwaiter().GetResult()) { using (var transaction = connection.BeginTransaction()) { var transportTransaction = new TransportTransaction(); transportTransaction.Set(connection); transportTransaction.Set(transaction); var context = new ContextBag(); context.Set(transportTransaction); var headers = new Dictionary <string, string> { [Headers.TimeToBeReceived] = TimeSpan.FromMinutes(-1).ToString() }; var operation = new TransportOperation( new OutgoingMessage("1", headers, new byte[0]), new UnicastAddressTag(validAddress) ); await dispatcher.Dispatch(new TransportOperations(operation), transportTransaction, context).ConfigureAwait(false); transaction.Commit(); } var expired = await queue.PurgeBatchOfExpiredMessages(connection, 100).ConfigureAwait(false); Assert.AreEqual(0, expired); } }
/// <summary> /// Initializes a new TestableCosmosSynchronizedStorageSession with a partition key. /// </summary> public TestableCosmosSynchronizedStorageSession(PartitionKey partitionKey) { var contextBag = new ContextBag(); contextBag.Set(partitionKey); ((IWorkWithSharedTransactionalBatch)this).CurrentContextBag = contextBag; }
public async Task When_in_transaction_scope_add_should_commit_when_scope_is_complete() { var data = new TimeoutData { Time = DateTime.Now.AddYears(-1), OwningTimeoutManager = "MyTestEndpoint", }; var contextBag = new ContextBag(); using (var tx = new TransactionScope()) { var transaction = new TransportTransaction(); transaction.Set(Transaction.Current); contextBag.Set(transaction); await persister.Add(data, contextBag).ConfigureAwait(false); tx.Complete(); } using (var session = sessionFactory.OpenSession()) { Assert.NotNull(session.Get <TimeoutEntity>(new Guid(data.Id))); } }
public async Task retries_are_set() { var bag = new ContextBag(); bag.Set(Defaults.Retries, 1); var context = new Moq.Mock <IIncomingLogicalMessageContext>(); var next = new Moq.Mock <Func <Task> >(); var builder = new Moq.Mock <IBuilder>(); var uow = new FakeUnitOfWork(); builder.Setup(x => x.BuildAll <IApplicationUnitOfWork>()).Returns(new IApplicationUnitOfWork[] { uow }); context.Setup(x => x.MessageId).Returns("1"); context.Setup(x => x.Message).Returns(new LogicalMessage(new NServiceBus.Unicast.Messages.MessageMetadata(typeof(object)), new object())); context.Setup(x => x.Extensions).Returns(bag); context.Setup(x => x.Builder).Returns(builder.Object); context.Setup(x => x.Headers).Returns(new Dictionary <string, string>()); context.Setup(x => x.MessageHeaders) .Returns(new Dictionary <string, string> { [Headers.MessageIntent] = MessageIntentEnum.Send.ToString() }); await _uow.Invoke(context.Object, next.Object); next.Verify(x => x(), Moq.Times.Once); Assert.AreEqual(1, uow.Retries); }
static ContextBag GetContextWithRabbitMqPriority(byte priority) { var contextBag = new ContextBag(); contextBag.Set(new RabbitMQMessagePriority(priority)); return(contextBag); }
public async Task <T> Get <T>(string propertyName, object propertyValue, SynchronizedStorageSession session, ContextBag context) where T : class, IContainSagaData { var documentSession = session.RavenSession(); var lookupId = SagaUniqueIdentity.FormatId(typeof(T), propertyName, propertyValue); //store it in the context to be able to optimize deletes for legacy sagas that don't have the id in metadata context.Set(UniqueDocIdKey, lookupId); var lookup = await documentSession .Include("SagaDocId") //tell raven to pull the saga doc as well to save us a round-trip .LoadAsync <SagaUniqueIdentity>(lookupId) .ConfigureAwait(false); if (lookup != null) { documentSession.Advanced.Evict(lookup); return(lookup.SagaDocId != null ? await documentSession.LoadAsync <T>(lookup.SagaDocId).ConfigureAwait(false) //if we have a saga id we can just load it : await Get <T>(lookup.SagaId, session, context).ConfigureAwait(false)); //if not this is a saga that was created pre 3.0.4 so we fallback to a get instead } return(default(T)); }
public async Task Defaults_to_no_ttbr() { using (var connection = sqlConnectionFactory.OpenNewConnection().GetAwaiter().GetResult()) { using (var transaction = connection.BeginTransaction()) { var transportTransaction = new TransportTransaction(); transportTransaction.Set(SettingsKeys.TransportTransactionSqlConnectionKey, connection); transportTransaction.Set(SettingsKeys.TransportTransactionSqlTransactionKey, transaction); var context = new ContextBag(); context.Set(transportTransaction); var operation = new TransportOperation( new OutgoingMessage("1", new Dictionary <string, string>(), new byte[0]), new UnicastAddressTag(ValidAddress) ); await dispatcher.Dispatch(new TransportOperations(operation), transportTransaction).ConfigureAwait(false); transaction.Commit(); } var message = await queue.TryReceive(connection, null).ConfigureAwait(false); Assert.IsFalse(message.Message.Expired); } }
public static ContextBag CreateContextWithSessionPresent(this MartenPersistenceTestBase testBase, out IDocumentSession session) { var context = new ContextBag(); session = testBase.OpenSession(); context.Set(session); return(context); }
public Task <TestSaga08.SagaData08> FindBy(SomeOtherMessage message, SynchronizedStorageSession storageSession, ReadOnlyContextBag context) { Context.FinderUsed = true; var bag = new ContextBag(); bag.Set(context.Get <IncomingMessage>()); return(SagaPersister.Get <TestSaga08.SagaData08>("Property", "Test", storageSession, bag)); }
public static ContextBag CreateContextWithAsyncSessionPresent(this RavenDBPersistenceTestBase testBase, out IAsyncDocumentSession session) { var context = new ContextBag(); session = testBase.OpenAsyncSession(); context.Set(session); return(context); }
static TSagaData SetConcurrency <TSagaData>(Concurrency <TSagaData> result, ContextBag context) where TSagaData : IContainSagaData { if (!EqualityComparer <TSagaData> .Default.Equals(result.Data, default(TSagaData))) { context.Set("NServiceBus.Persistence.Sql.Concurrency", result.Version); } return(result.Data); }
public void ShouldAllowMonkeyPatching() { var contextBag = new ContextBag(); contextBag.Set("MonkeyPatch", "some string"); ((ReadOnlyContextBag)contextBag).TryGet("MonkeyPatch", out string theValue); Assert.AreEqual("some string", theValue); }
static void SetDoNotEnforceBestPractices(this ContextBag context) { var bestPracticesOptions = new EnforceBestPracticesOptions { Enabled = false }; context.Set(bestPracticesOptions); }
public void Can_pass_additional_information_via_context_bag() { var contextBag = new ContextBag(); contextBag.Set("MyKey", "MyValue"); var context = new ErrorContext(new Exception(), new Dictionary <string, string>(), "ID", new byte[0], new TransportTransaction(), 0, contextBag); Assert.AreEqual("MyValue", context.Extensions.Get <string>("MyKey")); }
static void SetEntry(ContextBag context, Guid sagaId, Entry value) { if (context.TryGet(ContextKey, out Dictionary <Guid, Entry> entries) == false) { entries = new Dictionary <Guid, Entry>(); context.Set(ContextKey, entries); } entries[sagaId] = value; }
public Task<OutboxTransaction> BeginTransaction(ContextBag context) { var session = documentStore.OpenAsyncSession(); session.Advanced.UseOptimisticConcurrency = true; context.Set(session); var transaction = new RavenDBOutboxTransaction(session); return Task.FromResult<OutboxTransaction>(transaction); }
protected IncomingMessage SimulateIncomingMessage(ContextBag context, string messageId = null) { messageId = messageId ?? Guid.NewGuid().ToString("N"); var incomingMessage = new IncomingMessage(messageId, new Dictionary <string, string>(), new byte[0]); context.Set(incomingMessage); return(incomingMessage); }
public async Task <IActionResult> Invoke(HttpRequest request, string messageType, ILogger logger, IAsyncCollector <string> collector, ExecutionContext executionContext) { var messageId = Guid.NewGuid().ToString("N"); var headers = new Dictionary <string, string> { [Headers.EnclosedMessageTypes] = messageType }; foreach (var httpHeader in request.Headers) { headers[httpHeader.Key] = httpHeader.Value; } var memoryStream = new MemoryStream(); await request.Body.CopyToAsync(memoryStream); var body = memoryStream.ToArray(); //JsonConvert.DeserializeObject(memoryStream.ToArray(), typeof(PlaceOrder)); // TODO: hardcoded, needs to be determined var rootContext = new ContextBag(); if (collector == null) { collector = new FakeCollector <string>(); } rootContext.Set(collector); var messageContext = new MessageContext(messageId, headers, body, new TransportTransaction(), new CancellationTokenSource(), rootContext); var instance = await GetEndpoint(logger, executionContext); try { await instance.PushMessage(messageContext); } catch (Exception ex) { if (moveFailedMessagesToError) { var errorContext = new ErrorContext(ex, headers, messageId, body, new TransportTransaction(), 0); var result = await instance.PushError(errorContext); if (result == ErrorHandleResult.RetryRequired) { throw; } return(new AcceptedResult()); } throw; } return(new OkResult()); }
public void ShouldAllowMonkeyPatching() { var contextBag = new ContextBag(); contextBag.Set("MonkeyPatch", "some string"); string theValue; ((ReadOnlyContextBag) contextBag).TryGet("MonkeyPatch", out theValue); Assert.AreEqual("some string", theValue); }
async Task ProcessFile(DirectoryBasedTransaction transaction, string messageId) { try { string[] message = File.ReadAllLines(transaction.FileToProcess); string bodyPath = message.First(); string json = string.Join("", message.Skip(1)); Dictionary<string, string> headers = HeaderSerializer.DeSerialize(json); string ttbrString; if (headers.TryGetValue(Headers.TimeToBeReceived, out ttbrString)) { TimeSpan ttbr = TimeSpan.Parse(ttbrString); //file.move preserves create time DateTime sentTime = File.GetCreationTimeUtc(transaction.FileToProcess); if (sentTime + ttbr < DateTime.UtcNow) { transaction.Commit(); return; } } CancellationTokenSource tokenSource = new CancellationTokenSource(); using (FileStream bodyStream = new FileStream(bodyPath, FileMode.Open)) { ContextBag context = new ContextBag(); context.Set(transaction); PushContext pushContext = new PushContext(messageId, headers, bodyStream, transaction, tokenSource, context); await pipeline(pushContext).ConfigureAwait(false); } if (tokenSource.IsCancellationRequested) { transaction.Rollback(); return; } transaction.Commit(); } catch (Exception) { transaction.Rollback(); } }