private static void MigrateDatabase(IHost host, MigrationMode migrationMode)
{
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
var logger = services.GetRequiredService <ILogger <Program> >();
try
{
var pwdman = services.GetRequiredService <IPwdManService>();
var dbContext = pwdman.GetDbContext();
dbContext.Database.Migrate();
if (migrationMode != MigrationMode.None)
{
var postgres = services.GetRequiredService <DbPostgresContext>();
var sqlite = services.GetRequiredService <DbSqliteContext>();
if (migrationMode == MigrationMode.Sqlite2Postgres && dbContext is DbPostgresContext)
{
MigrateDbContexts(logger, sqlite, postgres);
}
else if (migrationMode == MigrationMode.Postgres2Sqlite && dbContext is DbSqliteContext)
{
MigrateDbContexts(logger, postgres, sqlite);
}
else
{
logger.LogWarning("Migration is not allowed.");
}
}
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred creating the DB.");
}
}
public MigrationProfile(string name, MigrationMode migrationMode, Dictionary <OtpType, string> findPlaceholder, Dictionary <OtpType, string> replacePlaceholder)
{
this.name = name;
this.migrationMode = migrationMode;
this.findPlaceholder = findPlaceholder;
this.replacePlaceholder = replacePlaceholder;
}
/// <summary>
/// Scaffolds a code based migration to apply any pending model changes to the database.
/// </summary>
/// <param name="start">The start.</param>
/// <param name="end">The end.</param>
/// <param name="mode">The mode.</param>
/// <returns>The <see cref="Migrator"/> used to apply migrations.</returns>
public IImmutableList <Migrator> Scaffold(ObjectId start, ObjectId end, MigrationMode mode)
{
if (mode == MigrationMode.Downgrade)
{
throw new NotImplementedException(MigrationMode.Downgrade.ToString());
}
return(_repositoryProvider.Execute(_repositoryDescription, repository =>
{
var log = repository.Commits.QueryBy(new CommitFilter
{
SortBy = CommitSortStrategies.Topological | CommitSortStrategies.Reverse,
ExcludeReachableFrom = start,
IncludeReachableFrom = end
});
var deferred = new List <IMigration>();
var result = ImmutableList.CreateBuilder <Migrator>();
result.AddRange(GetLogMigrators(repository, log, deferred, repository.Lookup <Commit>(start), mode));
if (deferred.Any())
{
var uniqueDeferredMigrations = deferred.Distinct(MetadataObjectIdComparer <IMigration> .Instance);
if (result.Any())
{
var toUpdate = result[result.Count - 1];
var newValue = new Migrator(toUpdate.Migrations.Concat(deferred).ToImmutableList(), mode, toUpdate.CommitId);
result[result.Count - 1] = newValue;
}
else
{
result.Add(new Migrator(uniqueDeferredMigrations.ToImmutableList(), mode, end));
}
}
return result.ToImmutable();
}));
}
public void ExecuteMigrationScripts(IDbPlatform dbPlatform, IMigrationVersionInfoManager migrationVersionInfoManager,
string connectionString, MigrationScriptCollection migrationScripts,
long currentVersion, long? targetVersion, MigrationMode migrationMode)
{
this.migrationScripts = migrationScripts;
this.currentVersion = currentVersion;
this.targetVersion = targetVersion;
this.migrationMode = migrationMode;
}
/// <summary>
/// Registers the fact of migrating to version <paramref name="version"/> with mode <paramref name="migrationMode"/>
/// for the given <paramref name="dbTransaction"/>.
/// </summary>
/// <param name="dbTransaction"></param>
/// <param name="migrationMode"></param>
/// <param name="version"></param>
public void RegisterMigrationVersion(IDbTransaction dbTransaction, MigrationMode migrationMode, long version)
{
if(migrationMode == MigrationMode.Upgrade)
registeredMigrationVersions.Add(version);
else
registeredMigrationVersions.Remove(version);
registeredMigrationVersions.Sort();
}
public void DeserializeSourceNodeAuto_with_Always_or_OnFailure_mode_opens_anything(
BattleScribeVersion version,
MigrationMode mode,
string datafile)
{
using var stream = datafile.GetDatafileStream(version);
var result = stream.DeserializeSourceNodeAuto(mode);
result
.Should().NotBeNull()
.And.BeAssignableTo <IRootNode>();
}
public static bool checkEntryMigratable(PwEntry entry, MigrationMode migrateMode)
{
switch (migrateMode)
{
case MigrationMode.KeeOtp1ToBuiltIn:
return(OtpAuthUtils.checkKeeOtp1Mode(entry));
case MigrationMode.BuiltInToKeeOtp1:
return(OtpAuthUtils.checkBuiltInMode(entry));
default:
return(false);
}
}
public static SourceNode DeserializeAuto(
Stream stream,
MigrationMode mode = MigrationMode.None)
{
return(mode switch
{
MigrationMode.None => DeserializeSimple(stream),
MigrationMode.OnFailure => WithSeekable(seekable =>
{
try
{
return DeserializeSimple(seekable);
}
catch (InvalidOperationException)
{
return DeserializeMigrated(seekable);
}
}),
MigrationMode.Always => WithSeekable(DeserializeMigrated),
_ => throw new ArgumentException(
$"Invalid {nameof(MigrationMode)} value.",
nameof(mode)),
});
private IEnumerable<MigrationScript> GetMigrationScripts(MigrationScriptCollection migrationScripts,
long currentVersion, long? targetVersion, MigrationMode migrationMode)
{
if(migrationMode == MigrationMode.Upgrade)
{
foreach (MigrationScript ms in migrationScripts)
{
yield return ms;
} // if
} // if
else
{
foreach(MigrationScript ms in Algorithms.Reverse(migrationScripts))
{
yield return ms;
} // foreach
} // else
}
IEnumerable <Migrator> GetLogMigrators(IRepository repository, ICommitLog log, List <IMigration> deferred, Commit previousCommit, MigrationMode mode)
{
foreach (var commit in log)
{
if (previousCommit != null)
{
var migrations = GetCommitMigrations(repository, previousCommit, commit).ToList();
deferred.AddRange(migrations.Where(m => m.IsIdempotent));
migrations.RemoveAll(m => m.IsIdempotent);
if (migrations.Any())
{
yield return(new Migrator(migrations.Where(m => !m.IsIdempotent).ToImmutableList(), mode, commit.Id));
}
}
previousCommit = commit;
}
}
/// <summary>
/// Registers the fact of migrating to version <paramref name="version"/> with mode <paramref name="migrationMode"/>
/// for the given <paramref name="dbTransaction"/>.
/// </summary>
/// <param name="dbTransaction"></param>
/// <param name="migrationMode"></param>
/// <param name="version"></param>
public void RegisterMigrationVersion(IDbTransaction dbTransaction, MigrationMode migrationMode, long version)
{
switch(migrationMode)
{
case MigrationMode.Upgrade:
RegisterUpgradeMigrationVersion(dbTransaction, version);
break;
case MigrationMode.Downgrade:
RegisterDowngradeMigrationVersion(dbTransaction, version);
break;
default:
throw new ArgumentOutOfRangeException("migrationMode");
}
}
public void ExecuteMigrationScripts(IDbPlatform dbPlatform, IMigrationVersionInfoManager migrationVersionInfoManager,
string connectionString, MigrationScriptCollection migrationScripts,
long currentVersion, long? targetVersion, MigrationMode migrationMode)
{
using(IDbConnection dbConnection = dbPlatform.ProviderFactory.CreateConnection())
{
dbConnection.ConnectionString = connectionString;
dbConnection.Open();
IList<MigrationScript> effectiveMigrationScripts =
new List<MigrationScript>(GetMigrationScripts(migrationScripts, currentVersion, targetVersion, migrationMode));
foreach(MigrationScript migrationScript in effectiveMigrationScripts)
{
using(IDbTransaction ddlTransaction = BeginDdlTransaction(dbPlatform, dbConnection))
{
using(IDbCommand dbCommand = dbConnection.CreateCommand())
{
InvokeMigrating(new MigrationScriptExecutionEventArgs(migrationMode, migrationScript.MigrationVersion));
foreach(string ddlScript in migrationScript.DdlScripts)
{
dbCommand.CommandText = ddlScript;
dbCommand.CommandType = CommandType.Text;
Trace.WriteLine(ddlScript);
//
// Workaround for Jet
if(!(ddlTransaction is NullDbTransaction))
dbCommand.Transaction = ddlTransaction;
try
{
dbCommandExecutionStrategy.Execute(dbPlatform, dbCommand);
} // try
// TODO: Replace with DbPlatformException or something
catch(Exception e)
{
throw new MigrationException(
string.Format(migrationMode == MigrationMode.Upgrade ?
Properties.Resources.ErrorWhileUpgradingToVersion:
Properties.Resources.ErrorWhileDowngradingToVersion, migrationScript.MigrationVersion, e.ToString()),
ddlScript, e);
} // catch
} // foreach
} // using
//
// If we're downgrading all way down, do not register it, since SchemaInfo
// will be deleted too.
if(!(migrationMode == MigrationMode.Downgrade && targetVersion == 0 && effectiveMigrationScripts.IndexOf(migrationScript) ==
effectiveMigrationScripts.Count - 1))
migrationVersionInfoManager.RegisterMigrationVersion(ddlTransaction, migrationMode,
migrationScript.MigrationVersion);
ddlTransaction.Commit();
InvokeMigrated(new MigrationScriptExecutionEventArgs(migrationMode, migrationScript.MigrationVersion));
} // using
} // foreach
} // foreach
}
private static MigrationScriptCollection CompileMigrationScripts(IDbPlatform dbPlatform, INativeSqlResourceProvider nativeSqlResourceProvider,
TextReader migrationDefinition, MigrationMode migrationMode)
{
MigrationScriptCompiler migrationScriptCompiler = new MigrationScriptCompiler(dbPlatform, nativeSqlResourceProvider, migrationMode);
return migrationScriptCompiler.CompileMigrationScripts(migrationDefinition);
}
public virtual void SetMigrationMode(MigrationMode migrationMode)
{
this.migrationMode = migrationMode;
}
private void MigrateDb(MigrationMode migrationMode, string connectionString, IEnumerable<MigrationScript> migrationScripts,
long currentVersion, long? targetVersion)
{
List<long> registeredMigrationVersions = new List<long>(GetRegisteredMigrationVersions(connectionString));
//
// When upgrading, set effective current version to 0
// to run all missing migrations
long effectiveCurrentVersion =
migrationMode == MigrationMode.Upgrade ?
0 :
currentVersion;
MigrationScriptCollection migrations =
new MigrationScriptSelector().SelectMigrationScripts(effectiveCurrentVersion, targetVersion,
migrationMode, registeredMigrationVersions.ToArray(), migrationScripts);
//
// Ok, we're all set. Run the migrations
migrationScriptExecutive.ExecuteMigrationScripts(dbPlatform, migrationVersionInfoManager,
connectionString, migrations, currentVersion, targetVersion, migrationMode);
}
public static SourceNode DeserializeSourceNodeAuto(
this Stream stream,
MigrationMode mode = MigrationMode.None)
{
return(DataVersionManagement.DeserializeAuto(stream, mode));
}
/// <summary>
/// Initializes a new instance of the <see cref="Migrator"/> class.
/// </summary>
/// <param name="migrations">The migrations.</param>
/// <param name="mode">The mode.</param>
/// <param name="commitId">The commit identifier containing the migrations.</param>
/// <exception cref="ArgumentNullException">migrations</exception>
public Migrator(IImmutableList <IMigration> migrations, MigrationMode mode, ObjectId commitId)
{
Migrations = migrations ?? throw new ArgumentNullException(nameof(migrations));
Mode = mode;
CommitId = commitId ?? throw new ArgumentNullException(nameof(commitId));
}
public MigrationScriptCompiler(IDbPlatform dbPlatform, INativeSqlResourceProvider nativeSqlResourceProvider, MigrationMode migrationMode)
{
this.dbPlatform = dbPlatform;
this.nativeSqlResourceProvider = nativeSqlResourceProvider;
this.migrationMode = migrationMode;
}
private IAstNode GetNode(IVersionNode versionNode, MigrationMode migrationMode)
{
return migrationMode == MigrationMode.Upgrade ?
(IAstNode)GetFirst<IUpgradeNode>(versionNode.ChildNodes) :
(IAstNode)GetFirst<IDowngradeNode>(versionNode.ChildNodes);
}
public MigrationScriptExecutionEventArgs(MigrationMode mode, long version)
{
this.mode = mode;
this.version = version;
}
private void MigrateDb(string connectionString, TextReader migrationDefinition, long currentVersion, long? targetVersion, MigrationMode migrationMode)
{
MigrationScriptCollection migrationScripts = CompileMigrationScripts(dbPlatform,
nativeSqlResourceProvider, migrationDefinition, migrationMode);
MigrateDb(migrationMode, connectionString, migrationScripts, currentVersion, targetVersion);
}
private IEnumerable <Migrator> GetLogMigrators(IRepository repository, ICommitLog log, List <IMigration> deferred, Commit previousCommit, MigrationMode mode)
{
var context = new ModelObjectSerializationContext(_container);
var serializer = _repositorySerializerFactory(context);
foreach (var commit in log)
{
if (previousCommit != null)
{
var migrations = GetCommitMigrations(repository, previousCommit, commit, serializer).ToList();
deferred.AddRange(migrations.Where(m => m.IsIdempotent));
migrations.RemoveAll(m => m.IsIdempotent);
if (migrations.Any())
{
yield return(new Migrator(migrations.Where(m => !m.IsIdempotent).ToImmutableList(), mode, commit.Id));
}
}
previousCommit = commit;
}
}
public MigrationEventArgs(long version, MigrationMode mode)
{
this.version = version;
this.mode = mode;
}
