public void Migrate(string connectionString, MigrationContext migrationContext)
{
var sw = Stopwatch.StartNew();
_announcer.Heading("Migrating " + connectionString);
var assembly = Assembly.GetExecutingAssembly();
var runnerContext = new RunnerContext(_announcer)
{
Namespace = "NzbDrone.Core.Datastore.Migration",
ApplicationContext = migrationContext
};
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
var factory = new NzbDroneSqliteProcessorFactory();
var processor = factory.Create(connectionString, _announcer, options);
var runner = new MigrationRunner(assembly, runnerContext, processor);
if (migrationContext.DesiredVersion.HasValue)
{
runner.MigrateUp(migrationContext.DesiredVersion.Value, true);
}
else
{
runner.MigrateUp(true);
}
sw.Stop();
_announcer.ElapsedTime(sw.Elapsed);
}
protected override void ApplicationStartup(TinyIoCContainer container, IPipelines pipelines)
{
base.ApplicationStartup(container, pipelines);
var announcer = new NullAnnouncer();
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = "Server.Migrations"
};
var options = new MigrationOptions();
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
var processor = factory.Create(
ConfigurationManager.ConnectionStrings["Simple.Data.Properties.Settings.DefaultConnectionString"].ConnectionString,
announcer,
options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
pipelines.EnableBasicAuthentication(new BasicAuthenticationConfiguration(new UserValidator(), "CPNRealm"));
JsonSettings.RetainCasing = true;
StaticConfiguration.DisableErrorTraces = false;
}
public static void Run(string connectionString)
{
var firstMigration = typeof(Lucid.Database.Migrations.Y2016.M01.V01);
var assembly = new SingleAssembly(firstMigration.Assembly);
var migrationGenerator = new SqlServer2008Generator();
var announcer = new NullAnnouncer();
var options = new ProcessorOptions();
var dbFactory = new SqlServerDbFactory();
var runnerContext = new RunnerContext(announcer)
{
Database = "SqlServer2008",
Connection = connectionString,
Targets = new string[] { firstMigration.Assembly.FullName },
NestedNamespaces = true,
Namespace = "Lucid.Database.Migrations",
};
using (var connection = new SqlConnection(connectionString))
using (var processor = new SqlServerProcessor(connection, migrationGenerator, announcer, options, dbFactory))
{
var runner = new MigrationRunner(assembly, runnerContext, processor);
runner.MigrateUp();
}
}
public void MigrateToLatest(string connectionString, MigrationType migrationType)
{
lock (MigrationCache)
{
if (MigrationCache.Contains(connectionString.ToLower())) return;
_announcer.Heading("Migrating " + connectionString);
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(_announcer)
{
Namespace = "NzbDrone.Core.Datastore.Migration",
ApplicationContext = new MigrationContext
{
MigrationType = migrationType,
SQLiteAlter = _sqLiteAlter,
MigrationHelper = _migrationHelper,
}
};
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
var factory = new SqliteProcessorFactory();
var processor = factory.Create(connectionString, _announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
MigrationCache.Add(connectionString.ToLower());
}
}
public void UpgradeDatabase()
{
var assembly = System.Reflection.Assembly.GetExecutingAssembly();
var announcer = new TextWriterAnnouncer(s => Log.Debug(s));
var context = new RunnerContext(announcer)
{
Namespace = "Causal.Server.Migrations"
};
var providerName = ConfigurationManager.ConnectionStrings["CausalContext"].ProviderName;
MigrationProcessorFactory factory;
if (providerName.Equals("Npgsql", StringComparison.InvariantCultureIgnoreCase))
{
factory = new FluentMigrator.Runner.Processors.Postgres.PostgresProcessorFactory();
}
else if (providerName.Equals("System.Data.SqlClient", StringComparison.InvariantCultureIgnoreCase))
{
factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
}
else
{
throw new Exception("Unknown provider for connection string CausalContext");
}
var options = new ProcessorOptions { PreviewOnly = false };
var processor = factory.Create(ConfigurationManager.ConnectionStrings["CausalContext"].ConnectionString, announcer, options);
var migrator = new MigrationRunner(assembly, context, processor);
migrator.MigrateUp(true);
}
public static void Run(IContainer settingsContainer)
{
var connectionString = settingsContainer.GetInstance<string>("DefaultConnection");
Announcer announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
announcer.ShowSql = true;
Assembly assembly = typeof(CreateTableEstacionamento).Assembly;
IRunnerContext migrationContext = new RunnerContext(announcer);
var options = new ProcessorOptions
{
PreviewOnly = false, // set to true to see the SQL
Timeout = 60
};
try
{
var factory = settingsContainer.GetInstance<MigrationProcessorFactory>(); //new FluentMigrator.Runner.Processors.SQLite.SQLiteProcessorFactory();
var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
catch (Exception ex)
{
throw new InvalidOperationException("connectionString: " + connectionString, ex);
}
}
public static void RunMigrations(string connectionString, string migration)
{
// var announcer = new NullAnnouncer();
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = "Azimuth.Migrations",
WorkingDirectory = "Migrations"
};
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory();
var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
switch (migration)
{
case "Run migrations":
runner.MigrateUp(true);
break;
case "Drop all tables":
runner.RollbackToVersion(201408091845);
runner.Rollback(1);
break;
}
}
private void MigrateTo(long targetVersion)
{
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
var announcer = new NullAnnouncer();
var processor = new SqlServer2012ProcessorFactory().Create(connectionString, announcer, options);
var migrationContext = new RunnerContext(announcer) { Namespace = "DDDEastAnglia.DatabaseMigrations.Migrations" };
var runner = new MigrationRunner(GetType().Assembly, migrationContext, processor);
runner.MigrateUp(targetVersion, true);
}
public void Run()
{
using (var connection = new SqlConnection(_connectionString))
{
var context = new RunnerContext(_announcer);
var generator = GetMigrationGenerator(_syntax);
var processor = new SqlServerProcessor(connection, generator, _announcer, _options);
var runner = new FluentMigrator.Runner.MigrationRunner(_assembly, context, processor);
runner.MigrateUp();
}
}
public void Migrate()
{
var processor = GetProcessor();
var context = new RunnerContext(new NullAnnouncer());
var migrationRunner = new MigrationRunner(
typeof (SqlSchemaMigrator).Assembly,
context,
processor);
migrationRunner.MigrateUp();
}
public static void Update(IAnnouncer announcer, MigrationProcessorType type, string connectionString, Assembly migrationAssembly)
{
var context = new RunnerContext(announcer);
var options = new ProcessorOptions();
var factory = GetProcessorFactory(type);
var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(migrationAssembly, context, processor);
runner.MigrateUp();
}
public static void MigrateToLatest()
{
var connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
var migrationAssembly= Assembly.GetExecutingAssembly();
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var migrationContext = new RunnerContext(announcer);
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 };
var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(migrationAssembly, migrationContext, processor);
runner.MigrateUp();
}
public void MigrateToLatest()
{
var announcer = new TextWriterAnnouncer(s => Debug.WriteLine(s));
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer);
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory();
using (var processor = factory.Create(connectionString, announcer, options))
{
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
}
public void MigrateToLatest()
{
var asm = Assembly.GetExecutingAssembly();
var announcer = new TextWriterAnnouncer((str) =>
{
Debug.WriteLine(str);
});
var context = new RunnerContext(announcer);
var options = new MigrationOptions();
var factory = new SqlServer2012ProcessorFactory();
var processor = factory.Create(this._connectionString, announcer, options);
var runner = new MigrationRunner(asm, context, processor);
runner.MigrateUp(true);
}
public static void MigrateToLatest(string connectionString)
{
var announcer = new NullAnnouncer();
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = "Hinata.Data.Migrations"
};
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory();
var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
public void Update()
{
IAnnouncer announcer = CreateAnnouncer();
IRunnerContext migrationContext = new RunnerContext(announcer);
ProcessorOptions options = new ProcessorOptions {
PreviewOnly = false, Timeout = 200
};
IMigrationProcessorFactory factory = new SqlServer2008ProcessorFactory();
Assembly migrationContainer = typeof(InitialDeployment).Assembly;
using (IMigrationProcessor processor = factory.Create(connectionString, announcer, options))
{
FluentMigrator.Runner.IMigrationRunner runner = new FluentMigrator.Runner.MigrationRunner(migrationContainer, migrationContext, processor);
runner.MigrateUp();
}
}
public void Run()
{
var announcer = new NullAnnouncer();
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = typeof(FluentDbMigrator).Namespace + ".Migrations"
};
var factory = GetProcessorFactory(_configuration.DbProvider);
var processor = factory.Create(_configuration.ConnectionString, announcer,
new ProcessorOptions { PreviewOnly = false, Timeout = 60 });
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
public static void MigrateToLatest(string connectionString)
{
// var announcer = new NullAnnouncer();
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = "Zoo.Models.Migrations"
};
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory();
var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
/// <summary>
/// Migrate the database to the latest version.
/// </summary>
/// <param name="connectionStringName">The name of the connection string.</param>
public static void MigrateToLatest(string connectionStringName)
{
var announcer = new NullAnnouncer();
var assembly = Assembly.GetAssembly(typeof(CreateCountriesTable));
var migrationContext = new RunnerContext(announcer)
{
Namespace = "ExampleApplication.Database.Migrations"
};
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2014ProcessorFactory();
using (var processor = factory.Create(connectionStringName, announcer, options))
{
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
}
public void Migrate(Action<IMigrationRunner> runnerAction)
{
var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 };
var factory = new FluentMigrator.Runner.Processors.SQLite.SQLiteProcessorFactory();
var assembly = Assembly.GetExecutingAssembly();
//using (var announcer = new NullAnnouncer())
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var migrationContext = new RunnerContext(announcer)
{
#if DEBUG
// will create testdata
Profile = "development"
#endif
};
using (var processor = factory.Create(connectionString, announcer, options))
{
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateDown(0);
runner.MigrateUp(true);
}
}
public void MigrateToLatest(string connectionString, MigrationType migrationType, Action<NzbDroneMigrationBase> beforeMigration)
{
var sw = Stopwatch.StartNew();
_announcer.Heading("Migrating " + connectionString);
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(_announcer)
{
Namespace = "NzbDrone.Core.Datastore.Migration",
ApplicationContext = new MigrationContext(migrationType, beforeMigration)
};
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
var factory = new NzbDroneSqliteProcessorFactory();
var processor = factory.Create(connectionString, _announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
sw.Stop();
_announcer.ElapsedTime(sw.Elapsed);
}
private void Check()
{
try
{
var announcer = new TextWriterAnnouncer(WriteLog);
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer);
var options = new MigrationOptions {PreviewOnly = false, Timeout = 60};
var factory = new FluentMigrator.Runner.Processors.MySql.MySqlProcessorFactory();
var processor = factory.Create(_provider.ConnectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
catch (InvalidMigrationException e)
{
_logger.Error("An invalid migration exception occured; {0:l}", e.Message);
}
catch (MySqlException e)
{
_logger.Error("An exception occured while running migration manager; {0:l}", e.Message);
}
}
public void MigrateUpWithTaggedMigrationsShouldOnlyApplyMatchedMigrations()
{
ExecuteWithSupportedProcessors(processor =>
{
var assembly = typeof(TenantATable).Assembly;
var runnerContext = new RunnerContext(new TextWriterAnnouncer(System.Console.Out))
{
Namespace = typeof(TenantATable).Namespace,
Tags = new[] { "TenantA" }
};
var runner = new MigrationRunner(assembly, runnerContext, processor);
try
{
runner.MigrateUp(false);
processor.TableExists(null, "TenantATable").ShouldBeTrue();
processor.TableExists(null, "NormalTable").ShouldBeTrue();
processor.TableExists(null, "TenantBTable").ShouldBeFalse();
processor.TableExists(null, "TenantAandBTable").ShouldBeTrue();
}
finally
{
runner.RollbackToVersion(0);
}
});
}
public void VersionInfoCreationScriptsOnlyGeneratedOnceInPreviewMode()
{
if (!IntegrationTestOptions.SqlServer2008.IsEnabled)
return;
var connection = new SqlConnection(IntegrationTestOptions.SqlServer2008.ConnectionString);
var processorOptions = new ProcessorOptions { PreviewOnly = true };
var outputSql = new StringWriter();
var announcer = new TextWriterAnnouncer(outputSql){ ShowSql = true };
var processor = new SqlServerProcessor(connection, new SqlServer2008Generator(), announcer, processorOptions, new SqlServerDbFactory());
try
{
var asm = typeof(MigrationRunnerTests).Assembly;
var runnerContext = new RunnerContext(announcer)
{
Namespace = "FluentMigrator.Tests.Integration.Migrations",
PreviewOnly = true
};
var runner = new MigrationRunner(asm, runnerContext, processor);
runner.MigrateUp(1, false);
processor.CommitTransaction();
string schemaName = new TestVersionTableMetaData().SchemaName;
var schemaAndTableName = string.Format("\\[{0}\\]\\.\\[{1}\\]", schemaName, TestVersionTableMetaData.TABLENAME);
var outputSqlString = outputSql.ToString();
var createSchemaMatches = new Regex(string.Format("CREATE SCHEMA \\[{0}\\]", schemaName)).Matches(outputSqlString).Count;
var createTableMatches = new Regex("CREATE TABLE " + schemaAndTableName).Matches(outputSqlString).Count;
var createIndexMatches = new Regex("CREATE UNIQUE CLUSTERED INDEX \\[" + TestVersionTableMetaData.UNIQUEINDEXNAME + "\\] ON " + schemaAndTableName).Matches(outputSqlString).Count;
var alterTableMatches = new Regex("ALTER TABLE " + schemaAndTableName).Matches(outputSqlString).Count;
System.Console.WriteLine(outputSqlString);
createSchemaMatches.ShouldBe(1);
createTableMatches.ShouldBe(1);
alterTableMatches.ShouldBe(2);
createIndexMatches.ShouldBe(1);
}
finally
{
CleanupTestSqlServerDatabase(connection, processor);
}
}
public void ValidateVersionOrderShouldThrowExceptionIfUnappliedMigrationVersionIsLessThanLatestAppliedMigration()
{
// Using SqlServer instead of SqlLite as versions not deleted from VersionInfo table when using Sqlite.
var excludedProcessors = new[] { typeof(SqliteProcessor), typeof(MySqlProcessor), typeof(PostgresProcessor) };
var assembly = typeof(User).Assembly;
var runnerContext1 = new RunnerContext(new TextWriterAnnouncer(System.Console.Out)) { Namespace = typeof(Migrations.Interleaved.Pass2.User).Namespace };
var runnerContext2 = new RunnerContext(new TextWriterAnnouncer(System.Console.Out)) { Namespace = typeof(Migrations.Interleaved.Pass3.User).Namespace };
VersionOrderInvalidException caughtException = null;
try
{
ExecuteWithSupportedProcessors(processor =>
{
var migrationRunner = new MigrationRunner(assembly, runnerContext1, processor);
migrationRunner.MigrateUp();
}, false, excludedProcessors);
ExecuteWithSupportedProcessors(processor =>
{
var migrationRunner = new MigrationRunner(assembly, runnerContext2, processor);
migrationRunner.ValidateVersionOrder();
}, false, excludedProcessors);
}
catch (VersionOrderInvalidException ex)
{
caughtException = ex;
}
finally
{
ExecuteWithSupportedProcessors(processor =>
{
var migrationRunner = new MigrationRunner(assembly, runnerContext2, processor);
migrationRunner.RollbackToVersion(0);
}, true, excludedProcessors);
}
caughtException.ShouldNotBeNull();
caughtException.InvalidMigrations.Count().ShouldBe(1);
var keyValuePair = caughtException.InvalidMigrations.First();
keyValuePair.Key.ShouldBe(200909060935);
keyValuePair.Value.Migration.ShouldBeOfType<UserEmail>();
}
public void ValidateVersionOrderShouldDoNothingIfUnappliedMigrationVersionIsGreaterThanLatestAppliedMigration()
{
// Using SqlServer instead of SqlLite as versions not deleted from VersionInfo table when using Sqlite.
var excludedProcessors = new[] { typeof(SqliteProcessor), typeof(MySqlProcessor), typeof(PostgresProcessor) };
var assembly = typeof(User).Assembly;
var runnerContext1 = new RunnerContext(new TextWriterAnnouncer(System.Console.Out)) { Namespace = typeof(Migrations.Interleaved.Pass2.User).Namespace };
var runnerContext2 = new RunnerContext(new TextWriterAnnouncer(System.Console.Out)) { Namespace = typeof(Migrations.Interleaved.Pass3.User).Namespace };
try
{
ExecuteWithSupportedProcessors(processor =>
{
var migrationRunner = new MigrationRunner(assembly, runnerContext1, processor);
migrationRunner.MigrateUp(3);
}, false, excludedProcessors);
ExecuteWithSupportedProcessors(processor =>
{
var migrationRunner = new MigrationRunner(assembly, runnerContext2, processor);
Assert.DoesNotThrow(migrationRunner.ValidateVersionOrder);
}, false, excludedProcessors);
}
finally
{
ExecuteWithSupportedProcessors(processor =>
{
var migrationRunner = new MigrationRunner(assembly, runnerContext2, processor);
migrationRunner.RollbackToVersion(0);
}, true, excludedProcessors);
}
}
/// <summary>
/// Runs database migrations of the specified module descriptor.
/// </summary>
/// <param name="moduleDescriptor">The module descriptor.</param>
/// <param name="up">if set to <c>true</c> migrates up; otherwise migrates down.</param>
public void Migrate(ModuleDescriptor moduleDescriptor, bool up = true)
{
var announcer = new TextWriterAnnouncer(
s =>
{
if (!string.IsNullOrWhiteSpace(s))
{
Log.Info(string.Concat("Migration on ", moduleDescriptor.Name, ". ", s));
}
});
var assembly = moduleDescriptor.GetType().Assembly;
var migrationTypes = assemblyLoader.GetLoadableTypes(assembly, typeof(Migration));
if (!migrationTypes.Any())
{
Log.Info(string.Concat("Migration on ", moduleDescriptor.Name, ". No migrations found."));
return;
}
var migrationContext = new RunnerContext(announcer)
{
Namespace = migrationTypes.First().Namespace
};
IMigrationProcessorOptions options = new ProcessorOptions
{
PreviewOnly = false,
Timeout = (int)migrationTimeout.TotalSeconds
};
IMigrationProcessor processor;
var connectionString = ConfigurationManager.ConnectionStrings["BetterCms"].ConnectionString;
if (databaseType == DatabaseType.SqlAzure || databaseType == DatabaseType.SqlServer)
{
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
processor = factory.Create(connectionString, announcer, options);
}
else if (databaseType == DatabaseType.PostgreSQL)
{
var factory = new FluentMigrator.Runner.Processors.Postgres.PostgresProcessorFactory();
processor = factory.Create(connectionString, announcer, options);
}
else if (databaseType == DatabaseType.Oracle)
{
var factory = new FluentMigrator.Runner.Processors.Oracle.OracleProcessorFactory();
processor = factory.Create(connectionString, announcer, options);
}
else
{
throw new NotSupportedException(string.Format("Database type {0} is not supported for data migrations.", databaseType));
}
var runner = new MigrationRunner(assembly, migrationContext, processor);
if (up)
{
runner.MigrateUp();
}
else
{
runner.MigrateDown(0);
}
}
public static void MigrateToLastVersion()
{
//// TODO: separate schema methods in another class
var provider = Dependency.Resolve<IDatabaseAdapter>();
Log.Framework.DebugFormat("Migrating database schema to last version");
if (Database.Configuration.Migrations.Any() == false)
{
Log.Framework.Warn("No assembly with migrations was found. Use Database.AddMapping(typeof(SomeMigration).Assembly);");
}
foreach (var migration in Database.Configuration.Migrations)
{
Log.Framework.DebugFormat("Migrating {0}", migration.FullName);
var announcer = new TextWriterAnnouncer(s =>
{
s = s.Replace(Environment.NewLine, string.Empty);
if (string.IsNullOrEmpty(s) == false)
{
Log.Framework.DebugFormat(s);
}
});
var assembly = migration;
var migrationContext = new RunnerContext(announcer);
var factory = provider.GetMigratorDriver();
var processor = factory.Create(AppSettings.ConnectionString, announcer, new ProcessorOptions
{
Timeout = 60,
PreviewOnly = false
});
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp();
}
Log.Framework.DebugFormat("Database migrated");
}
public static void ApplyMigration(Assembly assembly, ConnectionStringSettings connectionString)
{
var announcer = new TextWriterAnnouncer(s => Debug.WriteLine(s));
var migrationContext = new RunnerContext(announcer)
{
Profile = "Default"
};
var options = new ProcessorOptions { PreviewOnly = false, Timeout = 60 };
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory();
var processor = factory.Create(connectionString.ConnectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
public void CanRunMigrations()
{
ExecuteWithSupportedProcessors( processor =>
{
Assembly asm = typeof( MigrationRunnerTests ).Assembly;
var runnerContext = new RunnerContext( new TextWriterAnnouncer( System.Console.Out ) )
{
Namespace = "FluentMigrator.Tests.Integration.Migrations"
};
var runner = new MigrationRunner( asm, runnerContext, processor );
runner.MigrateUp();
runner.VersionLoader.VersionInfo.HasAppliedMigration( 1 ).ShouldBeTrue();
runner.VersionLoader.VersionInfo.HasAppliedMigration( 2 ).ShouldBeTrue();
runner.VersionLoader.VersionInfo.Latest().ShouldBe( 2 );
});
}
/// <summary>
/// Runs database migrations of the specified module descriptor.
/// </summary>
/// <param name="moduleDescriptor">The module descriptor.</param>
/// <param name="up">if set to <c>true</c> migrates up; otherwise migrates down.</param>
private void Migrate(ModuleDescriptor moduleDescriptor, IEnumerable<Type> migrationTypes = null, long? version = null)
{
var announcer = new TextWriterAnnouncer(
s =>
{
if (!string.IsNullOrWhiteSpace(s))
{
Log.Info(string.Concat("Migration on ", moduleDescriptor.Name, ". ", s));
}
});
var assembly = moduleDescriptor.GetType().Assembly;
if (migrationTypes == null)
{
migrationTypes = assemblyLoader.GetLoadableTypes(assembly, typeof(Migration));
}
if (migrationTypes == null || !migrationTypes.Any())
{
Log.Info(string.Concat("Migration on ", moduleDescriptor.Name, ". No migrations found."));
return;
}
var migrationContext = new RunnerContext(announcer)
{
Namespace = migrationTypes.First().Namespace
};
IMigrationProcessorOptions options = new ProcessorOptions
{
PreviewOnly = false,
Timeout = (int)migrationTimeout.TotalSeconds
};
IMigrationProcessor processor;
IDbConnection dbConnection = null;
string connectionString;
if (!string.IsNullOrEmpty(configuration.Database.ConnectionString))
{
connectionString = configuration.Database.ConnectionString;
}
else if (!string.IsNullOrEmpty(configuration.Database.ConnectionStringName))
{
connectionString = ConfigurationManager.ConnectionStrings[configuration.Database.ConnectionStringName].ConnectionString;
}
else
{
throw new ConfigurationErrorsException("Missing connection string.");
}
if (databaseType == DatabaseType.SqlAzure || databaseType == DatabaseType.SqlServer)
{
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
processor = factory.Create(connectionString, announcer, options);
dbConnection = ((SqlServerProcessor)processor).Connection;
}
else if (databaseType == DatabaseType.PostgreSQL)
{
var factory = new FluentMigrator.Runner.Processors.Postgres.PostgresProcessorFactory();
processor = factory.Create(connectionString, announcer, options);
dbConnection = ((PostgresProcessor)processor).Connection;
}
else if (databaseType == DatabaseType.Oracle)
{
var factory = new FluentMigrator.Runner.Processors.Oracle.OracleProcessorFactory();
processor = factory.Create(connectionString, announcer, options);
dbConnection = ((OracleProcessor)processor).Connection;
}
else
{
throw new NotSupportedException(string.Format("Database type {0} is not supported for data migrations.", databaseType));
}
var runner = new MigrationRunner(assembly, migrationContext, processor);
if (version != null)
{
runner.MigrateUp(version.Value);
}
else
{
throw new NotSupportedException("Migrations without target version are not supported.");
}
// If connection is still opened, close it.
if (dbConnection != null && dbConnection.State != ConnectionState.Closed)
{
dbConnection.Close();
}
}
public void CanAutoReverseAVersionDown()
{
ExecuteWithSupportedProcessors(processor =>
{
Assembly asm = typeof(MigrationRunnerTests).Assembly;
var runnerContext = new RunnerContext(new TextWriterAnnouncer(System.Console.Out));
runnerContext.Namespace = "FluentMigrator.Tests.Integration.Migrations";
runnerContext.AutoReverse = true;
var runner = new MigrationRunner(asm, runnerContext, processor);
runner.MigrateUp(1);
runner.VersionLoader.VersionInfo.HasAppliedMigration(1).ShouldBeTrue();
processor.TableExists("Users").ShouldBeTrue();
runner.MigrateDown(1);
runner.VersionLoader.VersionInfo.HasAppliedMigration(1).ShouldBeFalse();
processor.TableExists("Users").ShouldBeFalse();
});
}
