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