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