public void EndpointValidatorRegexp() { var validator = new EndpointFilter(new[] { "[a-z]+.com" }); Assert.True(validator.Validate(new Uri("http://bing.com"))); Assert.False(validator.Validate(new Uri("http://bing123.com"))); }
public void EndpointValidatorDefault() { var validator = new EndpointFilter(); Assert.True(validator.Validate(new Uri("http://google.com"))); Assert.False(validator.Validate(new Uri("https://storagesample.blob.core.windows.net"))); }
public IndexViewModel Create(HttpContext httpContext, EndpointFilter filter, IEnumerable <Data.Entities.Endpoint> endpoints, string orderBy, int skip, int take, int total) { IStringLocalizer <IndexViewModelFactory> localizer = httpContext.GetStringLocalizer <IndexViewModelFactory>(); return(new IndexViewModel() { Grid = new GridViewModelFactory().Create( httpContext, new[] { new FilterViewModelFactory().Create(httpContext, "Name.Contains", localizer["Name"]), new FilterViewModelFactory().Create(httpContext, "UrlTemplate.Contains", localizer["URL template"]) }, orderBy, skip, take, total, new[] { new GridColumnViewModelFactory().Create(localizer["Name"], "Name"), new GridColumnViewModelFactory().Create(localizer["URL template"], "UrlTemplate"), new GridColumnViewModelFactory().Create(localizer["Position"], "Position"), new GridColumnViewModelFactory().Create(localizer["Data sources"]), new GridColumnViewModelFactory().CreateEmpty() }, endpoints.Select(e => new EndpointViewModelFactory().Create(e)), "_Endpoint" ) }); }
public async Task WhenRunningWithStateStoragePreparedAndParametersMatch() { var batches = GetBatches(); var toolState = new FakeToolState { EndpointName = testEndpoint, Batches = batches, RunParameters = new Dictionary <string, string>(), Status = MigrationStatus.StoragePrepared }; timeoutsSource.SetupToolStateToReturn(toolState); timeoutsSource.SetupTimeoutsToReadForBatch(batches.First()); await runner.Run(DateTime.Now, EndpointFilter.SpecificEndpoint(testEndpoint), new Dictionary <string, string>()); Assert.That(timeoutsSource.EndpointsWereListed, Is.False); Assert.That(timeoutsSource.ToolStateWasCreated, Is.False); Assert.That(timeoutsTarget.EndpointWasVerified, Is.False); Assert.That(timeoutsSource.BatchWasRead); Assert.That(timeoutsTarget.BatchWasStaged); Assert.That(timeoutsSource.BatchWasCompleted); Assert.That(timeoutsSource.ToolStateMovedToCompleted); Assert.That(timeoutsSource.MigrationWasAborted, Is.False); Assert.That(timeoutsTarget.MigrationWasCompleted); }
private void VerifyAgainst(Models.Pact pact, List <VerificationRecord> verificationRecords) { var splitPacts = pact.SplitByEndpoint(true); var selectedToTestEndpoints = new EndpointFilter().Filter(splitPacts); foreach (var ep in selectedToTestEndpoints) { var singleInteractions = ep.Value.SplitByInteractions(); foreach (var singleInteraction in singleInteractions) { var interaction = singleInteraction.Interactions[0]; var publishResultViaBroker = PactnetVerificationPublish.InterceptPactBeforeVerification(singleInteraction, interaction); var verificationRecord = new VerificationRecord().UpdateFrom(singleInteraction, interaction); using (var pactVerifier = _pactVerifierFactory(publishResultViaBroker)) { var requestFilters = _filtersBuilder.Build(); pactVerifier.AddRequestFilters(requestFilters); var result = pactVerifier.Verify(singleInteraction); verificationRecord.UpdateFrom(result[0]); } verificationRecords.Add(verificationRecord); } } }
public async Task Can_migrate_timeouts() { var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(AspSource)); var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(SqlTTarget)); await Scenario.Define <SourceContext>() .WithEndpoint <AspSource>(b => b.CustomConfig(ec => { SetupPersistence(ec); }) .When(async(session, c) => { var delayedMessage = new DelayedMessage(); var options = new SendOptions(); options.DelayDeliveryWith(TimeSpan.FromSeconds(15)); options.SetDestination(targetEndpoint); await session.Send(delayedMessage, options); await WaitUntilTheTimeoutsAreSavedInAsp(sourceEndpoint, 2); c.TimeoutSet = true; })) .Done(c => c.TimeoutSet) .Run(TimeSpan.FromSeconds(30)); var setupContext = await Scenario.Define <TargetContext>() .WithEndpoint <SqlTTarget>(b => b.CustomConfig(ec => { ec.OverrideLocalAddress(sourceEndpoint); ec.UseTransport <SqlServerTransport>() .ConnectionString(sqlConnectionString); })) .Done(c => c.EndpointsStarted) .Run(TimeSpan.FromSeconds(30)); var logger = new TestLoggingAdapter(setupContext); var timeoutStorage = CreateTimeoutStorage(sourceEndpoint); var timeoutTarget = new SqlTTimeoutsTarget(logger, sqlConnectionString, "dbo"); var migrationRunner = new MigrationRunner(logger, timeoutStorage, timeoutTarget); await migrationRunner.Run(DateTime.Now.AddDays(-10), EndpointFilter.SpecificEndpoint(sourceEndpoint), new Dictionary <string, string>()); var context = await Scenario.Define <TargetContext>() .WithEndpoint <SqlTTarget>(b => b.CustomConfig(ec => { ec.OverrideLocalAddress(sourceEndpoint); ec.UseTransport <SqlServerTransport>() .ConnectionString(sqlConnectionString); })) .Done(c => c.GotTheDelayedMessage) .Run(TimeSpan.FromSeconds(30)); Assert.True(context.GotTheDelayedMessage); }
public void EndpointValidatorWhitelist() { var validator = new EndpointFilter(new [] { "bing", "microsoft", "visualstudio" }); Assert.False(validator.Validate(new Uri("http://google.com"))); Assert.True(validator.Validate(new Uri("http://bing.com"))); Assert.True(validator.Validate(new Uri("http://microsoft.com"))); Assert.True(validator.Validate(new Uri("http://visualstudio.com"))); }
public void EndpointValidatorBlacklist() { var validator = new EndpointFilter(new[] { "google" }, false); Assert.False(validator.Validate(new Uri("http://google.com"))); Assert.True(validator.Validate(new Uri("http://bing.com"))); Assert.True(validator.Validate(new Uri("http://microsoft.com"))); Assert.True(validator.Validate(new Uri("http://visualstudio.com"))); }
public IEnumerable <EndpointDetails> GetEndpoints([FromUri] string[] filterStatus = null, [FromUri] string[] filterTags = null, string filterGroup = null, string filterText = null) { var filter = new EndpointFilter() .WithGroup(filterGroup) .WithStatus(filterStatus) .WithTags(filterTags) .WithText(filterText); return(_endpointRegistry.Endpoints.Select(EndpointDetails.FromDomain).Where(filter.DoesMatch)); }
public async Task Can_migrate_timeouts() { var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(SqlPSource)); var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(RabbitMqTarget)); await Scenario.Define <SourceContext>() .WithEndpoint <SqlPSource>(b => b.CustomConfig(ec => { var persistence = ec.UsePersistence <SqlPersistence>(); persistence.SqlDialect <NServiceBus.SqlDialect.MsSqlServer>(); persistence.ConnectionBuilder( connectionBuilder: () => { return(new SqlConnection(connectionString)); }); }) .When(async(session, c) => { var delayedMessage = new DelayedMessage(); var options = new SendOptions(); options.DelayDeliveryWith(TimeSpan.FromSeconds(15)); options.SetDestination(targetEndpoint); await session.Send(delayedMessage, options); await WaitUntilTheTimeoutIsSavedInSql(sourceEndpoint); c.TimeoutSet = true; })) .Done(c => c.TimeoutSet) .Run(TimeSpan.FromSeconds(30)); var context = await Scenario.Define <TargetContext>() .WithEndpoint <RabbitMqTarget>(b => b.CustomConfig(ec => { ec.UseTransport <RabbitMQTransport>() .ConnectionString(rabbitUrl); }) .When(async(_, c) => { var logger = new TestLoggingAdapter(c); var timeoutStorage = new SqlTimeoutsSource(connectionString, new MsSqlServer(), 1024); var transportAdapter = new RabbitMqTimeoutTarget(logger, rabbitUrl); var migrationRunner = new MigrationRunner(logger, timeoutStorage, transportAdapter); await migrationRunner.Run(DateTime.Now.AddDays(-10), EndpointFilter.SpecificEndpoint(sourceEndpoint), new Dictionary <string, string>()); })) .Done(c => c.GotTheDelayedMessage) .Run(TimeSpan.FromSeconds(30)); Assert.True(context.GotTheDelayedMessage); }
public async Task Can_migrate_timeouts() { var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(RavenDBSource)); var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(RabbitMqEndpoint)); var ravenTimeoutPrefix = "TimeoutDatas"; var ravenVersion = RavenDbVersion.Four; var ravenAdapter = new Raven4Adapter(serverUrl, databaseName); await Scenario.Define <SourceContext>() .WithEndpoint <RavenDBSource>(b => b.CustomConfig(ec => { ec.UsePersistence <RavenDBPersistence>() .SetDefaultDocumentStore(GetDocumentStore(serverUrl, databaseName)); }) .When(async(session, c) => { var delayedMessage = new DelayedMessage(); var options = new SendOptions(); options.DelayDeliveryWith(TimeSpan.FromSeconds(20)); options.SetDestination(targetEndpoint); await session.Send(delayedMessage, options); await WaitUntilTheTimeoutIsSavedInRaven(ravenAdapter, sourceEndpoint); c.TimeoutSet = true; })) .Done(c => c.TimeoutSet) .Run(TimeSpan.FromSeconds(15)); var context = await Scenario.Define <TargetContext>() .WithEndpoint <RabbitMqEndpoint>(b => b.CustomConfig(ec => { ec.UseTransport <RabbitMQTransport>() .ConnectionString(rabbitUrl); }) .When(async(_, c) => { var logger = new TestLoggingAdapter(c); var timeoutsSource = new RavenDbTimeoutsSource(logger, serverUrl, databaseName, ravenTimeoutPrefix, ravenVersion, false); var timeoutsTarget = new RabbitMqTimeoutTarget(logger, rabbitUrl); var migrationRunner = new MigrationRunner(logger, timeoutsSource, timeoutsTarget); await migrationRunner.Run(DateTime.Now.AddDays(-1), EndpointFilter.SpecificEndpoint(sourceEndpoint), new Dictionary <string, string>()); })) .Done(c => c.GotTheDelayedMessage) .Run(TimeSpan.FromSeconds(30)); Assert.True(context.GotTheDelayedMessage); }
public async Task Can_migrate_timeouts() { var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(NHibernateSource)); var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(SqlTTarget)); using (var testSession = CreateSessionFactory().OpenSession()) { // Explicit using scope to ensure dispose before SUT connects using (var testTx = testSession.BeginTransaction()) { await testSession.SaveAsync(new TimeoutEntity { Endpoint = sourceEndpoint, Destination = targetEndpoint, SagaId = Guid.NewGuid(), Headers = "{\"NServiceBus.EnclosedMessageTypes\": \"TimeoutMigrationTool.NHibernate.AcceptanceTests.NHibernateToSqlTEndToEnd+DelayedMessage\"}", State = Encoding.UTF8.GetBytes("{}"), Time = DateTime.UtcNow.AddSeconds(15) }); await testTx.CommitAsync(); } } var context = await Scenario.Define <TargetContext>() .WithEndpoint <SqlTTarget>(b => b.CustomConfig(ec => { ec.OverrideLocalAddress(sourceEndpoint); var transportConfig = ec.UseTransport <SqlServerTransport>(); transportConfig.ConnectionString(connectionString); ec.UseSerialization <NewtonsoftSerializer>(); }) .When(async(_, c) => { var logger = new TestLoggingAdapter(c); var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 1024, DatabaseDialect); var timeoutTarget = new SqlTTimeoutsTarget(logger, connectionString, "dbo"); var migrationRunner = new MigrationRunner(logger, timeoutsSource, timeoutTarget); await migrationRunner.Run(DateTime.Now.AddDays(-10), EndpointFilter.SpecificEndpoint(sourceEndpoint), new Dictionary <string, string>()); })) .Done(c => c.GotTheDelayedMessage) .Run(TimeSpan.FromSeconds(90)); Assert.True(context.GotTheDelayedMessage); }
public void WhenRunningWithStatePreparingAndParametersMatchThrows() { var batches = GetBatches(); var toolState = new FakeToolState { EndpointName = testEndpoint, Batches = batches, RunParameters = new Dictionary <string, string>(), Status = MigrationStatus.Preparing }; timeoutsSource.SetupToolStateToReturn(toolState); timeoutsSource.SetupTimeoutsToReadForBatch(batches.First()); Assert.ThrowsAsync <Exception>(async() => await runner.Run(DateTime.Now, EndpointFilter.SpecificEndpoint(testEndpoint), new Dictionary <string, string>())); }
/// <summary> /// Constructs <see cref="AspNetCoreConfiguration{TContext}"/> /// </summary> /// <param name="configuration">Correlation configuration</param> public AspNetCoreConfiguration(IConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } var settings = new CorrelationConfigurationSettings(); configuration.Bind(settings); InstrumentOutgoingRequests = settings.InstrumentOutgoingRequests ?? true; if (settings.Headers != null) { if (settings.Headers.CorrelationIdHeaderName != null && settings.Headers.RequestIdHeaderName != null) { CorrelationHeaderInfo.CorrelationIdHeaderName = settings.Headers.CorrelationIdHeaderName; CorrelationHeaderInfo.RequestIdHeaderName = settings.Headers.RequestIdHeaderName; } else { throw new ArgumentException($"\"Headers\" section must define \"{nameof(CorrelationHeaderInfo.CorrelationIdHeaderName)}\" and \"{CorrelationHeaderInfo.RequestIdHeaderName}\""); } } if (settings.EndpointFilter != null) { if (settings.EndpointFilter.Endpoints != null) { EndpointFilter = new EndpointFilter(settings.EndpointFilter.Endpoints, settings.EndpointFilter.Allow); } else { throw new ArgumentException($"\"EndpointFilter\" section must define \"{nameof(settings.EndpointFilter.Endpoints)}\" list"); } } else { EndpointFilter = new EndpointFilter(); } }
public async Task SuccessFlowCustomInjectorBlockedEndpoint() { var injector = new InjectorMock(); var validator = new EndpointFilter(); validator.AddEndpoint("google.com"); var config = new AspNetCoreCorrelationConfiguration() .WithEndpointValidator(validator); ContextTracingInstrumentation.Enable(config); var correlationId = Guid.NewGuid().ToString(); ContextResolver.SetContext(new CorrelationContext(correlationId)); var client = new HttpClient(); await client.GetAsync("http://google.com"); Assert.False(injector.WasCalled); }
public async Task Can_migrate_timeouts() { var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(RavenDBSource)); var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(AsqTarget)); var ravenTimeoutPrefix = "TimeoutDatas"; var ravenVersion = RavenDbVersion.Four; var ravenAdapter = new Raven4Adapter(serverUrl, databaseName); await Scenario.Define <SourceContext>() .WithEndpoint <RavenDBSource>(b => b.CustomConfig(ec => { ec.UsePersistence <RavenDBPersistence>() .SetDefaultDocumentStore(GetDocumentStore(serverUrl, databaseName)); ec.UseSerialization <NewtonsoftSerializer>(); }) .When(async(session, c) => { var delayedMessage = new DelayedMessage(); var options = new SendOptions(); options.DelayDeliveryWith(TimeSpan.FromSeconds(20)); options.SetDestination(targetEndpoint); await session.Send(delayedMessage, options); await WaitUntilTheTimeoutIsSavedInRaven(ravenAdapter, sourceEndpoint); c.TimeoutSet = true; })) .Done(c => c.TimeoutSet) .Run(TimeSpan.FromSeconds(15)); var context = await Scenario.Define <TargetContext>() // Create the legacy endpoint to forward the delayed message to the native delayed delivery endpoint // This is needed as ASQ stores the delayed messages at the sending endpoint until delivery is needed .WithEndpoint <RavenDBSource>(b => b.CustomConfig(ec => { var transport = ec.UseTransport <AzureStorageQueueTransport>().ConnectionString(asqConnectionString); transport.DisablePublishing(); transport.DelayedDelivery().DisableTimeoutManager(); ec.UseSerialization <NewtonsoftSerializer>(); })) .WithEndpoint <AsqTarget>(b => b.CustomConfig(ec => { var transport = ec.UseTransport <AzureStorageQueueTransport>().ConnectionString(asqConnectionString); transport.DisablePublishing(); transport.DelayedDelivery().DisableTimeoutManager(); ec.UseSerialization <NewtonsoftSerializer>(); }) .When(async(_, c) => { var logger = new TestLoggingAdapter(c); var timeoutsSource = new RavenDbTimeoutsSource(logger, serverUrl, databaseName, ravenTimeoutPrefix, ravenVersion, false); var timeoutsTarget = new ASQTarget(asqConnectionString, new DelayedDeliveryTableNameProvider()); var migrationRunner = new MigrationRunner(logger, timeoutsSource, timeoutsTarget); await migrationRunner.Run(DateTime.Now.AddDays(-1), EndpointFilter.SpecificEndpoint(sourceEndpoint), new Dictionary <string, string>()); })) .Done(c => c.GotTheDelayedMessage) .Run(TimeSpan.FromSeconds(30)); Assert.True(context.GotTheDelayedMessage); }
/// <summary> /// Constructs default <see cref="AspNetCoreConfiguration{TContext}"/> with enabled outgoing requests instrumentation and default <see cref="EndpointFilter"/> /// </summary> public AspNetCoreConfiguration() { InstrumentOutgoingRequests = true; EndpointFilter = new EndpointFilter(); }
public async Task Can_migrate_timeouts() { var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(AspSource)); var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(AsqTarget)); await Scenario.Define <SourceContext>() .WithEndpoint <AspSource>(b => b.CustomConfig(ec => { SetupPersistence(ec); ec.UseSerialization <NewtonsoftSerializer>(); }) .When(async(session, c) => { var delayedMessage = new DelayedMessage(); var options = new SendOptions(); options.DelayDeliveryWith(TimeSpan.FromSeconds(15)); options.SetDestination(targetEndpoint); await session.Send(delayedMessage, options); await WaitUntilTheTimeoutsAreSavedInAsp(sourceEndpoint, 2); c.TimeoutSet = true; })) .Done(c => c.TimeoutSet) .Run(TimeSpan.FromSeconds(30)); var context = await Scenario.Define <TargetContext>() // Create the legacy endpoint to forward the delayed message to the reporting endpoint // This is needed as ASQ stores the delayed messages at the sending endpoint until // delivery is needed .WithEndpoint <AspSource>(b => b.CustomConfig(ec => { var transportConfig = ec.UseTransport <AzureStorageQueueTransport>(); transportConfig.ConnectionString(asqConnectionString); transportConfig.DisablePublishing(); transportConfig.DelayedDelivery().DisableTimeoutManager(); ec.UseSerialization <NewtonsoftSerializer>(); })) // Start the reporting endpoint to receive and process the delayed message .WithEndpoint <AsqTarget>(b => b.CustomConfig(ec => { var transportConfig = ec.UseTransport <AzureStorageQueueTransport>(); transportConfig.ConnectionString(asqConnectionString); transportConfig.DisablePublishing(); transportConfig.DelayedDelivery().DisableTimeoutManager(); ec.UseSerialization <NewtonsoftSerializer>(); }) .When(async(_, c) => { var logger = new TestLoggingAdapter(c); var timeoutStorage = CreateTimeoutStorage(sourceEndpoint); var timeoutsTarget = new ASQTarget(asqConnectionString, new DelayedDeliveryTableNameProvider()); var migrationRunner = new MigrationRunner(logger, timeoutStorage, timeoutsTarget); await migrationRunner.Run(DateTime.Now.AddDays(-10), EndpointFilter.SpecificEndpoint(sourceEndpoint), new Dictionary <string, string>()); })) .Done(c => c.GotTheDelayedMessage) .Run(TimeSpan.FromSeconds(30)); Assert.True(context.GotTheDelayedMessage); }
public void EndpointValidatorEmpty() { var validator = new EndpointFilter(new string[0]); Assert.True(validator.Validate(new Uri("http://google.com"))); }
/// <summary> /// Constructs <see cref="ProfilerConfiguration{TContext}"/> with default <see cref="EndpointFilter"/> /// </summary> public ProfilerConfiguration() { EndpointFilter = new EndpointFilter(); }
public async Task Can_migrate_timeouts() { var salesEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(SqlPSource)); var reportingEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(AsqTarget)); // Make sure delayed delivery queue is created so that the migration can run. await Scenario.Define <SourceContext>() .WithEndpoint <SqlPSource>(b => b.CustomConfig(ec => { var transportConfig = ec.UseTransport <AzureStorageQueueTransport>(); transportConfig.ConnectionString(asqConnectionString); transportConfig.DisablePublishing(); transportConfig.DelayedDelivery().DisableTimeoutManager(); ec.UseSerialization <NewtonsoftSerializer>(); })).Run(TimeSpan.FromSeconds(10)); // Sending a delayed delivery message using TimeoutManager await Scenario.Define <SourceContext>() .WithEndpoint <SqlPSource>(b => b.CustomConfig(ec => { var persistence = ec.UsePersistence <SqlPersistence>(); persistence.SubscriptionSettings().DisableCache(); persistence.SqlDialect <NServiceBus.SqlDialect.MsSqlServer>(); persistence.ConnectionBuilder( connectionBuilder: () => new SqlConnection(connectionString)); ec.UseSerialization <NewtonsoftSerializer>(); }) .When(async(session, c) => { var delayedMessage = new DelayedMessage(); var options = new SendOptions(); options.DelayDeliveryWith(TimeSpan.FromSeconds(15)); options.SetDestination(reportingEndpoint); await session.Send(delayedMessage, options); await WaitUntilTheTimeoutIsSavedInSql(salesEndpoint); c.TimeoutSet = true; })) .Done(c => c.TimeoutSet) .Run(TimeSpan.FromSeconds(30)); var context = await Scenario.Define <TargetContext>() // Create the sales endpoint to forward the delayed message to the reporting endpoint // This is needed as ASQ stores the delayed messages at the sending endpoint until // delivery is needed .WithEndpoint <SqlPSource>(b => b.CustomConfig(ec => { var transportConfig = ec.UseTransport <AzureStorageQueueTransport>(); transportConfig.ConnectionString(asqConnectionString); transportConfig.DisablePublishing(); transportConfig.DelayedDelivery().DisableTimeoutManager(); ec.UseSerialization <NewtonsoftSerializer>(); })) // Start the reporting endpoint to receieve and process the delayed message .WithEndpoint <AsqTarget>(b => b.CustomConfig(ec => { var transportConfig = ec.UseTransport <AzureStorageQueueTransport>(); transportConfig.ConnectionString(asqConnectionString); transportConfig.DisablePublishing(); transportConfig.DelayedDelivery().DisableTimeoutManager(); ec.UseSerialization <NewtonsoftSerializer>(); }) .When(async(_, c) => { var logger = new TestLoggingAdapter(c); var timeoutStorage = new SqlTimeoutsSource(connectionString, new MsSqlServer(), 1024); var timeoutsTarget = new ASQTarget(asqConnectionString, new DelayedDeliveryTableNameProvider()); var migrationRunner = new MigrationRunner(logger, timeoutStorage, timeoutsTarget); await migrationRunner.Run(DateTime.Now.AddDays(-10), EndpointFilter.SpecificEndpoint(salesEndpoint), new Dictionary <string, string>()); })) .Done(c => c.GotTheDelayedMessage) .Run(TimeSpan.FromSeconds(30)); Assert.True(context.GotTheDelayedMessage); }
public async Task Can_migrate_timeouts() { var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(NHibernateSource)); var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(AsqTarget)); using (var testSession = CreateSessionFactory().OpenSession()) { // Explicit using scope to ensure dispose before SUT connects using (var testTx = testSession.BeginTransaction()) { await testSession.SaveAsync(new TimeoutEntity { Endpoint = sourceEndpoint, Destination = targetEndpoint, SagaId = Guid.NewGuid(), Headers = "{\"NServiceBus.EnclosedMessageTypes\": \"TimeoutMigrationTool.NHibernate.AcceptanceTests.NHibernateToAsqEndToEnd+DelayedMessage\"}", State = Encoding.UTF8.GetBytes("{}"), Time = DateTime.UtcNow.AddSeconds(15) }); await testTx.CommitAsync(); } } var context = await Scenario.Define <TargetContext>() // Create the legacy endpoint to forward the delayed message to the reporting endpoint // This is needed as ASQ stores the delayed messages at the sending endpoint until // delivery is needed .WithEndpoint <NHibernateSource>(b => b.CustomConfig(ec => { var transportConfig = ec.UseTransport <AzureStorageQueueTransport>(); transportConfig.ConnectionString(asqConnectionString); transportConfig.DisablePublishing(); transportConfig.DelayedDelivery().DisableTimeoutManager(); ec.UseSerialization <NewtonsoftSerializer>(); })) .WithEndpoint <AsqTarget>(b => b.CustomConfig(ec => { var transportConfig = ec.UseTransport <AzureStorageQueueTransport>(); transportConfig.ConnectionString(asqConnectionString); transportConfig.DisablePublishing(); transportConfig.DelayedDelivery().DisableTimeoutManager(); ec.UseSerialization <NewtonsoftSerializer>(); }) .When(async(_, c) => { var logger = new TestLoggingAdapter(c); var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 512, DatabaseDialect); var timeoutsTarget = new ASQTarget(asqConnectionString, new DelayedDeliveryTableNameProvider()); var migrationRunner = new MigrationRunner(logger, timeoutsSource, timeoutsTarget); await migrationRunner.Run(DateTime.Now.AddDays(-10), EndpointFilter.SpecificEndpoint(sourceEndpoint), new Dictionary <string, string>()); })) .Done(c => c.GotTheDelayedMessage) .Run(TimeSpan.FromSeconds(90)); Assert.True(context.GotTheDelayedMessage); }