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 SetUp()
{
factory = new OracleProcessorFactory();
connectionString = "Data Source=localhost/XE;User Id=Something;Password=Something";
announcer = new NullAnnouncer();
options = new ProcessorOptions();
}
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 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();
}
}
protected void SetUp(IMigrationProcessorFactory processorFactory)
{
this.factory = processorFactory;
this.connectionString = "Data Source=localhost/XE;User Id=Something;Password=Something";
this.announcer = new NullAnnouncer();
this.options = new ProcessorOptions();
}
/// <summary>
/// Migration runner
/// </summary>
/// <param name="connectionString">Database connection string</param>
/// <param name="assembly">Assembly containing the migration classes to run</param>
public Runner(string connectionString, Assembly assembly)
{
_connectionString = connectionString;
_assembly = assembly;
Announcer = new NullAnnouncer();
Options = new ProcessorOptions();
MigrationGenerator = new SqlServer2008Generator();
}
protected ProcessorBase(
[NotNull] IMigrationGenerator generator,
[NotNull] IAnnouncer announcer,
[NotNull] ProcessorOptions options)
{
Generator = generator;
Announcer = announcer;
Options = options;
_legacyOptions = options;
Logger = new AnnouncerFluentMigratorLogger(announcer);
}
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();
}
private static IMigrationProcessor BuildMigrationProcessor(string database, string connection, int timeout, IAnnouncer announcer, bool previewOnly)
{
var processorFactoryProvider = new MigrationProcessorFactoryProvider();
var processorFactory = processorFactoryProvider.GetFactory(database);
var processorOptions = new ProcessorOptions
{
Timeout = timeout,
PreviewOnly = previewOnly
};
var processor = processorFactory.Create(connection, announcer, processorOptions);
return processor;
}
protected ProcessorBase(
[NotNull] IMigrationGenerator generator,
[NotNull] ILogger logger,
[NotNull] ProcessorOptions options)
{
Generator = generator;
Options = options;
Logger = logger;
#pragma warning disable 612
Announcer = new LoggerAnnouncer(
logger,
new AnnouncerOptions()
{
ShowSql = true,
ShowElapsedTime = true,
});
_legacyOptions = options;
#pragma warning restore 612
}
public static void MigrateDown(string connectionString, long version, Stream stream, bool previewOnly)
{
if (version == 0)
{
Console.WriteLine(string.Format("Purging Database"));
Honcho.Migrations.DatabasePurge.Migrate.Execute(connectionString);
Console.WriteLine(string.Format("Database Purge Complete"));
}
else
{
Console.WriteLine(string.Format("Executing Migration Rollback Scripts."));
using (var connection = new SqlConnection(connectionString))
{
IAnnouncer announcer = new NullAnnouncer(); // TextWriterAnnouncer(Console.Out);
var processorOptions = new ProcessorOptions
{
PreviewOnly = previewOnly
};
if (stream != null)
{
announcer = new TextWriterAnnouncer(new StreamWriter(stream));
}
var runnerContext = new RunnerContext(announcer);
var processor = new SqlServerProcessor(connection, new SqlServer2008Generator(), announcer,
processorOptions);
var runner = new MigrationRunner(Assembly.GetAssembly(typeof (Runner)), runnerContext,
processor);
runner.RollbackToVersion(version);
}
Console.WriteLine(string.Format("Migration Rollback Script Execution Complete"));
}
}
protected GenericProcessorBase(
[CanBeNull] Func <DbProviderFactory> factoryAccessor,
[NotNull] IMigrationGenerator generator,
[NotNull] ILogger logger,
[NotNull] ProcessorOptions options,
[NotNull] IConnectionStringAccessor connectionStringAccessor)
: base(generator, logger, options)
{
_dbProviderFactory = new Lazy <DbProviderFactory>(() => factoryAccessor?.Invoke());
var connectionString = connectionStringAccessor.ConnectionString;
#pragma warning disable 612
var legacyFactory = new DbFactoryWrapper(this);
// Prefetch connectionstring as after opening the security info could no longer be present
// for instance on sql server
_connectionString = connectionString;
Factory = legacyFactory;
#pragma warning restore 612
_lazyConnection = new Lazy <IDbConnection>(
() =>
{
if (DbProviderFactory == null)
{
return(null);
}
var connection = DbProviderFactory.CreateConnection();
Debug.Assert(connection != null, nameof(Connection) + " != null");
connection.ConnectionString = connectionString;
connection.Open();
return(connection);
});
}
private MigrationRunner MigrationRunner()
{
IAnnouncer announcer = new NullAnnouncer();
IRunnerContext context = new RunnerContext(announcer);
IMigrationProcessorFactory processorFactory = new SqlServer2008ProcessorFactory();
IMigrationProcessorOptions options = new ProcessorOptions { PreviewOnly = false, Timeout = 0 };
IMigrationProcessor processor = processorFactory.Create(DatabaseConnectionString, announcer, options);
return new MigrationRunner(Assembly.GetExecutingAssembly(), context, processor);
}
public static void MigrateUp(string connectionString, long? version, Stream stream, bool previewOnly)
{
if (Migrate.Exists(connectionString))
{
Console.WriteLine(string.Format("AspNet Membership Exists. No Action Needed."));
}
else
{
Console.WriteLine(string.Format("Installing AspNet Membership"));
Migrate.InstallIfDoesNotExist(connectionString);
Console.WriteLine(string.Format("AspNet Membership Install Complete"));
}
Console.WriteLine(string.Format("Executing Migration Scripts."));
using (var connection = new SqlConnection(connectionString))
{
IAnnouncer announcer = new NullAnnouncer(); // TextWriterAnnouncer(Console.Out);
var processorOptions = new ProcessorOptions
{
PreviewOnly = previewOnly
};
if (stream != null)
{
announcer = new TextWriterAnnouncer(new StreamWriter(stream));
}
var runnerContext = new RunnerContext(announcer);
var processor = new SqlServerProcessor(connection, new SqlServer2008Generator(), announcer, processorOptions);
var runner = new MigrationRunner(Assembly.GetAssembly(typeof(Runner)), runnerContext, processor);
if (version.HasValue)
runner.MigrateUp(version.Value);
else
runner.MigrateUp();
}
Console.WriteLine(string.Format("Migration Script Execution Complete"));
}
/// <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();
}
}
private IMigrationProcessor InitializeConnectionlessProcessor()
{
var options = new ProcessorOptions
{
PreviewOnly = RunnerContext.PreviewOnly,
Timeout = RunnerContext.Timeout,
ProviderSwitches = RunnerContext.ProviderSwitches
};
var generator = new MigrationGeneratorFactory().GetGenerator(RunnerContext.Database);
var processor = new ConnectionlessProcessor(generator, RunnerContext, options);
return processor;
}
public void SetUp()
{
var options = new ProcessorOptions
{
PreviewOnly = true
};
_processor = new Mock<IMigrationProcessor>();
_processor.SetupGet(x => x.Options).Returns(options);
_announcer = new Mock<IAnnouncer>();
_stopWatch = new Mock<IStopWatch>();
_runner = new MigrationRunner(new MigrationConventions(), _processor.Object, _announcer.Object, _stopWatch.Object);
}
public void SetUp()
{
_runnerContextMock = new Mock<IRunnerContext>(MockBehavior.Loose);
_conventionMock = new Mock<IMigrationConventions>(MockBehavior.Loose);
_processorMock = new Mock<IMigrationProcessor>(MockBehavior.Loose);
_migrationLoaderMock = new Mock<IMigrationLoader>(MockBehavior.Loose);
_profileLoaderMock = new Mock<IProfileLoader>(MockBehavior.Loose);
_announcer = new Mock<IAnnouncer>();
_stopWatch = new Mock<IStopWatch>();
var options = new ProcessorOptions
{
PreviewOnly = true
};
_processorMock.SetupGet(x => x.Options).Returns(options);
_runnerContextMock.SetupGet(x => x.Namespace).Returns("FluentMigrator.Tests.Integration.Migrations");
_runnerContextMock.SetupGet(x => x.Announcer).Returns(_announcer.Object);
_runnerContextMock.SetupGet(x => x.StopWatch).Returns(_stopWatch.Object);
_runnerContextMock.SetupGet(x => x.Target).Returns(Assembly.GetExecutingAssembly().ToString());
_runnerContextMock.SetupGet(x => x.Connection).Returns(IntegrationTestOptions.SqlServer.ConnectionString);
_runnerContextMock.SetupGet(x => x.Database).Returns("sqlserver");
_runner = new MigrationRunner(Assembly.GetAssembly( typeof( MigrationRunnerTests ) ), _runnerContextMock.Object, _processorMock.Object);
_runner.MigrationLoader = _migrationLoaderMock.Object;
_runner.ProfileLoader = _profileLoaderMock.Object;
}
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 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);
}
}
/// <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);
}
}
private IMigrationProcessor CreateMigrationProcessor(Announcer announcer)
{
var options = new ProcessorOptions
{
PreviewOnly = false, // set to true to see the SQL
Timeout = 60,
};
EnsureConnectionAvailable(_connectionString);
var factory = new SqlServer2012ProcessorFactory();
IMigrationProcessor processor = factory.Create(_connectionString, announcer, options);
return processor;
}
public void SetUp()
{
_applicationContext = new Random().Next();
_migrationList = new SortedList<long, IMigrationInfo>();
_runnerContextMock = new Mock<IRunnerContext>(MockBehavior.Loose);
_processorMock = new Mock<IMigrationProcessor>(MockBehavior.Loose);
_migrationLoaderMock = new Mock<IMigrationInformationLoader>(MockBehavior.Loose);
_profileLoaderMock = new Mock<IProfileLoader>(MockBehavior.Loose);
_announcer = new Mock<IAnnouncer>();
_stopWatch = new Mock<IStopWatch>();
_stopWatch.Setup(x => x.Time(It.IsAny<Action>())).Returns(new TimeSpan(1)).Callback((Action a) => a.Invoke());
var options = new ProcessorOptions
{
PreviewOnly = false
};
_processorMock.SetupGet(x => x.Options).Returns(options);
_processorMock.SetupGet(x => x.ConnectionString).Returns(IntegrationTestOptions.SqlServer2008.ConnectionString);
_runnerContextMock.SetupGet(x => x.Namespace).Returns("FluentMigrator.Tests.Integration.Migrations");
_runnerContextMock.SetupGet(x => x.Announcer).Returns(_announcer.Object);
_runnerContextMock.SetupGet(x => x.StopWatch).Returns(_stopWatch.Object);
_runnerContextMock.SetupGet(x => x.Target).Returns(Assembly.GetExecutingAssembly().ToString());
_runnerContextMock.SetupGet(x => x.Connection).Returns(IntegrationTestOptions.SqlServer2008.ConnectionString);
_runnerContextMock.SetupGet(x => x.Database).Returns("sqlserver");
_runnerContextMock.SetupGet(x => x.ApplicationContext).Returns(_applicationContext);
_migrationLoaderMock.Setup(x => x.LoadMigrations()).Returns(()=> _migrationList);
_runner = new MigrationRunner(Assembly.GetAssembly(typeof(MigrationRunnerTests)), _runnerContextMock.Object, _processorMock.Object)
{
MigrationLoader = _migrationLoaderMock.Object,
ProfileLoader = _profileLoaderMock.Object,
};
_fakeVersionLoader = new TestVersionLoader(_runner, _runner.VersionLoader.VersionTableMetaData);
_runner.VersionLoader = _fakeVersionLoader;
_processorMock.Setup(x => x.SchemaExists(It.Is<string>(s => s == _runner.VersionLoader.VersionTableMetaData.SchemaName)))
.Returns(true);
_processorMock.Setup(x => x.TableExists(It.Is<string>(s => s == _runner.VersionLoader.VersionTableMetaData.SchemaName),
It.Is<string>(t => t == _runner.VersionLoader.VersionTableMetaData.TableName)))
.Returns(true);
}
