public static Int64 GetValueTypeHashKey64(object obj)
{
if (obj is IUnique)
{
return(((IUnique)obj).KeyBlock);
}
Type t = obj.GetType();
if (t.IsPrimitive)
{
byte *ps = stackalloc byte[8];
Marshal.StructureToPtr(obj, (IntPtr)ps, false);
return(*(long *)ps);
}
if (obj is DateTime)
{
return(((DateTime)obj).ToBinary());
}
if (obj is Enum)
{
return(Convert.ToInt32(obj));
}
if (t.IsLayoutSequential)
{
byte *ps = stackalloc byte[8];
ExtractOperation.ValueStructureToPointer(obj, ps, 0);
return(*(long *)ps);
}
return((long)HashHandle64.ComputeHashCode(obj.GetBytes()));
}
private static void ExtractOperation_Completed(ExtractOperation sender, CompletedEventArgs e)
{
#if DEBUG
_debugStopwatch.Stop();
Console.WriteLine($"Extraction complete. {_debugStopwatch.ElapsedMilliseconds}ms elapsed");
#endif
ExtractingArchives.RemoveAll(x => sender.Archives.Contains(x));
sender.ProgressForm.BlockClose = false;
sender.ProgressForm.Close();
if (sender.ProgressForm.Owner != null && sender.TitleProgress)
{
sender.ProgressForm.Owner.Text = sender.OriginalTitle;
}
// Save exceptions to _report.txt file in destination path
if (e?.Exceptions.Count > 0)
{
var sb = new StringBuilder();
sb.AppendLine($"{sender.Files[0].Archive.FileName} - RetrieveRealSize: {sender.Files[0].Archive.RetrieveRealSize}");
sb.AppendLine();
foreach (var ex in e.Exceptions)
{
sb.AppendLine($"{ex.ArchiveEntry.FullPath}{Environment.NewLine}{ex.Exception}{Environment.NewLine}");
}
File.WriteAllText(Path.Combine(sender.Folder, "_report.txt"), sb.ToString());
MessageBox.Show(sender.ProgressForm.Owner, $"{e.Exceptions.Count} file(s) failed to extract. See report file in destination for details.", "Error");
}
}
public async void ExtractDacpac()
{
var result = GetLiveAutoCompleteTestObjects();
SqlTestDb testdb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxExtractTest");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
try
{
var extractParams = new ExtractParams
{
DatabaseName = testdb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", testdb.DatabaseName)),
ApplicationName = "test",
ApplicationVersion = "1.0.0.0"
};
DacFxService service = new DacFxService();
ExtractOperation operation = new ExtractOperation(extractParams, result.ConnectionInfo);
service.PerformOperation(operation, TaskExecutionMode.Execute);
VerifyAndCleanup(extractParams.PackageFilePath);
}
finally
{
testdb.Cleanup();
}
}
private async Task <Mock <RequestContext <DacFxResult> > > SendAndValidateExtractRequest()
{
var result = GetLiveAutoCompleteTestObjects();
var requestContext = new Mock <RequestContext <DacFxResult> >();
requestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));
SqlTestDb testdb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxExtractTest");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
var extractParams = new ExtractParams
{
DatabaseName = testdb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", testdb.DatabaseName)),
ApplicationName = "test",
ApplicationVersion = "1.0.0.0"
};
DacFxService service = new DacFxService();
ExtractOperation operation = new ExtractOperation(extractParams, result.ConnectionInfo);
service.PerformOperation(operation);
// cleanup
VerifyAndCleanup(extractParams.PackageFilePath);
testdb.Cleanup();
return(requestContext);
}
public static Int32 GetValueTypeHashKey32(object obj)
{
if (obj is IUnique)
{
return(((IUnique)obj).GetKeyBytes().BitAggregate64to32().ToInt32());
}
if (obj.GetType().IsPrimitive)
{
byte *ps = stackalloc byte[8];
Marshal.StructureToPtr(obj, (IntPtr)ps, false);
return(BitAggregate64to32(ps));
}
if (obj is DateTime)
{
return(((DateTime)obj).ToBinary().GetBytes().BitAggregate64to32().ToInt32());
}
if (obj is Enum)
{
return(Convert.ToInt32(obj));
}
if (obj.GetType().IsLayoutSequential)
{
byte *ps = stackalloc byte[8];
ExtractOperation.ValueStructureToPointer(obj, ps, 0);
return(BitAggregate64to32(ps));
}
return((int)HashHandle32.ComputeHashCode(obj.GetBytes()));
}
private static void ExtractOperation_ProgressPercentageUpdate(ExtractOperation sender, ProgressPercentageUpdateEventArgs e)
{
if (sender.ProgressForm.Owner != null && sender.TitleProgress)
{
sender.ProgressForm.Owner.Text = $"{e.ProgressPercentage}% - {sender.OriginalTitle}";
}
sender.ProgressForm.Progress = e.ProgressPercentage;
sender.ProgressForm.Description = sender.ProgressForm.Description.Split('\n')[0] + "\n" + Common.FormatTimeRemaining(e.RemainingEstimate);
}
private async Task <Mock <RequestContext <DacFxResult> > > SendAndValidateGenerateDeployScriptRequest()
{
// first extract a dacpac
var result = GetLiveAutoCompleteTestObjects();
var extractRequestContext = new Mock <RequestContext <DacFxResult> >();
extractRequestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxGenerateScriptTest");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
var extractParams = new ExtractParams
{
DatabaseName = sourceDb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
ApplicationName = "test",
ApplicationVersion = "1.0.0.0"
};
DacFxService service = new DacFxService();
ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
service.PerformOperation(extractOperation);
// generate script
var generateScriptRequestContext = new Mock <RequestContext <DacFxResult> >();
generateScriptRequestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));
var generateScriptParams = new GenerateDeployScriptParams
{
PackageFilePath = extractParams.PackageFilePath,
DatabaseName = string.Concat(sourceDb.DatabaseName, "-deployed"),
ScriptFilePath = Path.Combine(folderPath, string.Concat(sourceDb.DatabaseName, "_", "UpgradeDACScript.sql"))
};
GenerateDeployScriptOperation generateScriptOperation = new GenerateDeployScriptOperation(generateScriptParams, result.ConnectionInfo);
service.PerformOperation(generateScriptOperation);
SqlTestDb targetDb = SqlTestDb.CreateFromExisting(generateScriptParams.DatabaseName);
// cleanup
VerifyAndCleanup(generateScriptParams.ScriptFilePath);
VerifyAndCleanup(extractParams.PackageFilePath);
sourceDb.Cleanup();
targetDb.Cleanup();
return(generateScriptRequestContext);
}
private async Task <Mock <RequestContext <DacFxResult> > > SendAndValidateGenerateDeployPlanRequest()
{
var result = GetLiveAutoCompleteTestObjects();
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "DacFxGenerateDeployPlanTest");
DacFxService service = new DacFxService();
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
var extractParams = new ExtractParams
{
DatabaseName = sourceDb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
ApplicationName = "test",
ApplicationVersion = "1.0.0.0"
};
ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
service.PerformOperation(extractOperation);
// generate deploy plan for deploying dacpac to targetDb
var generateDeployPlanRequestContext = new Mock <RequestContext <DacFxResult> >();
generateDeployPlanRequestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));
SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, TargetScript, "DacFxGenerateDeployPlanTestTarget");
var generateDeployPlanParams = new GenerateDeployPlanParams
{
PackageFilePath = extractParams.PackageFilePath,
DatabaseName = targetDb.DatabaseName,
};
GenerateDeployPlanOperation generateDeployPlanOperation = new GenerateDeployPlanOperation(generateDeployPlanParams, result.ConnectionInfo);
service.PerformOperation(generateDeployPlanOperation);
string report = generateDeployPlanOperation.DeployReport;
Assert.NotNull(report);
Assert.Contains("Create", report);
Assert.Contains("Drop", report);
Assert.Contains("Alter", report);
// cleanup
VerifyAndCleanup(extractParams.PackageFilePath);
sourceDb.Cleanup();
targetDb.Cleanup();
return(generateDeployPlanRequestContext);
}
private async Task <Mock <RequestContext <DacFxResult> > > SendAndValidateDeployRequest()
{
// first extract a db to have a dacpac to import later
var result = GetLiveAutoCompleteTestObjects();
var extractRequestContext = new Mock <RequestContext <DacFxResult> >();
extractRequestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxDeployTest");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
var extractParams = new ExtractParams
{
DatabaseName = sourceDb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
ApplicationName = "test",
ApplicationVersion = new Version(1, 0)
};
SqlConnection sqlConn = ConnectionService.OpenSqlConnection(result.ConnectionInfo, "Deploy");
DacFxService service = new DacFxService();
ExtractOperation extractOperation = new ExtractOperation(extractParams, sqlConn);
service.PerformOperation(extractOperation);
// deploy the created dacpac
var deployRequestContext = new Mock <RequestContext <DacFxResult> >();
deployRequestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));
var deployParams = new DeployParams
{
PackageFilePath = extractParams.PackageFilePath,
DatabaseName = string.Concat(sourceDb.DatabaseName, "-deployed"),
UpgradeExisting = false
};
DeployOperation deployOperation = new DeployOperation(deployParams, sqlConn);
service.PerformOperation(deployOperation); SqlTestDb targetDb = SqlTestDb.CreateFromExisting(deployParams.DatabaseName);
// cleanup
VerifyAndCleanup(extractParams.PackageFilePath);
sourceDb.Cleanup();
targetDb.Cleanup();
return(deployRequestContext);
}
public async void GenerateDeployPlan()
{
var result = GetLiveAutoCompleteTestObjects();
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "DacFxGenerateDeployPlanTest");
SqlTestDb targetDb = null;
DacFxService service = new DacFxService();
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
try
{
var extractParams = new ExtractParams
{
DatabaseName = sourceDb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
ApplicationName = "test",
ApplicationVersion = "1.0.0.0"
};
ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
service.PerformOperation(extractOperation, TaskExecutionMode.Execute);
// generate deploy plan for deploying dacpac to targetDb
targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, TargetScript, "DacFxGenerateDeployPlanTestTarget");
var generateDeployPlanParams = new GenerateDeployPlanParams
{
PackageFilePath = extractParams.PackageFilePath,
DatabaseName = targetDb.DatabaseName,
};
GenerateDeployPlanOperation generateDeployPlanOperation = new GenerateDeployPlanOperation(generateDeployPlanParams, result.ConnectionInfo);
service.PerformOperation(generateDeployPlanOperation, TaskExecutionMode.Execute);
string report = generateDeployPlanOperation.DeployReport;
Assert.NotNull(report);
Assert.Contains("Create", report);
Assert.Contains("Drop", report);
Assert.Contains("Alter", report);
VerifyAndCleanup(extractParams.PackageFilePath);
}
finally
{
sourceDb.Cleanup();
if (targetDb != null)
{
targetDb.Cleanup();
}
}
}
public async void GenerateDeployScript()
{
// first extract a dacpac
var result = GetLiveAutoCompleteTestObjects();
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "DacFxGenerateScriptTest");
SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxGenerateScriptTest");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
try
{
var extractParams = new ExtractParams
{
DatabaseName = sourceDb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
ApplicationName = "test",
ApplicationVersion = "1.0.0.0"
};
DacFxService service = new DacFxService();
ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
service.PerformOperation(extractOperation, TaskExecutionMode.Execute);
// generate script
var generateScriptParams = new GenerateDeployScriptParams
{
PackageFilePath = extractParams.PackageFilePath,
DatabaseName = targetDb.DatabaseName
};
// Generate script for deploying source dacpac to target db
GenerateDeployScriptOperation generateScriptOperation = new GenerateDeployScriptOperation(generateScriptParams, result.ConnectionInfo);
service.PerformOperation(generateScriptOperation, TaskExecutionMode.Script);
// Verify script was generated
Assert.NotEmpty(generateScriptOperation.Result.DatabaseScript);
Assert.Contains("CREATE TABLE", generateScriptOperation.Result.DatabaseScript);
VerifyAndCleanup(extractParams.PackageFilePath);
}
finally
{
sourceDb.Cleanup();
targetDb.Cleanup();
}
}
public async void DeployDacpac()
{
// first extract a db to have a dacpac to import later
var result = GetLiveAutoCompleteTestObjects();
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxDeployTest");
SqlTestDb targetDb = null;
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
try
{
var extractParams = new ExtractParams
{
DatabaseName = sourceDb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
ApplicationName = "test",
ApplicationVersion = "1.0.0.0"
};
DacFxService service = new DacFxService();
ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
service.PerformOperation(extractOperation, TaskExecutionMode.Execute);
// deploy the created dacpac
var deployParams = new DeployParams
{
PackageFilePath = extractParams.PackageFilePath,
DatabaseName = string.Concat(sourceDb.DatabaseName, "-deployed"),
UpgradeExisting = false
};
DeployOperation deployOperation = new DeployOperation(deployParams, result.ConnectionInfo);
service.PerformOperation(deployOperation, TaskExecutionMode.Execute);
targetDb = SqlTestDb.CreateFromExisting(deployParams.DatabaseName);
VerifyAndCleanup(extractParams.PackageFilePath);
}
finally
{
sourceDb.Cleanup();
if (targetDb != null)
{
targetDb.Cleanup();
}
}
}
private string InitialExtract(DacFxService service, SqlTestDb sourceDb, LiveConnectionHelper.TestConnectionResult result)
{
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
var extractParams = new ExtractParams
{
DatabaseName = sourceDb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
ApplicationName = "test",
ApplicationVersion = "1.0.0.0"
};
ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
service.PerformOperation(extractOperation, TaskExecutionMode.Execute);
return(extractParams.PackageFilePath);
}
public async void ExtractDBToFlatTarget()
{
var result = GetLiveAutoCompleteTestObjects();
SqlTestDb testdb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, doNotCleanupDb : false, databaseName : null, query : SourceScript, dbNamePrefix : "DacFxExtractDBToFlatTarget");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest", "FlatExtract");
Directory.CreateDirectory(folderPath);
try
{
var extractParams = new ExtractParams
{
DatabaseName = testdb.DatabaseName,
PackageFilePath = folderPath,
ApplicationName = "test",
ApplicationVersion = "1.0.0.0",
ExtractTarget = DacExtractTarget.Flat
};
DacFxService service = new DacFxService();
ExtractOperation operation = new ExtractOperation(extractParams, result.ConnectionInfo);
service.PerformOperation(operation, TaskExecutionMode.Execute);
// Verify two sql files are generated in the target folder path
int actualCnt = Directory.GetFiles(folderPath, "*.sql", SearchOption.AllDirectories).Length;
Assert.Equal(actualCnt, 2);
// Remove the directory
if (Directory.Exists(folderPath))
{
Directory.Delete(folderPath, true);
}
}
finally
{
testdb.Cleanup();
}
}
internal static string CreateDacpac(SqlTestDb testdb)
{
var result = GetLiveAutoCompleteTestObjects();
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "SchemaCompareTest");
Directory.CreateDirectory(folderPath);
var extractParams = new ExtractParams
{
DatabaseName = testdb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", testdb.DatabaseName)),
ApplicationName = "test",
ApplicationVersion = "1.0.0.0"
};
DacFxService service = new DacFxService();
ExtractOperation operation = new ExtractOperation(extractParams, result.ConnectionInfo);
service.PerformOperation(operation, TaskExecutionMode.Execute);
return(extractParams.PackageFilePath);
}
public static Byte[] GetValueTypeHashBytes64(object obj)
{
if (obj is IUnique)
{
return(((IUnique)obj).GetKeyBytes());
}
if (obj.GetType().IsPrimitive)
{
byte[] s = new byte[8];
fixed(byte *ps = s)
{
Marshal.StructureToPtr(obj, (IntPtr)ps, false);
return(s);
}
}
if (obj is DateTime)
{
return(((DateTime)obj).ToBinary().GetBytes());
}
if (obj is Enum)
{
return(Convert.ToInt32(obj).GetBytes());
}
if (obj.GetType().IsLayoutSequential)
{
byte[] s = new byte[8];
fixed(byte *ps = s)
{
ExtractOperation.ValueStructureToPointer(obj, ps, 0);
return(s);
}
}
return(((long)HashHandle64.ComputeHashCode(obj.GetBytes())).GetBytes());
}
/// <summary>
/// Extracts the given file(s) to the given path.
/// </summary>
/// <param name="folder">The path to extract files to.</param>
/// <param name="useFolderPath">True to use full folder path for files, false to extract straight to path.</param>
/// <param name="gui">True to show a <see cref="ProgressForm"/>.</param>
/// <param name="files">The files in the selected archive to extract.</param>
public static void ExtractFiles(Form owner,
string folder,
bool useFolderPath,
bool gui,
List <ArchiveEntry> files,
ProgressForm progressForm = null,
bool titleProgress = false)
{
// Store all unique archives to prevent extracting same archive across multiple operations at the same time
var archives = files.Select(x => x.Archive.FullPath.ToLower()).Distinct();
if (ExtractingArchives.Any(x => archives.Contains(x)))
{
MessageBox.Show(owner,
"One or more archives are already being extracted from, try again later.",
"BSA Browser",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return;
}
// Check for unsupported textures and prompt the user what to do if there is any
if (CheckAndHandleUnsupportedTextures(owner, files) == DialogResult.Cancel)
{
return;
}
if (gui)
{
progressForm = progressForm ?? new ProgressForm(files.Count);
var operation = new ExtractOperation(folder, files, useFolderPath)
{
Archives = archives,
ProgressForm = progressForm,
TitleProgress = titleProgress,
OriginalTitle = owner?.Text
};
operation.StateChange += ExtractOperation_StateChange;
operation.ProgressPercentageUpdate += ExtractOperation_ProgressPercentageUpdate;
operation.Completed += ExtractOperation_Completed;
progressForm.Owner = owner;
progressForm.Canceled += delegate { operation.Cancel(); };
#if DEBUG
// Track extraction speed
_debugStopwatch.Restart();
#endif
operation.Start();
progressForm.Show(owner);
ExtractingArchives.AddRange(archives);
}
else
{
try
{
foreach (var fe in files)
{
fe.Extract(folder, useFolderPath);
}
}
catch (Exception ex)
{
MessageBox.Show(owner, ex.Message, "Error");
}
}
}
public void ExtractParseVersionShouldThrowExceptionGivenInvalidVersion()
{
string invalidVersion = "invalidVerison";
Assert.Throws <ArgumentException>(() => ExtractOperation.ParseVersion(invalidVersion));
}
private static void ExtractOperation_StateChange(ExtractOperation sender, StateChangeEventArgs e)
{
sender.ProgressForm.Description = e.FileName + '\n' + Common.FormatTimeRemaining(sender.EstimateTimeRemaining);
sender.ProgressForm.Footer = $"({e.Count}/{e.FilesTotal}) {Common.FormatBytes(sender.SpeedBytes)}/s";
}
