protected static void ExecuteWithMySql(Action <IMigrationProcessor> test, IntegrationTestOptions.DatabaseServerOptions serverOptions)
{
if (!serverOptions.IsEnabled)
{
return;
}
var announcer = new TextWriterAnnouncer(System.Console.Out);
announcer.Heading("Testing Migration against MySQL Server");
using (var connection = new MySqlConnection(serverOptions.ConnectionString))
{
var processor = new MySqlProcessor(connection, new MySqlGenerator(), announcer, new ProcessorOptions(), new MySqlDbFactory());
test(processor);
}
}
public static void Down(string connectionString)
{
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer);
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 60, ProviderSwitches = string.Empty
};
var factory = new PostgresProcessorFactory();
using (var processor = factory.Create(connectionString, announcer, options))
{
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateDown(0);
}
}
public void AlterTable_MigrationRequiresAutomaticDelete_AndProcessorHasUndoDisabled_ShouldNotThrow()
{
using (var tempDb = new TemporaryDatabase(IntegrationTestOptions.Firebird, _firebirdLibraryProber))
{
var connectionString = tempDb.ConnectionString;
var runnerContext = new RunnerContext(new TextWriterAnnouncer(TestContext.Out))
{
Namespace = "FluentMigrator.Tests.Integration.Migrations"
};
using (var connection = new FbConnection(connectionString))
{
FirebirdProcessor processor;
var announcer = new TextWriterAnnouncer(TestContext.Out);
announcer.ShowSql = true;
var options = FirebirdOptions.AutoCommitBehaviour();
options.TruncateLongNames = false;
processor = new FirebirdProcessor(connection, new FirebirdGenerator(options), announcer,
new ProcessorOptions(), new FirebirdDbFactory(), options);
var runner = new MigrationRunner(Assembly.GetExecutingAssembly(), runnerContext, processor);
runner.Up(new MigrationWhichCreatesTwoRelatedTables());
processor.CommitTransaction();
FbConnection.ClearPool(connection);
}
//---------------Assert Precondition----------------
Assert.IsTrue(ForeignKeyExists(connectionString, MigrationWhichCreatesTwoRelatedTables.ForeignKeyName),
"Foreign key does not exist after first migration");
using (var connection = new FbConnection(connectionString))
{
FirebirdProcessor processor;
var announcer = new TextWriterAnnouncer(TestContext.Out);
announcer.ShowSql = true;
var options = FirebirdOptions.AutoCommitBehaviour();
processor = new FirebirdProcessor(connection, new FirebirdGenerator(options), announcer,
new ProcessorOptions(), new FirebirdDbFactory(), options);
var runner = new MigrationRunner(Assembly.GetExecutingAssembly(), runnerContext, processor);
runner.Up(new MigrationWhichAltersTableWithFK());
processor.CommitTransaction();
}
Assert.IsTrue(ForeignKeyExists(connectionString, MigrationWhichCreatesTwoRelatedTables.ForeignKeyName),
"Foreign key does not exist after second migration");
}
}
private void ExecuteMigrations(string outputTo)
{
using (var sw = new StreamWriter(outputTo))
{
var fileAnnouncer = new TextWriterAnnouncer(sw)
{
ShowElapsedTime = false,
ShowSql = true
};
consoleAnnouncer.ShowElapsedTime = Verbose;
consoleAnnouncer.ShowSql = Verbose;
var announcer = new CompositeAnnouncer(consoleAnnouncer, fileAnnouncer);
ExecuteMigrations(announcer);
}
}
protected override Result <MigrationResult> ExecuteCore(Session session, MigrationContract contract)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
var announcer = new TextWriterAnnouncer(Logger.Debug);
var migrationContext = new RunnerContext(announcer)
{
NestedNamespaces = true
};
var factoryProvider = new MigrationProcessorFactoryProvider();
var factory = factoryProvider.GetFactory(contract.DatabaseType);
var migrationOptions = new ProcessorOptions
{
PreviewOnly = false,
ProviderSwitches = null,
Timeout = contract.Timeout
};
using (var processor = factory.Create(contract.AdminConnectionString, announcer, migrationOptions))
{
var migrationAssemblies = _migrationAssemblies.Select(x => x.Assembly);
var assemblies = new AssemblyCollection(migrationAssemblies);
var runner = new MigrationRunner(assemblies, migrationContext, processor);
runner.Conventions.TypeIsMigration = IsTypeMigration;
runner.Conventions.GetMigrationInfo = GetPlatformMigrationInfo;
Logger.Info("Start migration");
Logger.Info($"-> Database type: {contract.DatabaseType}");
Logger.Info($"-> Command timeout: {migrationOptions.Timeout}");
Logger.Info($"-> Assemblies to scan: {string.Join("; ", assemblies.Assemblies.Select(x => x.GetName().Name))}");
runner.MigrateUp(true);
}
var migrationResult = new MigrationResult(_migrationAssemblies);
return(Success(migrationResult));
}
public void Load()
{
Announcer announcer = new TextWriterAnnouncer(x => Debug.WriteLine(""));
var assembly = Assembly.GetExecutingAssembly();
IRunnerContext ctx = new RunnerContext(announcer);
var options = new ProcessorOptions
{
PreviewOnly = false,
Timeout = 40
};
var factory = new SqlServer2012ProcessorFactory();
string con = WebConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString.ToString();
var processer = factory.Create(con, announcer, options);
var runner = new MigrationRunner(assembly, ctx, processer);
runner.MigrateUp();
}
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 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 = "MyApp.Sql.Migrations"
};
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 60
};
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
protected static void ExecuteWithFirebird(Action <IMigrationProcessor> test, IntegrationTestOptions.DatabaseServerOptions serverOptions)
{
if (!serverOptions.IsEnabled)
{
return;
}
var announcer = new TextWriterAnnouncer(System.Console.Out);
announcer.ShowSql = true;
announcer.Heading("Testing Migration against Firebird Server");
if (!System.IO.File.Exists("fbtest.fdb"))
{
FbConnection.CreateDatabase(serverOptions.ConnectionString);
}
using (var connection = new FbConnection(serverOptions.ConnectionString))
{
var options = FirebirdOptions.AutoCommitBehaviour();
var processor = new FirebirdProcessor(connection, new FirebirdGenerator(options), announcer, new ProcessorOptions(), new PostgresDbFactory(), options);
try
{
test(processor);
}
catch (Exception e)
{
if (!processor.WasCommitted)
{
processor.RollbackTransaction();
}
throw e;
}
if (!processor.WasCommitted)
{
processor.RollbackTransaction();
}
connection.Close();
}
}
public int Run()
{
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s))
{
ShowSql = true
};
IRunnerContext migrationContext = new RunnerContext(announcer)
{
Profile = Constants.MigratorProfileName
};
var processor = new SqlServer2014ProcessorFactory().Create(DatabaseConnectionString, announcer, new ProcessorOptions
{
PreviewOnly = false,
Timeout = _options.TimeoutSeconds
});
var runner = new MigrationRunner(Assembly.GetEntryAssembly(), migrationContext, processor);
try
{
if (_options.GenerateEnums)
{
runner.Up(new EnumTableGenerator());
}
if (_options.MigrationRequest.HasValue)
{
runner.MigrateUp(_options.MigrationRequest.Value, true);
}
else
{
runner.MigrateUp(true);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
return(-1);
}
return(0);
}
public static void MigrateDown(long toVersion, string MigrationNamespace, string connectionString)
{
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = MigrationNamespace
};
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 60
};
var factory = new FluentMigrator.Runner.Processors.Postgres.PostgresProcessorFactory();
using (var processor = factory.Create(connectionString, announcer, options))
{
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateDown(toVersion);
}
}
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");
}
private static MigrationRunner CreateMigrationRunner(string connectionString)
{
var announcer = new TextWriterAnnouncer(s => Debug.WriteLine(s));
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = "Migrator.Migrations"
};
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 60
};
var factory = new SqlServer2008ProcessorFactory();
var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
return(runner);
}
public static string Run()
{
var connectionString = ConfigurationManager.ConnectionStrings["Main"].ConnectionString;
var migrationLog = new StringBuilder();
var announcer = new TextWriterAnnouncer(s => migrationLog.Append(s));
var runnerContext = new RunnerContext(announcer)
{
Database = "sqlserver",
Connection = connectionString,
Targets = new [] { typeof(MigrationsRunner).Assembly.FullName }
};
var taskExecutor = new TaskExecutor(runnerContext);
taskExecutor.Execute();
return(migrationLog.ToString());
}
protected static void ExecuteWithSqlite(Action <IMigrationProcessor> test, IntegrationTestOptions.DatabaseServerOptions serverOptions)
{
if (!serverOptions.IsEnabled)
{
return;
}
var announcer = new TextWriterAnnouncer(System.Console.Out);
announcer.Heading("Testing Migration against SQLite");
var factory = new SqliteDbFactory();
using (var connection = factory.CreateConnection(serverOptions.ConnectionString))
{
var processor = new SqliteProcessor(connection, new SqliteGenerator(), announcer, new ProcessorOptions(), factory);
test(processor);
}
}
public void MigrateToLatest()
{
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Targets = new[] { assembly.FullName }
};
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 60
};
var factory = new FluentMigrator.Runner.Processors.Postgres.PostgresProcessorFactory();
var processor = factory.Create(_connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
private TaskExecutor MakeTask(string task, string migrationsNamespace, Action<RunnerContext> configureContext = null)
{
var consoleAnnouncer = new TextWriterAnnouncer(TestContext.Out)
{
ShowSql = true
};
var debugAnnouncer = new TextWriterAnnouncer(msg => Debug.WriteLine(msg));
var announcer = new CompositeAnnouncer(consoleAnnouncer, debugAnnouncer);
var runnerContext = new RunnerContext(announcer)
{
Database = "SqlServer2016",
Connection = IntegrationTestOptions.SqlServer2016.ConnectionString,
Targets = new[] { Assembly.GetExecutingAssembly().Location },
Namespace = migrationsNamespace,
Task = task
};
configureContext?.Invoke(runnerContext);
return new TaskExecutor(runnerContext);
}
private void Migrate()
{
var connectionString = ConfigFixture.Config.GetConnectionString("DefaultConnection");
var announcer = new TextWriterAnnouncer(Console.WriteLine);
announcer.ShowSql = true;
var assembly = Assembly.Load("Skrabbl.DataAccess");
var migrationContext = new RunnerContext(announcer);
var options = new ProcessorOptions
{
PreviewOnly = false,
Timeout = TimeSpan.FromMinutes(1)
};
var factory = new SqlServer2016ProcessorFactory();
using var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp();
}
public void Initialize()
{
var announcer = new TextWriterAnnouncer(s => FileLogger.Debug(BasePage.LoggerName, s));
var assembly = Assembly.Load("AmministrazioneTrasparente.SQLite");
var migrationContext = new RunnerContext(announcer)
{
Namespace = MIGRATION_NAMESPACE
};
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 60
};
var factory = new FluentMigrator.Runner.Processors.SQLite.SQLiteProcessorFactory();
using (var processor = factory.Create(this._connection, announcer, options))
{
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
}
public static void MigrateToLatest(string connectionString)
{
var announcer = new TextWriterAnnouncer(s => logger.Info(s));
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = "UCLouvain.AmbulanceSystem.Server.Migrations"
};
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 60
};
// var factory = new MonoSQLiteProcessorFactory();
var factory = new PostgresProcessorFactory();
using (var processor = factory.Create(connectionString, announcer, options)) {
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
}
private void Execute()
{
var announcer = new TextWriterAnnouncer(Console.Out)
{
ShowElapsedTime = true, ShowSql = true
};
var runnerContext = new RunnerContext(announcer)
{
Database = _database,
Task = _task,
Connection = _connectionString,
Targets = new[] { _migrationAssembly.CodeBase.Replace("file:///", "") },
Version = _version
};
Trace.TraceInformation("#\n# Executing migration task {0}...\n#\n", _task);
var task = new TaskExecutor(runnerContext);
task.Execute();
Trace.TraceInformation("\n#\n# Task {0} complete!\n#", _task);
}
public void Migrate(Action <IMigrationRunner> runnerAction)
{
//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
};
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 0
};
var factory = new SqlServer2008ProcessorFactory();
var assembly = Assembly.GetExecutingAssembly();
var processor = factory.Create(_connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runnerAction(runner);
}
public void MigrateToLatest()
{
var announcer = new TextWriterAnnouncer(s => Debug.WriteLine(s));
var migrationContext = new RunnerContext(announcer)
{
Namespace = Namespace
};
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 60
};
var factory = new PostgresProcessorFactory();
using (var processor = factory.Create(ConnectionString, announcer, options))
{
var runner = new MigrationRunner(Assembly, migrationContext, processor);
runner.MigrateUp(true);
}
}
private void Migrate(TextWriter writer, bool previewOnly, bool rollback, long?version = null, string connectionString = null)
{
string cs;
long highestMigration;
string task, database;
using (var con = string.IsNullOrEmpty(connectionString) ? Database.OpenDbConnection() : OpenConnection(connectionString))
{
database = DialectToDatabaseString(con.GetDialectProvider());
cs = con.ConnectionString;
highestMigration = con.TableExists("VersionInfo") ? con.Scalar <long>("SELECT MAX(Version) from VersionInfo") : -1;
}
if (rollback)
{
task = version.HasValue ? "rollback:toversion" : "rollback";
}
else
{
task = !version.HasValue || version.Value >= highestMigration ? "migrate:up" : "migrate:down";
}
var announcer = new TextWriterAnnouncer(writer)
{
ShowElapsedTime = true,
ShowSql = true,
};
var context = new RunnerContext(announcer)
{
Database = database,
Connection = cs,
Targets = new[] { Assembly.Location },
PreviewOnly = previewOnly,
Task = task,
Version = version ?? 0,
};
new TaskExecutor(context).Execute();
}
public void MigrateToLatest(string connectionString)
{
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = "DriveHUD.Application.MigrationService.Migrations"
};
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 60
};
var factory = GetProcessorFactory();
using (var processor = factory.Create(connectionString, announcer, options))
{
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
}
public virtual void Migrate(string connectionString, Assembly assembly = null)
{
if (_databaseType == "sqlite")
{
CopyInteropAssemblyByPlatform();
}
assembly = assembly ?? Assembly.GetExecutingAssembly();
var announcer = new TextWriterAnnouncer(Console.Out)
{
ShowSql = true, ShowElapsedTime = false
};
var context = new RunnerContext(announcer)
{
Connection = connectionString,
Database = _databaseType,
Target = assembly.FullName,
Profile = "linger",
};
var executor = new TaskExecutor(context);
executor.Execute();
}
public static void MigrateToLatest(string connectionString, Type sourceNamespace)
{
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var assembly = Assembly.GetAssembly(sourceNamespace);
var migrationContext = new RunnerContext(announcer)
{
Namespace = sourceNamespace.Namespace
};
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 60
};
var factory =
new FluentMigrator.Runner.Processors.SqlServer.SqlServer2014ProcessorFactory();
using (var processor = factory.Create(connectionString, announcer, options))
{
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
}
protected static void ExecuteWithSqlServer(Action <IMigrationProcessor> test, IntegrationTestOptions.DatabaseServerOptions serverOptions, Boolean tryRollback)
{
if (!serverOptions.IsEnabled)
{
return;
}
var announcer = new TextWriterAnnouncer(System.Console.Out);
announcer.Heading("Testing Migration against MS SQL Server");
using (var connection = new SqlConnection(serverOptions.ConnectionString))
{
var processor = new SqlServerProcessor(connection, new SqlServer2000Generator(), announcer, new ProcessorOptions());
test(processor);
if (tryRollback && !processor.WasCommitted)
{
processor.RollbackTransaction();
}
}
}
private static void Execute(Assembly assembly, string task, string databaseType, string connectionString)
{
const bool verbose = true;
var consoleAnnouncer = new TextWriterAnnouncer(Console.Out)
{
ShowElapsedTime = verbose,
ShowSql = verbose
};
var runnerContext = new RunnerContext(consoleAnnouncer)
{
Database = databaseType,
Connection = connectionString,
Timeout = 90,
Target = assembly.Location,
Task = task
};
var taskExecutor = new TaskExecutor(runnerContext);
taskExecutor.Execute();
}
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 (MySqlException e)
{
_logger.Error("An exception occured while running migration manager. Please ensure your mysql settings are correct; {0:l}", e.Message);
}
}
