public async Task Calling_run_in_parallel_runs_migrations_only_once()
{
using var documentStore = GetDocumentStore();
await new TestDocumentIndex().ExecuteAsync(documentStore);
var instanceOne = new MigrationRunner(documentStore, new MigrationOptions()
{
Assemblies = assemblies
}, new ConsoleLogger());
var instanceTwo = new MigrationRunner(documentStore, new MigrationOptions()
{
Assemblies = assemblies
}, new ConsoleLogger());
var first = Task.Run(() => instanceOne.Run());
var second = Task.Run(() => instanceTwo.Run());
await Task.WhenAll(first, second);
WaitForIndexing(documentStore);
WaitForUserToContinueTheTest(documentStore);
using var session = documentStore.OpenSession();
var testDocCount = session.Query <TestDocument, TestDocumentIndex>().Count();
testDocCount
.Should()
.Be(1);
}
public void Can_call_up_then_down_on_migrations()
{
using (var store = GetDocumentStore())
{
new TestDocumentIndex().Execute(store);
var runner = new MigrationRunner(store, GetMigrationOptions(), new ConsoleLogger());
runner.Run();
WaitForIndexing(store);
// flip it and reverse it :P
var options = GetMigrationOptions();
options.Direction = Directions.Down;
var reverseRunner = new MigrationRunner(store, options, new ConsoleLogger());
reverseRunner.Run();
WaitForIndexing(store);
using (var session = store.OpenSession())
{
session.Query <TestDocument, TestDocumentIndex>()
.Count()
.Should().Be(0);
}
}
}
public void Can_call_migrations_down_to_a_certain_version()
{
using (var store = GetDocumentStore())
{
new TestDocumentIndex().Execute(store);
var runner = new MigrationRunner(store, GetMigrationOptions(), new ConsoleLogger());
runner.Run();
WaitForIndexing(store);
// migrate down to
var options = GetMigrationOptions();
options.Direction = Directions.Down;
options.ToVersion = 2;
var downRunner = new MigrationRunner(store, options, new ConsoleLogger());
downRunner.Run();
using (var session = store.OpenSession())
{
session.Query <TestDocument, TestDocumentIndex>()
.Count()
.Should().Be(1);
var secondMigrationDocument =
session.Load <MigrationRecord>(new Second_Migration().GetMigrationIdFromName());
secondMigrationDocument.Should().BeNull();
var firstMigrationDocument =
session.Load <MigrationRecord>(new First_Migration().GetMigrationIdFromName());
firstMigrationDocument.Should().NotBeNull();
}
}
}
public async Task Can_migrate_timeouts()
{
await Scenario.Define <SourceContext>()
.WithEndpoint <EndpointBeforeMigration>(b => b.CustomConfig(ec =>
{
var persistence = ec.UsePersistence <SqlPersistence>();
persistence.SubscriptionSettings().DisableCache();
persistence.SqlDialect <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(30));
options.RouteToThisEndpoint();
await session.Send(delayedMessage, options);
await WaitUntilTheTimeoutIsSavedInSql(Conventions.EndpointNamingConvention(typeof(Endpoint)));
c.TimeoutSet = true;
}))
.Done(c => c.TimeoutSet)
.Run(TimeSpan.FromSeconds(60));
var setupContext = await Scenario.Define <TargetContext>()
.WithEndpoint <Endpoint>(b => b.CustomConfig(ec =>
{
var transport = ec.UseTransport <MsmqTransport>();
transport.NativeDelayedDelivery(new SqlServerDelayedMessageStore(connectionString));
//To ensure we don't pick up the timeout via the timeout manager
var persistence = ec.UsePersistence <InMemoryPersistence>();
}))
.Done(c => c.EndpointsStarted)
.Run(TimeSpan.FromSeconds(90));
MigrationRunner.Run(connectionString);
var context = await Scenario.Define <TargetContext>()
.WithEndpoint <Endpoint>(b => b.CustomConfig(ec =>
{
var transport = ec.UseTransport <MsmqTransport>();
transport.NativeDelayedDelivery(new SqlServerDelayedMessageStore(connectionString));
//To ensure we don't pick up the timeout via the timeout manager
var persistence = ec.UsePersistence <InMemoryPersistence>();
}))
.Done(c => c.GotTheDelayedMessage)
.Run(TimeSpan.FromSeconds(120));
Assert.True(context.GotTheDelayedMessage);
}
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 Calling_run_twice_runs_migrations_only_once()
{
using var store = GetDocumentStore();
new TestDocumentIndex().Execute(store);
var runner = new MigrationRunner(store, GetMigrationOptions(), new ConsoleLogger());
runner.Run();
// oooops, twice!
runner.Run();
WaitForIndexing(store);
using var session = store.OpenSession();
session.Query <TestDocument, TestDocumentIndex>()
.Count()
.Should().Be(1);
}
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 static void AssemblyInit(TestContext context)
{
if (File.Exists("test.db"))
{
File.Delete("test.db");
}
var conn = new TestAppConfig().DatabaseConnectionString;
var runner = new MigrationRunner(DatabaseType.Sqlite, conn, false, typeof(TestInitializer).Assembly);
runner.Run();
BaseControllerTest.Init();
}
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 Can_run_an_up_migration_against_a_document_store()
{
using var store = GetDocumentStore();
new TestDocumentIndex().Execute(store);
var runner = new MigrationRunner(store, GetMigrationOptions(), new ConsoleLogger());
runner.Run();
WaitForIndexing(store);
using var session = store.OpenSession();
session.Query <TestDocument, TestDocumentIndex>()
.Count()
.Should().Be(1);
}
public void Can_call_migrations_ignore_migrations_with_profile()
{
using var store = GetDocumentStore();
new TestDocumentIndex().Execute(store);
var runner = new MigrationRunner(store, GetMigrationOptions(), new ConsoleLogger());
runner.Run();
WaitForIndexing(store);
using var session = store.OpenSession();
var development = session.Load <object>("development-1");
development.Should().BeNull();
}
public void InitSchema()
{
if (_invoked)
{
throw new InvalidOperationException("Already invoked.");
}
_invoked = true;
try
{
var schemaManager = new MigrationRunner(OpenConnection, "Coderr", typeof(CoderrMigrationPointer).Namespace);
schemaManager.Run();
}
catch (SqlException ex)
{
throw new DataException(_databaseName + " [" + ConnectionString + "] schema init failed.", ex);
}
}
/// <inheritdoc/>
public async Task StartAsync(CancellationToken cancellationToken)
{
_runner.Run();
if (cancellationToken.IsCancellationRequested)
{
return;
}
await IndexCreation.CreateIndexesAsync(typeof(SetupDocumentStore).Assembly, _store, null, _store.Database, cancellationToken);
var indexErrors = await GetIndexErrors(maxWaitingForStaleIndexes : 30, cancellationToken);
if (!string.IsNullOrEmpty(indexErrors))
{
throw new DatabaseDisabledException(indexErrors);
}
}
public void Can_call_migrations_that_are_not_direct_subclasses_of_Migration()
{
using var store = GetDocumentStore();
new TestDocumentIndex().Execute(store);
var options = GetMigrationOptions();
options.Profiles = new[] { "uses-BaseMigration" };
var runner = new MigrationRunner(store, options, new ConsoleLogger());
runner.Run();
WaitForIndexing(store);
using var session = store.OpenSession();
var development = session.Load <object>("migrated-using-BaseMigration");
development.Should().NotBeNull();
}
private static void Main(string[] args)
{
try
{
if (args == null || args.Length == 0)
{
args = new[] { "-h" }
}
;
var config = Run(args);
if (config.AssemblyPath == null && config.Directory == null)
{
throw new Exception($"Both assembly path and directory can not be empty together.");
}
var files = new List <string>();
if (config.AssemblyPath != null)
{
files.Add(config.AssemblyPath);
}
if (config.Directory != null)
{
files.AddRange(Directory.GetFiles(config.Directory, "*.dll"));
}
var loaders = new List <PluginLoader>();
foreach (var file in files)
{
var loader = PluginLoader.CreateFromAssemblyFile(file, new[] { typeof(DbMigratorBase) });
loaders.Add(loader);
}
var runner = new MigrationRunner();
runner.Run(config.ConnectionString, loaders.Select(i => i.LoadDefaultAssembly()).ToArray(), null);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void Can_call_migrations_with_demo_profile()
{
using (var store = GetDocumentStore())
{
new TestDocumentIndex().Execute(store);
var options = GetMigrationOptions();
options.Profiles = new[] { "demo" };
var runner = new MigrationRunner(store, options, new ConsoleLogger());
runner.Run();
WaitForIndexing(store);
using (var session = store.OpenSession())
{
var development = session.Load <object>("development-1");
development.Should().NotBeNull();
}
}
}
private void UpgradeDatabaseSchema()
{
// Dont run for new installations
if (!HostConfig.Instance.IsConfigured)
{
return;
}
try
{
var migrator = new MigrationRunner(() => OpenConnection(CoderrClaims.SystemPrincipal), "Coderr", typeof(CoderrMigrationPointer).Namespace);
migrator.Run();
}
catch (Exception ex)
{
_logger.Fatal("DB Migration failed.", ex);
Err.Report(ex, new { Migration = true });
}
}
public void Can_call_migrations_up_to_a_certain_version()
{
using var store = GetDocumentStore();
new TestDocumentIndex().Execute(store);
var options = GetMigrationOptions();
options.ToVersion = 1;
var runner = new MigrationRunner(store, options, new ConsoleLogger());
runner.Run();
WaitForIndexing(store);
using var session = store.OpenSession();
session.Query <TestDocument, TestDocumentIndex>()
.Count()
.Should().Be(1);
var shouldNotExist = session.Load <object>("second-document");
shouldNotExist.Should().BeNull();
}
/// <summary>
/// Runs the migrate tool
/// </summary>
/// <param name = "args" > program arguements</param>
public void Run(Queue <string> args)
{
var executingLocation = Directory.GetCurrentDirectory();
var projectFile = Directory.GetFiles(executingLocation, "*.csproj");
if (projectFile.Length == 0)
{
throw new FileNotFoundException("Project file not found in current directory.");
}
var parser = ArgumentParserFactory.GetInstance <MigrationOptions>();
// pull out arg as we pass the remaining arguments down the list
var options = parser.Parse(args);
var isValid = options.Validate();
if (!isValid)
{
Console.WriteLine("Run dotnet mongo --help for usage information.");
}
options.ProjectFile = projectFile[0];
var migrationResult = MigrationRunner.Run(options);
if (migrationResult.Operation == MigrationOperation.Status && migrationResult.IsSuccessful)
{
var table = migrationResult.Result.BuildConsoleTable();
table.Write(Format.Alternative);
}
else
{
Console.WriteLine(migrationResult.Result);
}
}
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);
}
public void CreateTables()
{
_schemaManager.Run();
}
private void DatabaseInitialization(string connectionString)
{
var migrator = new MigrationRunner(connectionString);
migrator.Run();
}
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);
}
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 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 void UpdateSchema(int version)
{
var mgr = new MigrationRunner(OpenConnection, "Coderr", typeof(CoderrMigrationPointer).Namespace);
mgr.Run();
}
