private void PushDummyMigrationHistoryMessage()
{
var migrationHistoryRow = new MigrationHistoryRow {
Prefix = "test"
};
migrationHistoryRow.AppliedMigrations.Add(new MigrationHistoryRowDetails
{
Name = "001_TestMigration",
Hash = "a0b87bef6d840b00ac344eb2a204442760794512bb8bc0873b63d8c7d5849e9f",
DownOperations = new List <BaseOperation>
{
new DeleteQueueOperation().SetName("bar"),
new DeleteExchangeOperation().SetName("foo")
}
});
var migrationHistory = new MigrationHistory();
migrationHistory.AllMigrations.Add(migrationHistoryRow);
using (var connection = _connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
var messageBody = JsonConvertHelper.SerializeObjectToByteArray(migrationHistory);
channel.BasicPublish("", Constants.HistoryQueue, false, null, messageBody);
}
}
public void RunDeploymentScript(DeploymentScript script)
{
try
{
if (_db.Exists <MigrationHistory>(script.Name))
{
Log.Debug($"Migration {script.Name} has already been executed");
return;
}
Log.Info($"Processing migration {script.Name}");
_db.BeginTransaction();
var migration = new MigrationHistory
{
ScriptName = script.Name,
Completed = false,
DateProcessed = DateTime.Now
};
_db.Insert(migration);
_db.CompleteTransaction();
_db.Execute(script.Sql);
migration.Completed = true;
_db.Save(migration);
}
catch (Exception ex)
{
_db.AbortTransaction();
Log.Error($"Failed to run deployment migration {script.Name}", ex);
throw;
}
}
private MigrationHistory LoadMigrationHistory()
{
var ids = ExecuteSqlQuery($"SELECT database_id FROM master.sys.databases WHERE name = '{_databaseName}'",
row => (int)row["database_id"]);
if (ids.Any())
{
var rows = ExecuteSqlQuery($@"SELECT h.[Type], h.[HashCode], h.[Attributes], j.[Role], p.[HashCode] AS [PrerequisiteHashCode]
FROM [{_databaseName}].[dbo].[__MergableMigrationHistory] h
LEFT JOIN [{_databaseName}].[dbo].[__MergableMigrationHistoryPrerequisite] j
ON h.MigrationId = j.MigrationId
LEFT JOIN [{_databaseName}].[dbo].[__MergableMigrationHistory] p
ON j.PrerequisiteMigrationId = p.MigrationId
ORDER BY h.MigrationId, j.Role, p.MigrationId",
row => new MigrationHistoryRow
{
Type = LoadString(row["Type"]),
HashCode = LoadBigInteger(row["HashCode"]),
Attributes = LoadString(row["Attributes"]),
Role = LoadString(row["Role"]),
PrerequisiteHashCode = LoadBigInteger(row["PrerequisiteHashCode"])
});
return(MigrationHistory.LoadMementos(LoadMementos(rows)));
}
else
{
return(new MigrationHistory());
}
}
public void IsMigrationItemEqualsToHistory()
{
//arrange
var step = new TestStep(ExecutionResult.Success);
var positiveCaseStepName = MigrationHandler.StepIdentity(step);
var positiveCaseVersion = new Version("1.2.3.4");
var negativeCaseVersion = new Version("4.3.2.1");
var migrationItem = new MigrationItem(positiveCaseVersion, new TestStep(ExecutionResult.Success));
var migrationHistory = new MigrationHistory
{
Name = positiveCaseStepName,
Version = positiveCaseVersion.ToString()
};
//act
var positiveCase = MigrationHandler.IsMigrationItemEqualsToHistory(migrationItem, migrationHistory);
migrationHistory.Version = negativeCaseVersion.ToString();
var negativeCase1 = MigrationHandler.IsMigrationItemEqualsToHistory(migrationItem, migrationHistory);
migrationHistory.Version = positiveCaseVersion.ToString();
migrationHistory.Name = String.Empty;
var negativeCase2 = MigrationHandler.IsMigrationItemEqualsToHistory(migrationItem, migrationHistory);
//assert
Assert.True(positiveCase && !negativeCase1 && !negativeCase2);
}
public static MigrationHistoryViewModel MapDbModelToViewModel(MigrationHistory dbModel)
{
var viewModel = new MigrationHistoryViewModel();
viewModel.MigrationId = dbModel.MigrationId;
viewModel.ContextKey = dbModel.ContextKey;
viewModel.Model = dbModel.Model;
viewModel.ProductVersion = dbModel.ProductVersion;
return(viewModel);
}
public void Create(string name, Version version)
{
var migrationHistory = new MigrationHistory
{
Name = name,
Version = version.ToString(),
CreateDate = DateTime.Now
};
_migrationHistoryRepository.Add(migrationHistory);
}
public async Task CreateHistoryAsync(MigrationHistory history, CancellationToken cancellationToken = default)
{
var prepare = await this.session.PrepareAsync("INSERT INTO migrations (major, minor, time) VALUES (?, ?, ?)");
var statement = prepare.Bind(
Convert.ToInt16(history.Version.Major),
Convert.ToInt16(history.Version.Minor),
history.AppliedTime.ToUniversalTime());
await this.session.ExecuteAsync(statement);
}
public async Task <bool> HasHistory(IAppMigration migrationInfo)
{
if (TryTestForTable(_historyTableName) == false)
{
return(false);
}
// else
return(await MigrationHistory.AnyAsync(x =>
x.Id == migrationInfo.Id &&
x.Migration == migrationInfo.Migration
));
}
public static MigrationHistory MapInsertModelToDbModel(MigrationHistoryViewModel model, MigrationHistory newDomainModel = null)
{
if (newDomainModel == null)
{
newDomainModel = new MigrationHistory();
}
newDomainModel.MigrationId = model.MigrationId;
newDomainModel.ContextKey = model.ContextKey;
newDomainModel.Model = model.Model;
newDomainModel.ProductVersion = model.ProductVersion;
return(newDomainModel);
}
public MigrationHistory Migrate(Session session)
{
History = new MigrationHistory {
FromRevision = From,
ToRevision = To,
Applied = DateTime.UtcNow,
};
Session = session;
var docs = Session.ListDocuments();
foreach (var d in docs)
{
Migrate(d);
}
return History;
}
public void LogHistory(IAppMigration migrationInfo, MigrationResult result, DateTime started, DateTime finished)
{
var migrationRecord = new MigrationRecord()
{
Id = migrationInfo.Id,
Migration = migrationInfo.Migration,
Executed = started,
Duration = finished.Subtract(started).Milliseconds,
Result = result.Status.ToString(),
StatusCode = (int)result.Status,
Message = result.Message
};
MigrationHistory.Add(migrationRecord);
}
public MigrationHistory Migrate(Session session)
{
History = new MigrationHistory {
FromRevision = From,
ToRevision = To,
Applied = DateTime.UtcNow,
};
Session = session;
var docs = Session.ListDocuments();
foreach (var d in docs)
{
Migrate(d);
}
return(History);
}
private void PushDummyMigrationHistoryMessage()
{
var migrationHistoryRow = new MigrationHistoryRow {
Prefix = "test"
};
var migrationHistory = new MigrationHistory {
Version = 3
};
migrationHistory.AllMigrations.Add(migrationHistoryRow);
using (var connection = _connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
var messageBody = JsonConvertHelper.SerializeObjectToByteArray(migrationHistory);
channel.BasicPublish("", Constants.HistoryQueue, false, null, messageBody);
}
}
private void PushDummyMigrationHistoryMessage()
{
var migrationHistoryRow = new MigrationHistoryRow {
Prefix = "test"
};
migrationHistoryRow.AppliedMigrations.Add("001_TestMigration");
var migrationHistory = new MigrationHistory();
migrationHistory.AllMigrations.Add(migrationHistoryRow);
using (var connection = _connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
var messageBody = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(migrationHistory));
channel.BasicPublish("", Constants.HistoryQueue, false, null, messageBody);
}
}
internal static MigrationHistory UpdateMigrationHistory([NotNull] this ICassandraMigrator self, [NotNull] Table <MigrationHistory> table, [NotNull] IMigrator migration)
{
Check.NotNull(self, $"the argument [Cassandra Migrator]");
Check.NotNull(table, $"the argument [Migration History]");
Check.NotNull(migration, $"the argument [Migration]");
var result = new MigrationHistory
{
Name = migration.Name,
Version = migration.Version.ToString(),
CreatedAt = DateTime.UtcNow,
Description = migration.Description,
};
table
.Insert(result)
.Execute();
return(result);
}
public void CanGenerateSql()
{
var migrations = new Genome();
var migrationHistory = new MigrationHistory();
var sql = WhenGenerateSql(migrations, migrationHistory);
sql.Should().Contain(@"CREATE TABLE [Mathematicians].[dbo].[Mathematician](
[MathematicianId] INT IDENTITY (1,1) NOT NULL,
CONSTRAINT [PK_Mathematician] PRIMARY KEY CLUSTERED ([MathematicianId]),
[Name] NVARCHAR(100) NOT NULL,
[BirthYear] INT NOT NULL,
[DeathYear] INT NULL)");
sql.Should().Contain(@"CREATE TABLE [Mathematicians].[dbo].[Contribution](
[ContributionId] INT IDENTITY (1,1) NOT NULL,
CONSTRAINT [PK_Contribution] PRIMARY KEY CLUSTERED ([ContributionId]),
[MathematicianId] INT NOT NULL,
[Description] NVARCHAR(500) NOT NULL,
INDEX [IX_Contribution_MathematicianId] NONCLUSTERED ([MathematicianId]),
CONSTRAINT [FK_Contribution_MathematicianId] FOREIGN KEY ([MathematicianId])
REFERENCES [Mathematicians].[dbo].[Mathematician] ([MathematicianId]))");
}
private static string[] WhenGenerateRollbackSql(IGenome migrations, MigrationHistory migrationHistory)
{
var sqlGenerator = new SqlGenerator(migrations, migrationHistory);
return(sqlGenerator.GenerateRollbackSql("Mathematicians"));
}
public SqlGenerator(IGenome migrations, MigrationHistory migrationHistory)
{
_migrations = migrations;
_migrationHistory = migrationHistory;
}
private MigrationHistory WhenLoadMigrationHistory(MigrationMemento[] mementos)
{
return(MigrationHistory.LoadMementos(mementos));
}
