protected virtual void Initialize()
{
var assembly = AssemblyLoaderFactory.GetAssemblyLoader(RunnerContext.Target).Load();
var connectionString = LoadConnectionString(assembly.Location);
var processor = InitializeProcessor(assembly.Location, connectionString);
Runner = new MigrationRunner(assembly, RunnerContext, processor);
}
public void Can_Find_Targetted_Migrations()
{
var db = GetConfiguredDatabase();
//Create db schema and data from old Total.sql file for Sql Ce
string statements = GetDatabaseSpecificSqlScript();
// replace block comments by whitespace
statements = FindComments.Replace(statements, " ");
// execute all non-empty statements
foreach (string statement in statements.Split(";".ToCharArray()))
{
string rawStatement = statement.Replace("GO", "").Trim();
if (rawStatement.Length > 0)
{
db.Execute(new Sql(rawStatement));
}
}
var configuredVersion = new SemVersion(4, 8, 0);
var targetVersion = new SemVersion(6, 0, 0);
var foundMigrations = MigrationResolver.Current.Migrations;
var migrationRunner = new MigrationRunner(
Mock.Of <IMigrationEntryService>(),
Logger, configuredVersion, targetVersion, Constants.System.UmbracoMigrationName);
var migrations = migrationRunner.OrderedUpgradeMigrations(foundMigrations).ToList();
var context = new MigrationContext(DatabaseProviders.SqlServerCE, db, Logger);
foreach (var migration1 in migrations)
{
var migration = (MigrationBase)migration1;
migration.GetUpExpressions(context);
}
foreach (var expression in context.Expressions)
{
Debug.Print(expression.ToString());
}
Assert.That(migrations.Count(), Is.EqualTo(12));
}
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 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);
try
{
var runner = new MigrationRunner(assembly, runnerContext, processor);
if (migrationContext.DesiredVersion.HasValue)
{
runner.MigrateUp(migrationContext.DesiredVersion.Value, true);
}
else
{
runner.MigrateUp(true);
}
}
catch (SQLiteException)
{
processor.Dispose();
SQLiteConnection.ClearAllPools();
throw;
}
sw.Stop();
_announcer.ElapsedTime(sw.Elapsed);
}
public void WhenRunningMigrationFromSettings()
{
_versionValidator = new Mock <IVersionValidator>();
_versionValidator
.Setup(v => v.Validate(It.IsAny <ISimpleMigrator>(), It.IsAny <Settings>()))
.Returns(VersionValidation.Valid);
_noOpProcess = new Mock <INoOpProcess>();
_settings = new Settings("connection", 1, Mode.NoOp, "test.dll");
_migrator = new Mock <ISimpleMigrator>();
_versionOutputHelper = new Mock <IVersionOutputHelper>();
var runner = new MigrationRunner(_migrator.Object, _versionValidator.Object, _noOpProcess.Object, null, _versionOutputHelper.Object);
_result = runner.Execute(_settings);
}
public void WhenRunningMigrationFromSettings()
{
_versionValidator = new Mock <IVersionValidator>();
_versionValidator
.Setup(v => v.Validate(It.IsAny <ISimpleMigrator>(), It.IsAny <Settings>()))
.Returns(VersionValidation.TargetVersionIsSameAsCurrent);
_applyProcess = new Mock <IApplyProcess>();
_noOpProcess = new Mock <INoOpProcess>();
_migrator = new Mock <ISimpleMigrator>();
_settings = new Settings("connection", 100, Mode.Apply, "assembly");
_versionOutputHelper = new Mock <IVersionOutputHelper>();
var runner = new MigrationRunner(_migrator.Object, _versionValidator.Object, _noOpProcess.Object, _applyProcess.Object, _versionOutputHelper.Object);
_result = runner.Execute(_settings);
}
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);
}
protected override void AfterMigration(MigrationRunner sender, MigrationEventArgs e)
{
var target70 = new Version(7, 0, 0);
if (e.ConfiguredVersion <= target70)
{
//This query is structured to work with MySql, SQLCE and SqlServer:
// http://issues.umbraco.org/issue/U4-3876
var sql = @"DELETE FROM cmsContentXml WHERE nodeId IN
(SELECT nodeId FROM (SELECT DISTINCT cmsContentXml.nodeId FROM cmsContentXml
INNER JOIN umbracoNode ON cmsContentXml.nodeId = umbracoNode.id
WHERE nodeObjectType = '" + Constants.ObjectTypes.Media + "' AND " + SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName("path") + " LIKE '%-21%') x)";
var count = e.MigrationContext.Database.Execute(sql);
LogHelper.Info <ClearMediaXmlCacheForDeletedItemsAfterUpgrade>("Cleared " + count + " items from the media xml cache that were trashed and not meant to be there");
}
}
public async Task RunMigration_Works()
{
await DropMigrationInfoTable();
await PrepareCounterTable(new List <Counter> {
new Counter {
Id = 999, CounterValue = 12
}
});
var db = GetDb();
var services = new ServiceCollection();
var provider = new PostgreSqlConnectionProvider();
provider.Add("yolo", db, true);
var runner = new MigrationRunner(
new LoggerFactory().CreateLogger <MigrationRunner>(),
new ServiceProviderRapidContainerAdapter(services.BuildServiceProvider()),
new MigrationEnvironment("staging"),
A.Fake <IDistributedAppLockProvider>(),
new PostgreSqlMigrationContextFactory(provider),
new ReflectionMigrationFinder(new List <Assembly> {
typeof(MigrationTests).GetAssembly()
}),
new PostgreSqlMigrationStorage()
);
await runner.UpgradeAsync();
// assert all migrations are marked as complete
var migrationInfos = await GetAllMigrationInfo();
Assert.Contains(migrationInfos, x => x.Name == nameof(Migration01) && x.MigrationCompleted);
Assert.Contains(migrationInfos, x => x.Name == nameof(Migration02) && x.MigrationCompleted);
// check the state of the db
var counter999 = await db.QuerySingleAsync <Counter>("select * from __Counter where Id = 999");
Assert.Equal("sample default value", counter999.Description);
await DropCounterTable();
}
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[] { "users-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();
}
}
}
public void Setup()
{
timeoutsSource = new FakeTimeoutsSource();
timeoutsTarget = new FakeTimeoutTarget();
logger = new ConsoleLogger(false);
runner = new MigrationRunner(logger, timeoutsSource, timeoutsTarget);
endpoints = new List <EndpointInfo>
{
new EndpointInfo
{
EndpointName = "Sales",
NrOfTimeouts = 500
}
};
testEndpoint = endpoints.First().EndpointName;
timeoutsSource.SetupEndpoints(endpoints);
}
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);
}
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 async Task Setup()
{
foreach (var dbProvider in DbProviders())
{
Trace.WriteLine(TraceObjectGraphInfo(dbProvider));
var migrationRunner = new MigrationRunner(dbProvider);
// drop the database before running the tests again
await migrationRunner.DropDatabase();
await migrationRunner.RunAll(SystemRole.Server, new List <IDbMigration>
{
new Migration001(),
new Migration002(),
new Migration003(),
new Migration004()
});
}
}
public static void MigrateToLatest(string connectionString)
{
//using (var announcer = new NullAnnouncer())
using (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);
}
}
public void RollbackAllShouldRemoveVersionInfoTable()
{
ExecuteWithSupportedProcessors(processor =>
{
MigrationRunner runner = SetupMigrationRunner(processor);
runner.MigrateUp(2);
processor.TableExists(runner.VersionLoader.VersionTableMetaData.SchemaName, runner.VersionLoader.VersionTableMetaData.TableName).ShouldBeTrue();
});
ExecuteWithSupportedProcessors(processor =>
{
MigrationRunner runner = SetupMigrationRunner(processor);
runner.RollbackToVersion(0);
processor.TableExists(runner.VersionLoader.VersionTableMetaData.SchemaName, runner.VersionLoader.VersionTableMetaData.TableName).ShouldBeFalse();
});
}
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");
}
public static void EnsureLatest(string connectionString, string databaseName)
{
if (_isUpdating)
{
return;
}
_isUpdating = true;
try {
var runner = new MigrationRunner(connectionString, databaseName);
runner.MigrationLocator.LookForMigrationsInAssemblyOfType <EventRepository>();
runner.UpdateToLatest();
} catch (Exception ex) {
Log.Error().Exception(ex).Message("Error ensuring latest db version: {0}", ex.Message).Report().Write();
} finally {
_isUpdating = false;
}
}
/// <summary>
/// 激活外壳完成后执行。
/// </summary>
public void Activated()
{
Logger.Information("准备对租户 {0} 进行数据迁移...", _shellSettings.Name);
var dataProviderName = _shellSettings.GetDataProvider();
var connectionString = _shellSettings.GetDataConnectionString();
if (string.IsNullOrWhiteSpace(connectionString))
{
Logger.Warning(string.Format("未对租户 {0} 进行数据迁移，因为没有配置数据服务提供程序。", _shellSettings.Name));
return;
}
if (string.IsNullOrWhiteSpace(dataProviderName))
{
Logger.Warning(string.Format("未对租户 {0} 进行数据迁移，因为没有配置数据连接字符串。", _shellSettings.Name));
return;
}
var provider = _dataServicesProviders.SingleOrDefault(i => i.ProviderName.Equals(dataProviderName));
if (provider == null)
{
Logger.Debug(string.Format("未对租户 {0} 进行数据迁移，因为根据数据服务提供程序名称 {1}，找不到对应的数据服务提供程序。", _shellSettings.Name, dataProviderName));
return;
}
using (var connection = provider.CreateConnection(connectionString))
{
var context = new RunnerContext(new NullAnnouncer());
var migrationProcessor = provider.CreateMigrationProcessor(context, connection);
using (migrationProcessor)
{
var migrationRunner = new MigrationRunner(GetType().Assembly, context, migrationProcessor)
{
MigrationLoader = new ChunSunMigrationInformationLoader(_migrations, Logger)
};
//迁移。
migrationRunner.MigrateUp(true);
}
}
Logger.Information("完成对租户 {0} 的数据迁移", _shellSettings.Name);
}
private static void RunInLegacyMode(DatabaseConfiguration dbConfig)
{
// Create the announcer to output the migration messages
#pragma warning disable 612
var announcer = new ConsoleAnnouncer()
{
ShowSql = true,
};
#pragma warning restore 612
// Processor specific options (usually none are needed)
var options = new ProcessorOptions()
{
ConnectionString = dbConfig.ConnectionString,
};
// Initialize the DB-specific processor
#pragma warning disable 612
var processor = MigrationProcessorFactoryProvider
.RegisteredFactories.Single(
x => string.Equals(x.Name, dbConfig.ProcessorId, StringComparison.OrdinalIgnoreCase))
.Create(dbConfig.ConnectionString, announcer, options);
#pragma warning restore 612
// Configure the runner
#pragma warning disable 612
var context = new RunnerContext(announcer)
{
AllowBreakingChange = true,
};
#pragma warning restore 612
// Create the migration runner
#pragma warning disable 612
var runner = new MigrationRunner(
typeof(AddGTDTables).Assembly,
context,
processor);
#pragma warning restore 612
// Run the migrations
runner.MigrateUp();
}
public override void StartTask(ITaskExecutionContext context)
{
StringBuilder stringBuilder;
bool flag = this._loggingDisabler != null;
MigrationDb[] array = this._dbs;
string[] strArrays = (context.Arguments["Names"] ?? string.Empty).Split(new string[] { ",", ";" }, StringSplitOptions.RemoveEmptyEntries);
if (strArrays.Length != 0)
{
ILookup <string, MigrationDb> lookup = ((IEnumerable <MigrationDb>) this._dbs).ToLookup <MigrationDb, string, MigrationDb>((MigrationDb db) => db.IdentifyingName, (MigrationDb db) => db, StringComparer.OrdinalIgnoreCase);
array = strArrays.SelectMany <string, MigrationDb>((string x) => lookup[x]).ToArray <MigrationDb>();
}
string lowerInvariant = (context.Arguments["Action"] ?? string.Empty).ToLowerInvariant();
MigrationDb[] migrationDbArray = array;
for (int i = 0; i < (int)migrationDbArray.Length; i++)
{
MigrationDb migrationDb = migrationDbArray[i];
MigrationRunner migrationRunner = this.CreateRunner(migrationDb, out stringBuilder);
if (lowerInvariant == "list")
{
migrationDb.List(migrationRunner, context, this._kernel);
}
else if (lowerInvariant == "rollback")
{
migrationDb.Rollback(migrationRunner, context, this._kernel);
}
else
{
migrationDb.MigrateUp(migrationRunner, context, this._kernel);
}
migrationRunner.Processor.Dispose();
if (stringBuilder.Length > 0)
{
context.Log.Message(stringBuilder.ToString(), new object[0]);
}
if (flag)
{
this._loggingDisabler.Dispose();
flag = false;
}
}
}
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();
}
}
}
public static void MigrateToLatest(string connectionString)
{
var announcer = new NullAnnouncer();
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = "Bloqs.Logging.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 static void MigrateToLatest(string connectionString)
{
var announcer = new TextWriterAnnouncer(s => Console.WriteLine(s));
var assembly = Assembly.GetExecutingAssembly();
var migrationContext = new RunnerContext(announcer)
{
Namespace = "Katrin.Database.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);
}
/// <summary>
///
/// </summary>
/// <param name="sqlSyntax"></param>
/// <param name="migrationEntryService"></param>
/// <param name="logger"></param>
public void RunMigrations(ISqlSyntaxProvider sqlSyntax, IMigrationEntryService migrationEntryService, ILogger logger)
{
var currentVersion = new SemVersion(0);
var migrations = ApplicationContext.Current.Services.MigrationEntryService
.GetAll(nameof(Shield))
.OrderByDescending(x => x.CreateDate);
var latestMigration = migrations.FirstOrDefault();
if (latestMigration != null)
{
currentVersion = latestMigration.Version;
}
if (TargetVersion == currentVersion)
{
return;
}
IMigration[] scriptsForMigration =
{
currentVersion == new SemVersion(0)
? (IMigration) new Migration103Create(sqlSyntax, logger)
: new Migration103(sqlSyntax, logger),
new Migration107(sqlSyntax, logger)
};
var migrationsRunner = new MigrationRunner(migrationEntryService,
logger,
currentVersion,
TargetVersion,
nameof(Shield),
scriptsForMigration);
try
{
migrationsRunner.Execute(ApplicationContext.Current.DatabaseContext.Database);
}
catch (Exception ex)
{
LogHelper.Error <Migration>("Error running Shield migration", ex);
}
}
public void CanUseCustomVersionInfo()
{
ExecuteWithSupportedProcessors(processor =>
{
var runner = new MigrationRunner(Assembly.GetExecutingAssembly(), new RunnerContext(new TextWriterAnnouncer(TestContext.Out))
{
Namespace = "FluentMigrator.Tests.Integration.Migrations.Interleaved.Pass3"
}, processor);
var tableMetaData = new TestVersionTableMetaData();
//ensure table doesn't exist
if (processor.TableExists(tableMetaData.SchemaName, tableMetaData.TableName))
{
runner.Down(new VersionMigration(tableMetaData));
}
//ensure schema doesn't exist
if (processor.SchemaExists(tableMetaData.SchemaName))
{
runner.Down(new VersionSchemaMigration(tableMetaData));
}
runner.Up(new VersionSchemaMigration(tableMetaData));
processor.SchemaExists(tableMetaData.SchemaName).ShouldBeTrue();
runner.Up(new VersionMigration(tableMetaData));
processor.TableExists(tableMetaData.SchemaName, tableMetaData.TableName).ShouldBeTrue();
runner.Down(new VersionMigration(tableMetaData));
processor.TableExists(tableMetaData.SchemaName, tableMetaData.TableName).ShouldBeFalse();
runner.Down(new VersionSchemaMigration(tableMetaData));
processor.SchemaExists(tableMetaData.SchemaName).ShouldBeFalse();
},
true,
#if NET461
typeof(SqlAnywhereProcessor),
#endif
typeof(SQLiteProcessor), typeof(MySqlProcessor), typeof(FirebirdProcessor));
}
protected virtual void Initialize()
{
List<Assembly> assemblies = new List<Assembly>();
foreach (var target in RunnerContext.Targets)
{
var assembly = AssemblyLoaderFactory.GetAssemblyLoader(target).Load();
if (!assemblies.Contains(assembly))
{
assemblies.Add(assembly);
}
}
var assemblyCollection = new AssemblyCollection(assemblies);
var processor = RunnerContext.NoConnection? InitializeConnectionlessProcessor():InitializeProcessor(assemblyCollection);
Runner = new MigrationRunner(assemblyCollection, RunnerContext, processor);
}
public void Executes_For_Any_Product_Name_When_Not_Specified()
{
var changed1 = new Args {
CountExecuted = 0
};
var testHandler1 = new TestMigrationHandler(changed1);
testHandler1.OnApplicationStarting(Mock.Of <UmbracoApplicationBase>(), new ApplicationContext(CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger(Mock.Of <ILogger>(), Mock.Of <IProfiler>())));
var conn = new Mock <IDbConnection>();
conn.Setup(x => x.BeginTransaction(It.IsAny <IsolationLevel>())).Returns(Mock.Of <IDbTransaction>());
var db = new Mock <Database>(conn.Object);
var runner1 = new MigrationRunner(Mock.Of <IMigrationEntryService>(), Mock.Of <ILogger>(), new SemVersion(1), new SemVersion(2), "Test1",
new IMigration[] { Mock.Of <IMigration>() });
var result1 = runner1.Execute(db.Object, DatabaseProviders.SqlServerCE, false);
Assert.AreEqual(1, changed1.CountExecuted);
}
private static MigrationRunner CreateMigrationRunner(string assemblyName, string connectionString)
{
var probingPath = Path.Combine(Environment.CurrentDirectory, "bin");
var assemblyFiles = Directory.GetFiles(probingPath, $"{assemblyName}*.dll", SearchOption.AllDirectories);
if (assemblyFiles.Length > 1)
{
throw new ApplicationException("Found multiple assemblies! Specify a more restrictive pattern.");
}
var assemblyFile = assemblyFiles.First();
var assembly = Assembly.LoadFile(assemblyFile);
ILogger logger = _loggerFactory.CreateLogger <MigrationRunner>();
var runner = new MigrationRunner(connectionString, assembly, logger);
return(runner);
}
public void Migrate(Assembly assembly, Action <IMigrationRunner> runnerAction)
{
var options = new MigrationOptions {
PreviewOnly = false, Timeout = 0
};
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory();
var announcer = GetAnnouncer();
var migrationContext = new RunnerContext(announcer)
{
Profile = "IntegrationTests",
ApplicationContext = "BaselineSetup"
};
var processor = factory.Create(this.connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runnerAction(runner);
}
protected virtual void Initialize()
{
List <Assembly> assemblies = new List <Assembly>();
foreach (var target in RunnerContext.Targets)
{
var assembly = AssemblyLoaderFactory.GetAssemblyLoader(target).Load();
if (!assemblies.Contains(assembly))
{
assemblies.Add(assembly);
}
}
var assemblyCollection = new AssemblyCollection(assemblies);
var processor = RunnerContext.NoConnection? InitializeConnectionlessProcessor():InitializeProcessor(assemblyCollection);
Runner = new MigrationRunner(assemblyCollection, RunnerContext, processor);
}
private void Initialize()
{
Assembly assembly;
if(string.IsNullOrEmpty(RunnerContext.MigrationDirectory))
{ assembly = AssemblyLoaderFactory.GetAssemblyLoader(RunnerContext.Target).Load(); }
else
{
var migrations = CollateMigrations();
assembly = GenerateMigrationAssembly(migrations);
}
var processor = InitializeProcessor();
Runner = new MigrationRunner(assembly, RunnerContext, processor);
}
private static MigrationRunner BuildMigrationRunner(Assembly migrationAssembly, IRunnerContext runnerContext, IMigrationProcessor processor)
{
var migrationRunner = new MigrationRunner(migrationAssembly, runnerContext, processor);
return migrationRunner;
}
protected virtual void Initialize()
{
var assemblies = new List<MigrationAssemblyInfo>();
var assmNames = RunnerContext.Target.Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var asm in assmNames) {
var assembly = AssemblyLoaderFactory.GetAssemblyLoader(asm).Load();
assemblies.Add(new MigrationAssemblyInfo { Assembly = assembly });
}
var processor = InitializeProcessor(assemblies[0].Assembly.Location);
Runner = new MigrationRunner(assemblies, RunnerContext, processor, true);
}
private void Initialize()
{
var assembly = AssemblyLoaderFactory.GetAssemblyLoader(RunnerContext.Target).Load();
var processor = InitializeProcessor();
Runner = new MigrationRunner(assembly, RunnerContext, processor);
AddSourceControl();
}
