/// <summary>
/// Initializes a new instance of <see cref="MigrationEngine{TMigrationVersion,TMigration,TMigrationAttribute,TMigrationInfo,TMigrationContext}" />.
/// </summary>
/// <param name="sessionFactory">The factory that is used to create sessions which are used to access the target system.</param>
/// <param name="migrationFactory">The factory that is used to instantiate migrations.</param>
/// <param name="createMigrationInfo">The delegate that is used to instantiate migration infos.</param>
/// <exception cref="ArgumentNullException">Thrown when any argument is null.</exception>
public MigrationEngine(ISessionFactory <TMigrationInfo, TMigration, TMigrationContext> sessionFactory,
IMigrationFactory <TMigration> migrationFactory,
Func <TMigration, DateTime, TMigrationInfo> createMigrationInfo)
{
SessionFactory = sessionFactory.MustNotBeNull(nameof(sessionFactory));
MigrationFactory = migrationFactory.MustNotBeNull(nameof(migrationFactory));
CreateMigrationInfo = createMigrationInfo.MustNotBeNull(nameof(createMigrationInfo));
}
public RollbackMigrationAction(IMigrationFactory migratorFactory)
{
if (migratorFactory == null)
{
throw new ArgumentNullException(nameof(migratorFactory));
}
_migratorFactory = migratorFactory;
}
public MigrationContext(IMigrationFactory factory, IQuerySchema querySchema, Assembly migrationAssembly, object context)
{
this.Factory = factory;
Conventions = factory.GetMigrationConventions(context);
Expressions = new List<IMigrationExpression>();
QuerySchema = querySchema;
MigrationAssembly = migrationAssembly;
this.ApplicationContext = context;
}
public bool CanMigrate(IDictionary <string, List <MigrationStep> > steps)
{
foreach (MigrationStep step in steps.SelectMany(row => row.Value).OrderBy(row => row.Version))
{
MigrationReference migrationReference = step.MigrationReference;
IMigrationFactory migrationFactory = _migrationFactoryChooser.ChooseFactory(migrationReference);
IDatabaseMigration migration = migrationFactory.CreateMigration(migrationReference);
step.DatabaseMigration = migration;
_migrationInitializer.InitializeMigration(migration);
}
_log.Info("All migrations are initialized.");
return(true);
}
public override MigrationRunner Create()
{
_steps = new Dictionary <string, List <MigrationStep> >();
_steps[string.Empty] = new List <MigrationStep>();
_steps[string.Empty].Add(new MigrationStep(new MigrationReference(1, "A", "001_a.cs"), false));
_steps[string.Empty].Add(new MigrationStep(new MigrationReference(2, "B", "002_b.cs"), false));
_migration1 = _mocks.StrictMock <IDatabaseMigration>();
_migration2 = _mocks.StrictMock <IDatabaseMigration>();
_schemaStateManager = _mocks.DynamicMock <ISchemaStateManager>();
_migrationFactoryChooser = _mocks.DynamicMock <IMigrationFactoryChooser>();
_migrationInitializer = _mocks.DynamicMock <IMigrationInitializer>();
_migrationFactory = _mocks.DynamicMock <IMigrationFactory>();
_configuration = _mocks.DynamicMock <IConfiguration>();
_transactionProvider = _mocks.DynamicMock <ITransactionProvider>();
_transaction = _mocks.StrictMock <IDbTransaction>();
return(new MigrationRunner(_migrationFactoryChooser, _migrationInitializer, _schemaStateManager, _configuration,
_transactionProvider));
}
public async Task MigrateAsync(IMigrationFactory migrationFactory, CancellationToken cancellationToken)
{
if (migrationFactory == null)
{
throw new ArgumentNullException(nameof(migrationFactory));
}
cancellationToken.ThrowIfCancellationRequested();
using (var connection = await connectionFactory(cancellationToken))
using (var transaction = connection.BeginTransaction(IsolationLevel.Serializable))
{
var version = await connection.QuerySingleAsync <int>(
"PRAGMA user_version;",
transaction : transaction
).ConfigureAwait(false);
var migrations = migrationFactory.BuildMigrations(version);
foreach (var migration in migrations)
{
cancellationToken.ThrowIfCancellationRequested();
await connection.ExecuteAsync(
sql : migration.Sql,
param : migration.Parameter,
commandType : migration.CommandType,
commandTimeout : migration.CommandTimeout,
transaction : transaction
).ConfigureAwait(false);
// Bump version; Dapper does not support parameters with PRAGMAs.
// SQL injection is not an issue here, since we use integers for version.
await connection.ExecuteAsync(
$"PRAGMA user_version = {++version};",
transaction : transaction
).ConfigureAwait(false);
}
cancellationToken.ThrowIfCancellationRequested();
transaction.Commit();
}
}
public MigrationRunner(Assembly assembly, IRunnerContext runnerContext, IMigrationProcessor processor)
{
_migrationAssembly = assembly;
_migrationFactory = runnerContext.Factory;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
ApplicationContext = runnerContext.ApplicationContext;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = runnerContext.Factory.GetMigrationConventions(ApplicationContext);
if (!string.IsNullOrEmpty(runnerContext.WorkingDirectory))
Conventions.GetWorkingDirectory = () => runnerContext.WorkingDirectory;
VersionLoader = runnerContext.Factory.GetVersionLoader(this, _migrationAssembly, Conventions, ApplicationContext);
MigrationLoader = runnerContext.Factory.GetMigrationLoader(Conventions, _migrationAssembly, runnerContext.Namespace, runnerContext.NestedNamespaces, runnerContext.Tags, ApplicationContext);
ProfileLoader = runnerContext.Factory.GetProfileLoader(runnerContext, this, Conventions);
}
/// <summary>
/// Initializes a new instance of <see cref="MigrationEngine{TMigration,TMigrationInfo,TMigrationContext}" />.
/// </summary>
/// <param name="sessionFactory">The factory that is used to create sessions which are used to access the target system.</param>
/// <param name="migrationFactory">The factory that is used to instantiate migrations.</param>
/// <param name="createMigrationInfo">The delegate that is used to instantiate migration infos.</param>
/// <exception cref="ArgumentNullException">Thrown when any argument is null.</exception>
public MigrationEngine(ISessionFactory <TMigrationInfo, TMigration, TMigrationContext> sessionFactory,
IMigrationFactory <TMigration> migrationFactory,
Func <TMigration, DateTime, TMigrationInfo> createMigrationInfo)
: base(sessionFactory, migrationFactory, createMigrationInfo)
{
}
public DefaultMigrationFinder(IMigrationFactory migrationFactory, params Assembly[] assemblies)
{
this.migrationFactory = migrationFactory ?? throw new ArgumentNullException(nameof(migrationFactory));
this.assemblies = assemblies ?? throw new ArgumentNullException(nameof(assemblies));
}
public WindsorBasedFactoryChooser(IKernel kernel)
{
factory = new WindsorFactory(kernel);
}
/// <summary>
/// Initializes a new instance of <see cref="MigrationEngine" />.
/// </summary>
/// <param name="sessionFactory">The factory that is used to create sessions which are used to access the target system.</param>
/// <param name="migrationFactory">The factory that is used to instantiate migrations.</param>
/// <param name="createMigrationInfo">The delegate that is used to instantiate migration infos.</param>
/// <exception cref="ArgumentNullException">Thrown when any argument is null.</exception>
public MigrationEngine(ISessionFactory <MigrationInfo, Migration, IAsyncDocumentSession> sessionFactory,
IMigrationFactory <Migration> migrationFactory,
Func <Migration, DateTime, MigrationInfo> createMigrationInfo)
: base(sessionFactory, migrationFactory, createMigrationInfo)
{
}
/// <summary>
/// Creates a new instance of MigrationRunner
/// </summary>
/// <param name="url">MongoDb connection string</param>
/// <param name="migrationAssembly">Assembly with migrations</param>
/// <param name="factory">Factory responsible for instantiating migrations</param>
public MigrationRunner(MongoUrl url, string migrationAssembly, IMigrationFactory factory)
{
_dbMigrations = new DatabaseMigrations(url);
_locator = new MigrationLocator(migrationAssembly, _dbMigrations.GetDatabase(), factory);
_migrationAssembly = migrationAssembly;
}
public MigrationLocator(string assemblyName, IMongoDatabase database, IMigrationFactory factory)
{
_assembly = Assembly.Load(new AssemblyName(assemblyName));
_database = database;
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
}
public MigrationService(IMigrationLocator locator, IMigrationLogFactory logFactory, IMigrationFactory migrationFactory)
{
this.locator = locator;
this.logFactory = logFactory;
this.migrationFactory = migrationFactory;
}
/// <summary>
/// Creates a new instance of MigrationRunner
/// </summary>
/// <param name="database">MongoDb IMongoDatabase instance</param>
/// <param name="migrationAssembly">Assembly with migrations</param>
/// <param name="factory">Factory responsible for instantiating migrations</param>
public MigrationRunner(IMongoDatabase database, string migrationAssembly, IMigrationFactory factory = null)
{
_dbMigrations = new DatabaseMigrations(database);
_locator = new MigrationLocator(migrationAssembly, database, factory ?? new MigrationFactory());
_migrationAssembly = migrationAssembly;
}
/// <summary>
/// Creates a new instance of MigrationRunner
/// </summary>
/// <param name="connectionString">connection string in common URL format</param>
/// <param name="migrationAssembly">Assembly containing migrations</param>
/// <param name="factory">Factory responsible for instantiating migrations</param>
public MigrationRunner(string connectionString, string migrationAssembly, IMigrationFactory factory) :
this(MongoUrl.Create(connectionString), migrationAssembly, factory)
{
}
/// <summary>
/// Initializes a new instance of <see cref="MigrationEngine{TDbContext}" />.
/// </summary>
/// <param name="sessionFactory">The factory that is used to create sessions which are used to access the target system.</param>
/// <param name="migrationFactory">The factory that is used to instantiate migrations.</param>
/// <param name="createMigrationInfo">The delegate that is used to instantiate migration infos.</param>
/// <exception cref="ArgumentNullException">Thrown when any argument is null.</exception>
public MigrationEngine(ISessionFactory <MigrationInfo, Migration <TDbContext>, TDbContext> sessionFactory,
IMigrationFactory <Migration <TDbContext> > migrationFactory,
Func <Migration <TDbContext>, DateTime, MigrationInfo> createMigrationInfo)
: base(sessionFactory, migrationFactory, createMigrationInfo)
{
}
public MigrationLocator(Assembly locatedAssembly, IMongoDatabase database, IMigrationFactory factory)
{
LocatedAssembly = locatedAssembly;
_database = database;
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
}
public MigrationLocator(string assemblyName, IMongoDatabase database, IMigrationFactory factory)
: this(Assembly.Load(new AssemblyName(assemblyName)), database, factory)
{
}
/// <summary>
/// Initializes a new instance of <see cref="MigrationEngine" />.
/// </summary>
/// <param name="sessionFactory">The factory that is used to create sessions which are used to access the target system.</param>
/// <param name="migrationFactory">The factory that is used to instantiate migrations.</param>
/// <param name="createMigrationInfo">The delegate that is used to instantiate migration infos.</param>
/// <exception cref="ArgumentNullException">Thrown when any argument is null.</exception>
public MigrationEngine(ISessionFactory <MigrationInfo, Migration, DataConnection> sessionFactory,
IMigrationFactory <Migration> migrationFactory,
Func <Migration, DateTime, MigrationInfo> createMigrationInfo)
: base(sessionFactory, migrationFactory, createMigrationInfo)
{
}
/// <summary>
/// Creates a new instance of MigrationRunner
/// </summary>
/// <param name="server">MongoDb server</param>
/// <param name="database">MongoDb database</param>
/// <param name="migrationAssembly">Assembly containing migrations</param>
/// <param name="factory">Factory responsible for instantiating migrations</param>
public MigrationRunner(string server, string database, string migrationAssembly, IMigrationFactory factory) :
this(MongoUrl.Create($"mongodb://{server}/{database}"), migrationAssembly, factory)
{
}
protected EfPersistenceMigrator(IMigrationFactory migratorFactory) : this(new UpdateMigrationAction(migratorFactory), new RollbackMigrationAction(migratorFactory))
{
}
public LoggedMigrationFactory(IMigrationFactory migrationFactory)
{
this.migrationFactory = migrationFactory;
}
