public void SaveMigrationsHistory(FaustMigrationHistory[] migrationHistories, UserContext userContext) { Logger.Log(string.Format("FaustEngine.SaveMigrationsHistory: Saving History for {0} scripts.", migrationHistories.Length), TraceEventType.Verbose); foreach (FaustMigrationHistory migration in migrationHistories) { FaustMigrationHistory searchCriteria = new FaustMigrationHistory { ReleaseNumber = migration.ReleaseNumber, ScriptName = migration.ScriptName }; using (TransactionScope loggingScope = new TransactionScope(TransactionScopeOption.RequiresNew)) { FaustMigrationHistory existingHistory = UnityCache.Resolve <IFaustMigrationsHistoryAccessor>() .FindMany(searchCriteria, userContext) .FirstOrDefault(); if (existingHistory == null) { UnityCache.Resolve <IFaustMigrationsHistoryAccessor>().Create(migration, userContext); } else { existingHistory.LastRun = migration.LastRun; existingHistory.Committed = migration.Committed; existingHistory.Successful = migration.Successful; existingHistory.Log = migration.Log; UnityCache.Resolve <IFaustMigrationsHistoryAccessor>().Update(existingHistory, userContext); } loggingScope.Complete(); } } }
public void FaustMigrationsHistoryAccessor_Delete() { FaustMigrationHistory migrationHistory = new FaustMigrationHistory { ReleaseNumber = 2, ScriptName = "2.tony.sql", Committed = false, Successful = false, LastRun = DateTime.Now, }; _faustMigrationsHistoryAccessor.Create(migrationHistory, base.DefaultUserContext); int id = migrationHistory.FaustMigrationHistoryId; _faustMigrationsHistoryAccessor.Delete(migrationHistory, base.DefaultUserContext); FaustMigrationHistory testing; using (FaustDB db = new FaustDB(base.DefaultUserContext)) { testing = db.FaustMigrationsHistory.Where(f => f.FaustMigrationHistoryId == id).FirstOrDefault(); } Assert.IsNull(testing); }
public FaustMigrationHistory RunMigrationScript(FaustMigrationScript script, UserContext userContext) { Logger.Log(string.Format("FaustEngine.RunMigrationScript: Running commands for script {0}.", script.ScriptName), TraceEventType.Verbose); FaustMigrationHistory migrationHistory = new FaustMigrationHistory(); try { migrationHistory.ReleaseNumber = script.ReleaseNumber; migrationHistory.ScriptName = script.ScriptName; migrationHistory.Committed = true; migrationHistory.Successful = true; migrationHistory.LastRun = DateTime.Now; foreach (string sqlCommand in script.Commands) { migrationHistory.Log = sqlCommand; UnityCache.Resolve <IFaustAccessor>().ExecuteSqlCommand(sqlCommand, userContext); } return(migrationHistory); } catch (Exception ex) { migrationHistory.Successful = false; migrationHistory.Log = string.Format("Error: {0}\r\nCommand: {1}", ex.Message, migrationHistory.Log); Logger.Log(string.Format("FaustEngine.RunMigrationScript: {0}", migrationHistory.Log), TraceEventType.Error); return(migrationHistory); } }
public Expression <Func <FaustMigrationHistory, bool> > SetupFindMany(FaustMigrationHistory searchCriteria, UserContext userContext) { if (searchCriteria == null) { throw new ArgumentException(Resources.Error_SearchParameterNull, "searchCriteria"); } var predicate = PredicateBuilder.True <FaustMigrationHistory>(); return(predicate); }
public FaustMigrationHistory Update(FaustMigrationHistory entity, UserContext userContext) { Logger.Log(string.Format(Resources.Accessors_Updating, typeof(FaustMigrationHistory).Name, entity.FaustMigrationHistoryId), TraceEventType.Verbose); using (var db = new FaustDB(userContext)) { db.Entry(entity).State = EntityState.Modified; db.SaveChanges(); } Logger.Log(string.Format(Resources.Accessors_Updated, typeof(FaustMigrationHistory).Name, entity.FaustMigrationHistoryId), TraceEventType.Verbose); return(entity); }
public FaustMigrationHistory[] FindMany(FaustMigrationHistory searchCriteria, UserContext userContext) { Logger.Log(string.Format(Resources.Accessors_FindMany, typeof(FaustMigrationHistory).ToString()), TraceEventType.Verbose); var predicate = SetupFindMany(searchCriteria, userContext); predicate = SearchCriteriaExpression(searchCriteria, predicate); FaustMigrationHistory[] result; using (var db = new FaustDB(userContext)) { result = db.Set <FaustMigrationHistory>().AsExpandable().Where(predicate).ToArray(); } Logger.Log(string.Format(Resources.Accessors_FoundMany, result.Length, typeof(FaustMigrationHistory).ToString()), TraceEventType.Verbose); return(result); }
public FaustMigrationHistory Delete(FaustMigrationHistory entity, UserContext userContext) { if (entity == null) { throw new ArgumentException(Resources.Error_DeleteEntityParameterNull, "entity"); } using (var db = new FaustDB(userContext)) { db.Entry(entity).State = EntityState.Deleted; db.SaveChanges(); } Logger.Log(string.Format(Resources.Accessors_Deleted, typeof(FaustMigrationHistory).Name), TraceEventType.Verbose); return(entity); }
public void FaustMigrationsHistoryAccessor_DeleteMany() { FaustMigrationHistory migrationHistory1 = new FaustMigrationHistory { FaustMigrationHistoryId = 1, ReleaseNumber = 1, ScriptName = "1.xyzUnitTest.sql", Committed = false, Successful = false, LastRun = DateTime.Now, Log = "This needs to be deleted for the purpose of unit testing" }; FaustMigrationHistory migrationHistory2 = _faustMigrationsHistoryAccessor.Create(new FaustMigrationHistory { FaustMigrationHistoryId = 2, ReleaseNumber = 2, ScriptName = "2.xyzUnitTest.sql", Committed = false, Successful = false, LastRun = DateTime.Now, Log = "This needs to be deleted for the purpose of unit testing" }, base.DefaultUserContext); int id = migrationHistory1.FaustMigrationHistoryId; int id2 = migrationHistory2.FaustMigrationHistoryId; _faustMigrationsHistoryAccessor.DeleteMany(new FaustMigrationHistory { Log = "This needs to be deleted for the purpose of unit testing" }, base.DefaultUserContext); FaustMigrationHistory testing = _faustMigrationsHistoryAccessor.FindMany(new FaustMigrationHistory { ScriptName = "1.xyzUnitTest.sql" }, base.DefaultUserContext) .FirstOrDefault(); Assert.IsNull(testing); testing = _faustMigrationsHistoryAccessor.FindMany(new FaustMigrationHistory { ScriptName = "2.xyzUnitTest.sql" }, base.DefaultUserContext).FirstOrDefault(); Assert.IsNull(testing); }
public override void TestInitialize() { base.TestInitialize(); _faustMigrationsHistoryAccessor = new FaustMigrationsHistoryAccessor(); _faustMigrationsHistoryAccessor.Initialize(base.DefaultUserContext); using (var db = new FaustDB(base.DefaultUserContext)) { _migrationHistory = new FaustMigrationHistory(); _migrationHistory.FaustMigrationHistoryId = 1; _migrationHistory.ReleaseNumber = 1; _migrationHistory.ScriptName = "1.tony.sql"; _migrationHistory.Committed = false; _migrationHistory.Successful = false; _migrationHistory.LastRun = DateTime.Now; db.FaustMigrationsHistory.Add(_migrationHistory); db.SaveChanges(); } }
public FaustMigrationHistory[] DeleteDebugEntries(UserContext userContext) { Logger.Log("FaustMigrationsHistoryAccessor - Deleting all debug Migration Histories", TraceEventType.Verbose); FaustMigrationHistory[] deletedHistories = new FaustMigrationHistory[0]; using (var db = new FaustDB(userContext)) { IEnumerable <FaustMigrationHistory> histories = db.Set <FaustMigrationHistory>().Where(fmh => fmh.ReleaseNumber < 0); deletedHistories = histories.ToArray(); histories.ForEach(h => db.Entry(h).State = EntityState.Deleted); db.SaveChanges(); } Logger.Log(string.Format("FaustMigrationsHistoryAccessor - Deleted {0} Migration Histories", deletedHistories.Length), TraceEventType.Verbose); return(deletedHistories); }
public void FaustMigrationsHistoryAccessor_Create() { FaustMigrationHistory migrationHistory = new FaustMigrationHistory { ReleaseNumber = 2, ScriptName = "2.tony.sql", Committed = false, Successful = false, LastRun = DateTime.Now, }; _faustMigrationsHistoryAccessor.Create(migrationHistory, base.DefaultUserContext); int id = migrationHistory.FaustMigrationHistoryId; FaustMigrationHistory[] result = _faustMigrationsHistoryAccessor.FindMany(new FaustMigrationHistory { ScriptName = "2.tony.sql" }, base.DefaultUserContext); Assert.IsTrue(Array.Find(result, item => migrationHistory.FaustMigrationHistoryId == id) != null); }
public virtual FaustMigrationHistory[] DeleteMany(FaustMigrationHistory searchCriteria, UserContext userContext) { if (searchCriteria == null) { throw new ArgumentException(Resources.Error_SearchParameterNull, "searchCriteria"); } FaustMigrationHistory[] foundArray = FindMany(searchCriteria, userContext); using (var db = new FaustDB(userContext)) { foreach (FaustMigrationHistory entity in foundArray) { db.Entry(entity).State = EntityState.Deleted; } db.SaveChanges(); } Logger.Log(string.Format(Resources.Accessors_DeletedMany, foundArray.Length, typeof(FaustMigrationHistory).Name), TraceEventType.Verbose); return(foundArray); }
public void RunMigration(string databaseName) { Logger.Log(string.Format("FaustManager.RunMigration: Running Migrations for database {0}.", databaseName), TraceEventType.Verbose); Console.WriteLine("##teamcity[message text='FAUSTing Migrations']"); UserContext userContext = UserContext.GetUserContext(databaseName); UnityCache.Resolve <IFaustMigrationsHistoryAccessor>().Initialize(userContext); List <DirectoryInfo> releaseDirs = Directory.GetDirectories(ConfigurationManager.AppSettings["MigrationsDirectory"] + databaseName) .Select(dir => new DirectoryInfo(dir)) .Where(dir => int.Parse(dir.Name) > 0) .OrderBy(dir => int.Parse(dir.Name)) .ToList(); if (ConfigurationManager.AppSettings["RunDebugMigrations"] == "true") { List <DirectoryInfo> holdingDirs = Directory.GetDirectories(ConfigurationManager.AppSettings["MigrationsDirectory"] + databaseName) .Select(dir => new DirectoryInfo(dir)) .Where(dir => int.Parse(dir.Name) < 0) .OrderByDescending(dir => int.Parse(dir.Name)) .ToList(); holdingDirs.ForEach(d => releaseDirs.Add(d)); UnityCache.Resolve <IFaustMigrationsHistoryAccessor>().DeleteDebugEntries(userContext); } foreach (DirectoryInfo release in releaseDirs) { FaustMigrationScript[] scripts = UnityCache.Resolve <IFaustEngine>().GetReleaseMigrationScripts(release, userContext); List <FaustMigrationHistory> migrationHistories = new List <FaustMigrationHistory>(); TransactionScopeOption scopeOption = TransactionScopeOption.Required; if (release.EnumerateFiles().Any(file => file.Name == "no.transaction")) { scopeOption = TransactionScopeOption.Suppress; } TimeSpan desiredTimeout = TimeSpan.FromSeconds(int.Parse(ConfigurationManager.AppSettings["DefaultCommandTimeoutSecondsOverride"])); Settings.OverrideTransactionManagerMaximumTimeout(desiredTimeout); using (TransactionScope releaseScope = new TransactionScope(scopeOption, new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted })) { foreach (FaustMigrationScript script in scripts) { FaustMigrationHistory migrationHistory = UnityCache.Resolve <IFaustEngine>().RunMigrationScript(script, userContext); migrationHistories.Add(migrationHistory); if (!migrationHistory.Successful ?? false) { releaseScope.Dispose(); migrationHistories.ForEach(m => m.Committed = false); Console.WriteLine(string.Format("##teamcity[message text='{0}' errorDetails='' status='ERROR']", migrationHistory.Log)); Console.WriteLine("##teamcity[buildProblem description='FAUST Failed. See build log for details.']"); Logger.Log(string.Format("FaustManager.RunMigration: {0}", migrationHistory.Log), TraceEventType.Error); break; } } if (Transaction.Current != null) { releaseScope.Complete(); Console.WriteLine("##teamcity[message text='FAUSTing completed without errors.']"); } UnityCache.Resolve <IFaustEngine>().SaveMigrationsHistory(migrationHistories.ToArray(), userContext); } } }
public Expression <Func <FaustMigrationHistory, bool> > SearchCriteriaExpression(FaustMigrationHistory searchCriteria, Expression <Func <FaustMigrationHistory, bool> > predicate) { if (searchCriteria.FaustMigrationHistoryId > 0) { predicate = predicate.And(migration => migration.FaustMigrationHistoryId == searchCriteria.FaustMigrationHistoryId); } if (searchCriteria.ReleaseNumber != default(int)) { predicate = predicate.And(migration => migration.ReleaseNumber == searchCriteria.ReleaseNumber); } if (!string.IsNullOrEmpty(searchCriteria.ScriptName)) { predicate = predicate.And(migration => migration.ScriptName == searchCriteria.ScriptName); } if (searchCriteria.LastRun != null && searchCriteria.LastRun != DateTime.MinValue) { predicate = predicate.And(migration => migration.LastRun == searchCriteria.LastRun); } if (searchCriteria.Successful != null) { predicate = predicate.And(migration => migration.Successful == searchCriteria.Successful); } if (searchCriteria.Committed != null) { predicate = predicate.And(migration => migration.Committed == searchCriteria.Committed); } return(predicate); }