public void StartMigration()
{
var consoleAnnouncer = new TextWriterAnnouncer(System.Console.Out)
{
ShowElapsedTime = true,
ShowSql = true
};
var runnerContext = new RunnerContext(consoleAnnouncer)
{
Database= DataBaseType,
Connection=connStr,
Target=assemblyPath,
PreviewOnly= false,
Namespace=string.Empty,
Task=string.Empty,
Version=0,
Steps=1,
WorkingDirectory = currentPath,
Profile=string.Empty,
Timeout=0,
ConnectionStringConfigPath=string.Empty
};
TaskExecutor tskMigration = new TaskExecutor(runnerContext);
tskMigration.Execute();
}
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;
}
}
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 void Main(string[] args)
{
BuildConfiguration(args);
PrintLogo();
var csName = Configuration["cs"];
var runnerContext = new RunnerContext(new ConsoleAnnouncer())
{
Database = "SqlServer",
Connection = Configuration[$"Data:{csName}:ConnectionString"],
Targets = new string[] { Configuration["target"] },
PreviewOnly = false,
NestedNamespaces = true,
Task = "migrate",
StartVersion = 0,
NoConnection = false,
Steps = 1,
WorkingDirectory = ".",
TransactionPerSession = true
};
new TaskExecutor(runnerContext).Execute();
Console.ReadLine();
}
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);
}
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 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);
}
}
/// <summary>
/// Migrates the specified file name and path.
/// <remarks>This method is called directly when performing integration tests.</remarks>
/// </summary>
/// <param name="fileNameAndPath">The file name and path.</param>
/// <param name="withBackup">if set to <c>true</c> [with backup].</param>
/// <param name="withAnnouncer">if set to <c>true</c> [with announcer].</param>
public static void Migrate(string fileNameAndPath, bool withBackup = false, bool withAnnouncer = false)
{
var currentDb = new FileInfo(fileNameAndPath);
var backupDb = string.Empty;
if (withBackup) { Backup(currentDb); }
var emptyAnnouncers = new Announcer[] { };
var consoleAnnouncer = new Announcer[] { new ConsoleAnnouncer() };
var announcerToProvide = new CompositeAnnouncer(withAnnouncer ? consoleAnnouncer : emptyAnnouncers);
var ctx = new RunnerContext(announcerToProvide)
{
ApplicationContext = string.Empty,
Database = "sqlite",
Connection = string.Format(CONNECTION_STRING_FORMAT, fileNameAndPath).NormalizePathSeparator(),
Targets = new[] { "Drey.Configuration" }
};
try
{
var executor = new TaskExecutor(ctx);
executor.Execute();
}
catch (Exception)
{
if (withBackup)
{
currentDb.Delete();
if (!string.IsNullOrWhiteSpace(backupDb)) { File.Copy(backupDb, currentDb.FullName); }
}
throw;
}
}
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();
}
}
private RunnerContext GetMigrationContext(long version, string profile)
{
var context = new RunnerContext(Announcer);
if (version > -1)
context.Version = version;
if (!string.IsNullOrEmpty(profile))
context.Profile = profile;
return context;
}
private static MigrationRunner GetRunner(string connectionString, IMigrationProcessorFactory factory)
{
var announcer = new NullAnnouncer();
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer) { Namespace = "Migrations" };
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
var processor = factory.Create(connectionString, announcer, options);
return new MigrationRunner(assembly, migrationContext, processor);
}
public void Migrate(Action<IMigrationRunner> runnerAction)
{
var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 };
var factory = new FluentMigrator.Runner.Processors.MigrationProcessorFactoryProvider().GetFactory(_dbType);
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var migrationContext = new RunnerContext(announcer);
var processor = factory.Create(_connectionString, announcer, options);
var runner = new MigrationRunner(_migrationAssembly, migrationContext, processor);
runnerAction(runner);
}
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);
}
/// <summary>
/// Runs the migration
/// </summary>
public virtual void Run()
{
using (var connection = new SqlConnection(_connectionString))
{
var context = new RunnerContext(Announcer);
var processor = GenerateProcessor(connection);
var runner = GenerateRunner(context, processor);
runner.MigrateUp();
}
}
public static void Run()
{
ConnectionStringSettings connectionString = ConfigurationManager.ConnectionStrings["BeerConf"];
var runnerContext = new RunnerContext(new NullAnnouncer())
{
Database = "sqlserver",
Connection = connectionString.ConnectionString,
Target = typeof(MigrationsRunner).Assembly.FullName,
};
new TaskExecutor(runnerContext).Execute();
}
public void Migrate(Action<IMigrationRunner> runnerAction)
{
var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 };
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
var assembly = Assembly.GetExecutingAssembly();
var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
var migrationContext = new RunnerContext(announcer);
var processor = factory.Create(this._connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runnerAction(runner);
}
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 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 MigrateToLatestVersion(string connectionString)
{
var migrationContext = new RunnerContext(new Log4NetAnnouncer())
{
Connection = connectionString,
Database = DefaultProvider,
Target = typeof(Migrate).Assembly.GetName().Name
};
var executor = new TaskExecutor(migrationContext);
executor.Execute();
}
private MigrationRunner CreateMigrationRunner()
{
var processor = GetMigrationProcessor();
var migrationContext = new RunnerContext(Announcer)
{
Namespace = NamespaceContainingMigrations,
TransactionPerSession = true,
};
return new MigrationRunner(AssemblyContainingMigrations, migrationContext, processor);
}
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();
}
protected TaskExecutor MakeTask(string task, string migrationsNamespace)
{
var announcer = new TextWriterAnnouncer(System.Console.Out);
var runnerContext = new RunnerContext(announcer)
{
Database = "Firebird",
Connection = IntegrationTestOptions.Firebird.ConnectionString,
Targets = new[] { Assembly.GetExecutingAssembly().Location },
Namespace = migrationsNamespace,
Task = task
};
return new TaskExecutor(runnerContext);
}
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 Migrator(string connectionString, params Assembly[] assemblies)
{
var announcer = new TextWriterAnnouncer(Console.Write);
IAssemblyCollection assemblyCollection = new AssemblyCollection(assemblies);
var migrationContext = new RunnerContext(announcer);
var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
PostgresProcessorFactory factory = new PostgresProcessorFactory();
IMigrationProcessor processor = factory.Create(connectionString, announcer, options);
runner = new MigrationRunner(assemblyCollection, migrationContext, processor);
}
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 MigrateSchema()
{
log.Debug("Applying any required schema updates");
var announcer = new MigrationAnnoucer(message => log.Debug(message), message => log.Error(message));
var runner = new RunnerContext(announcer)
{
Database = "SqlServer",
Connection = SessionProvider.ConnectionSettings.ConnectionString,
Target =
Path.Combine(AppDomain.CurrentDomain.SetupInformation.PrivateBinPath,
Assembly.GetExecutingAssembly().GetName().Name + ".dll")
};
new TaskExecutor(runner).Execute();
}
private void Execute(string task)
{
tbAnnouncer.Clear();
var version = (int)numVersion.Value;
var steps = (int)numSteps.Value;
var tags = new List<string>();
var profile = tbProfile.Text;
foreach (var item in lbTags.SelectedItems)
{
tags.Add(item.ToString());
}
var announcer = new TextWriterAnnouncer(new TextBoxStreamWriter(tbAnnouncer));
announcer.Heading("Migrate database");
var runnerContext = new RunnerContext(announcer)
{
Database = "SqlServer2008",
Connection = ConfigurationManager.ConnectionStrings["FluentMigrator"].ConnectionString,
Target = "DatabaseProject.dll",
PreviewOnly = false,
Namespace = "DatabaseProject",
NestedNamespaces = true,
Task = task,
Version = version,
Steps = steps,
Tags = tags,
//WorkingDirectory = "C:\\temp",
Profile = profile,
Timeout = 30,
TransactionPerSession = true
};
var executor = new TaskExecutor(runnerContext);
try
{
executor.Execute();
}
catch (Exception ex)
{
tbAnnouncer.AppendText("Exception: " + ex.Message);
}
}
public static bool MigrateDatabase(string databaseType, string connectionString)
{
try {
RunnerContext runnerContext = new RunnerContext(new TextWriterAnnouncer(Console.Out)) {
Database = databaseType,
Connection = connectionString,
Targets = new[] { typeof(DatabaseMigrationRunner).Assembly.Location },
};
new TaskExecutor(runnerContext).Execute();
} catch {
return false;
}
return true;
}
private void Execute()
{
var runnerContext = new RunnerContext(GetAnnouncer())
{
Database = database,
Task = task,
Connection = connectionString,
Target = migrationAssembly.CodeBase.Replace("file:///", string.Empty),
Version = version
};
Trace.TraceInformation("#\n# Executing migration task {0}...\n#\n", task);
var localTask = new TaskExecutor(runnerContext);
localTask.Execute();
Trace.TraceInformation("\n#\n# Task {0} complete!\n#", task);
}
