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); }