static void printAllMigrations(IMigration[] migrations) {
foreach (var m in migrations) {
Console.WriteLine("========================================");
Console.WriteLine(m.version + "\n - " + m.description + "\n - Use on folder, " + m.workingDirectory);
}
Console.WriteLine("========================================");
}
static void migrate(IMigration migration)
{
var shouldMigrate = EditorUtility.DisplayDialog("Migrate",
"You are about to migrate your source files. " +
"Make sure that you have committed your current project or that you have a backup of your project before you proceed.",
"I have a backup - Migrate",
"Cancel"
);
if(shouldMigrate) {
EditorUtility.DisplayDialog("Migrate",
"Please select the folder, " + migration.workingDirectory + ".",
"I will select the requested folder"
);
var path = "Assets/";
path = EditorUtility.OpenFolderPanel(migration.version + ": " + migration.workingDirectory, path, string.Empty);
if(!string.IsNullOrEmpty(path)) {
var changedFiles = migration.Migrate(path);
Debug.Log("Applying " + migration.version);
foreach(var file in changedFiles) {
MigrationUtils.WriteFiles(changedFiles);
Debug.Log("Migrated " + file.fileName);
}
} else {
throw new Exception("Could not complete migration! Selected path was invalid!");
}
}
}
static void printUsage(IMigration[] migrations)
{
Console.WriteLine(@"usage:
[-l] - print all available versions
[version] [path] - apply migration of version [version] to source files located at [path]"
);
}
public static void Main(string[] args)
{
var allMigrations = new IMigration[] {
new M0180(),
new M0190(),
new M0220(),
new M0260(),
new M0300()
};
if (args == null) {
printUsage(allMigrations);
} else if (args.Length == 1) {
var arg = args[0];
if (arg == "-l") {
printAllMigrations(allMigrations);
} else {
printUsage(allMigrations);
}
} else if (args.Length == 2) {
var version = args[0];
var path = args[1];
var migrations = allMigrations.Where(m => m.version == version).ToArray();
if (migrations.Length == 0) {
printVersionNotFound(version, allMigrations);
} else {
foreach (var m in migrations) {
MigrationUtils.WriteFiles(m.Migrate(path));
}
}
} else {
printUsage(allMigrations);
}
}
public MigrationWithMetaDataAdapter(IMigration migration, IMigrationMetadata metadata)
{
if (migration == null) throw new ArgumentNullException("migration");
if (metadata == null) throw new ArgumentNullException("metadata");
Migration = migration;
MetaData = metadata;
}
/// <summary>
/// Initializes a new instance of the <see cref="AfterMigrationEventArgs"/> class.
/// </summary>
/// <param name="version">The version.</param>
/// <param name="migration">The migration.</param>
/// <param name="direction">The direction.</param>
/// <param name="success">if set to <c>true</c> the migration succeeded.</param>
public AfterMigrationEventArgs(long version, IMigration migration, MigrationDirection direction, bool success)
{
Version = version;
Migration = migration;
Direction = direction;
Success = success;
}
public MigrationStep(IMigration migration, IScheduledMigrationMetadata metadata, ConnectionInfo connectionInfo, IProvider provider, IProviderMetadata providerMetadata, IDbConnectionFactory connectionFactory, ISqlDispatcher sqlDispatcher)
: base(migration, provider, providerMetadata)
{
_metadata = metadata;
_connectionInfo = connectionInfo;
_connectionFactory = connectionFactory;
_sqlDispatcher = sqlDispatcher;
}
private long ExtractTimestamp(string moduleName, IMigration migration)
{
var timestampProvider = _timestampProviders.ContainsKey(moduleName)
? _timestampProviders[moduleName]
: _timestampProviders[MigrationExportAttribute.DefaultModuleName];
long timestamp = timestampProvider.GetTimestamp(migration.GetType());
return timestamp;
}
public MigrationInfo(long version, TransactionBehavior transactionBehavior, IMigration migration)
{
if (migration == null) throw new ArgumentNullException("migration");
Version = version;
TransactionBehavior = transactionBehavior;
Migration = migration;
}
public MigrationInfo(long version, TransactionBehavior transactionBehavior, bool breakingChange, IMigration migration)
{
if (migration == null) throw new ArgumentNullException("migration");
Version = version;
TransactionBehavior = transactionBehavior;
Migration = migration;
BreakingChange = breakingChange;
}
private void ApplyMigration(IMigration migration, MigrationAttribute attr) {
// we're adding this one
_logger.MigrateUp(Current, migration.Name);
if (! DryRun) {
migration.Up();
_provider.MigrationApplied(attr.Version);
_provider.Commit();
migration.AfterUp();
}
}
public MigrationVersionRunner(IMigrationConventions conventions, IMigrationProcessor processor, IMigrationLoader loader, Assembly assembly, string @namespace)
{
_migrationConventions = conventions;
_migrationProcessor = processor;
_migrationAssembly = assembly;
_migrationLoader = loader;
_namespace = @namespace;
_migrationRunner = new MigrationRunner(conventions, processor);
_versionMigration = new VersionMigration();
}
private void RemoveMigration(IMigration migration, MigrationAttribute attr) {
// we're removing this one
_logger.MigrateDown(Current, migration.Name);
if (! DryRun) {
migration.Down();
_provider.MigrationUnApplied(attr.Version);
_provider.Commit();
migration.AfterDown();
}
}
private void SolveDependency(IDbRoot root, string filePath, IMigration migration)
{
foreach (var migrationId in migration.MigrationsNeeded.Where(x => !root.MigrationHistory.HasMigration(x)))
{
// For each dependency that needs to be solved, we solve the subdependencies
var dependency = this.migrations[migrationId];
this.SolveDependency(root, filePath, dependency);
dependency.Apply(root, filePath);
root.MigrationHistory.AddMigration(migrationId);
}
}
public override void Migrate(IMigration migration)
{
_provider.BeginTransaction();
MigrationAttribute attr = (MigrationAttribute)Attribute.GetCustomAttribute(migration.GetType(), typeof(MigrationAttribute));
if (_provider.AppliedMigrations.Contains(attr.Version)) {
RemoveMigration(migration, attr);
} else {
ApplyMigration(migration, attr);
}
}
public MigrationVersionRunner(IMigrationConventions conventions, IMigrationProcessor processor, IMigrationLoader loader, Assembly assembly, string @namespace, IAnnouncer announcer)
{
_migrationConventions = conventions;
_migrationProcessor = processor;
_migrationAssembly = assembly;
_migrationLoader = loader;
_namespace = @namespace;
_announcer = announcer;
_migrationRunner = new MigrationRunner(conventions, processor, announcer, new StopWatch());
_versionTableMetaData = loader.GetVersionTableMetaData(assembly);
_versionMigration = new VersionMigration(_versionTableMetaData);
}
private Task Migrate(IMigration migration, Func<IMigration, Task> action)
{
try
{
return action(migration);
}
finally
{
var disposable = migration as IDisposable;
disposable?.Dispose();
}
}
public VersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies, IMigrationConventions conventions)
{
Runner = runner;
Processor = runner.Processor;
Assemblies = assemblies;
Conventions = conventions;
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
/// <summary>
/// Alters the database schema by applying the specified migration. Versioning is unaffected by this operation and any timestamp information on the <paramref name="migration"/> is disregarded.
/// </summary>
public void Alter(IMigration migration)
{
if (migration is IReversibleMigration)
{
Log.Info(LogCategory.General, "Migrations used to modify the database schema directly cannot be reversed.");
}
var migrationMetadata = new MigrationMetadata(0, "Bypass", "This migration is being executed without affecting the versioning.");
var stepMetadata = new MigrationStepMetadata(MigrationDirection.Up, false, new[] { migrationMetadata });
var batch = new MigrationBatch(new[]
{
new MigrationStep(migration, stepMetadata)
}, Enumerable.Empty<IMigrationMetadata>(), new NoVersioning(), Configuration);
batch.Execute();
}
void ApplyMigration(IMigration migration, MigrationAttribute attr)
{
// we're adding this one
_logger.MigrateUp(Current, migration.Name);
if (! DryRun)
{
var tProvider = _provider as TransformationProvider;
if (tProvider != null)
tProvider.CurrentMigration = migration;
migration.Up();
_provider.MigrationApplied(attr.Version, attr.Scope);
_provider.Commit();
migration.AfterUp();
}
}
public void Down(IMigration migration)
{
var name = migration.GetType().Name;
_announcer.Heading(name + ": reverting");
CaughtExceptions = new List<Exception>();
var context = new MigrationContext(Conventions, Processor);
migration.GetDownExpressions(context);
_stopWatch.Start();
ExecuteExpressions(context.Expressions);
_stopWatch.Stop();
_announcer.Say(name + ": reverted");
_announcer.ElapsedTime(_stopWatch.ElapsedTime());
}
protected void RunMigrationIfNecessary(SqlConnection connection, IMigration migration)
{
// Determine if we need to apply this one
var exists = new SqlCommand("SELECT COUNT(*) FROM " + VERSION_TABLE + " WHERE MigrationId = " + migration.Version, connection);
var results = (int)exists.ExecuteScalar();
if(results != 0)
{
// Already applied
return;
}
// Execute the migration
var command = new SqlCommand(migration.SqlCommand, connection);
command.ExecuteNonQuery();
// Add a record to the version table
var addVersion = new SqlCommand("INSERT INTO " + VERSION_TABLE + " SELECT " + migration.Version + ", GETUTCDATE()", connection);
addVersion.ExecuteNonQuery();
}
public void Down(IMigration migration)
{
var name = migration.GetType().Name;
_announcer.Announce(name + ": reverting");
CaughtExceptions = new List<Exception>();
var context = new MigrationContext(Conventions,Processor);
migration.GetDownExpressions(context);
_stopWatch.Start();
ExecuteExpressions(context.Expressions);
_stopWatch.Stop();
var elapsed = _stopWatch.ElapsedTime().TotalSeconds;
_announcer.Announce(name + ": reverted (" + elapsed + "s" + ")");
}
/// <summary>
/// Validates each migration expression that has implemented the ICanBeValidated interface.
/// It throws an InvalidMigrationException exception if validation fails.
/// </summary>
/// <param name="migration">The current migration being run</param>
/// <param name="expressions">All the expressions contained in the up or down action</param>
public void ApplyConventionsToAndValidateExpressions(IMigration migration, IEnumerable<IMigrationExpression> expressions)
{
var errorMessageBuilder = new StringBuilder();
foreach (var expression in expressions)
{
expression.ApplyConventions(_conventions);
var errors = new Collection<string>();
expression.CollectValidationErrors(errors);
if (errors.Count > 0)
AppendError(errorMessageBuilder, expression.GetType().Name, string.Join(" ", errors.ToArray()));
}
if (errorMessageBuilder.Length > 0)
{
var errorMessage = errorMessageBuilder.ToString();
_announcer.Error("The migration {0} contained the following Validation Error(s): {1}", migration.GetType().Name, errorMessage);
throw new InvalidMigrationException(migration, errorMessage);
}
}
public override void Migrate(IMigration migration)
{
_provider.BeginTransaction();
MigrationAttribute attr = (MigrationAttribute)Attribute.GetCustomAttribute(migration.GetType(), typeof(MigrationAttribute));
var v = attr.GetVersion(migration.GetType());
var contains = false;
foreach (var appliedMigration in _provider.AppliedMigrations)
{
if (appliedMigration.Key != v.Key || appliedMigration.Value != v.Value) continue;
contains = true;
break;
}
if (contains)
{
RemoveMigration(migration, attr);
} else {
ApplyMigration(migration, attr);
}
}
static void printVersionNotFound(string version, IMigration[] migrations)
{
Console.WriteLine("Could not find a migration for version '" + version + "'");
printAllMigrations(migrations);
}
public void Down(IMigration migration)
{
var migrationInfoAdapter = new NonAttributedMigrationToMigrationInfoAdapter(migration);
ApplyMigrationDown(migrationInfoAdapter, true);
}
private string GetMigrationName(long version, IMigration migration)
{
string name = GetMigrationName(migration);
if (migration is IMigrationMetadata)
return name;
return string.Format("{0}: {1}", version, name);
}
private string GetMigrationName(IMigration migration)
{
if (migration == null) throw new ArgumentNullException("migration");
IMigrationMetadata metadata = migration as IMigrationMetadata;
if (metadata != null)
{
return string.Format("{0}: {1}", metadata.Version, metadata.Type.Name);
}
return migration.GetType().Name;
}
public void Up(IMigration migration)
{
var name = GetMigrationName(migration);
_announcer.Heading(string.Format("{0} migrating", name));
CaughtExceptions = new List<Exception>();
var context = new MigrationContext(Conventions, Processor, MigrationAssembly, ApplicationContext) { Factory = _migrationFactory };
migration.GetUpExpressions(context);
_stopWatch.Start();
ExecuteExpressions(context.Expressions);
_stopWatch.Stop();
_announcer.Say(string.Format("{0} migrated", name));
_announcer.ElapsedTime(_stopWatch.ElapsedTime());
}
private void ExecuteMigration(IMigration migration, Action<IMigration, IMigrationContext> getExpressions)
{
CaughtExceptions = new List<Exception>();
var context = new MigrationContext(Conventions, Processor, MigrationAssembly, ApplicationContext, Processor.ConnectionString);
getExpressions(migration, context);
_migrationValidator.ApplyConventionsToAndValidateExpressions(migration, context.Expressions);
ExecuteExpressions(context.Expressions);
}
