ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-01-14 01:25:40 -05:00
Code Issues Packages Projects Releases Wiki Activity

Add schema compare publish changes operation (#795)

Browse Source 
* add schema compare publish changes operation
This commit is contained in:
kisantia
2019-04-09 15:04:59 -07:00
committed by GitHub
parent 8ba59859dc
commit 213fe4ab37
10 changed files with 449 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/Microsoft.SqlTools.ServiceLayer/DacFx/DacFxService.cs
View File

@@ -67,7 +67,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
if (connInfo != null)
{
ExportOperation operation = new ExportOperation(parameters, connInfo);
await ExecuteOperation(operation, parameters, "Export bacpac", requestContext);
await ExecuteOperation(operation, parameters, SR.ExportBacpacTaskName, requestContext);
}
}
catch (Exception e)
@@ -91,7 +91,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
if (connInfo != null)
{
ImportOperation operation = new ImportOperation(parameters, connInfo);
await ExecuteOperation(operation, parameters, "Import bacpac", requestContext);
await ExecuteOperation(operation, parameters, SR.ImportBacpacTaskName, requestContext);
}
}
catch (Exception e)
@@ -115,7 +115,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
if (connInfo != null)
{
ExtractOperation operation = new ExtractOperation(parameters, connInfo);
await ExecuteOperation(operation, parameters, "Extract dacpac", requestContext);
await ExecuteOperation(operation, parameters, SR.ExtractDacpacTaskName, requestContext);
}
}
catch (Exception e)
@@ -139,7 +139,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
if (connInfo != null)
{
DeployOperation operation = new DeployOperation(parameters, connInfo);
await ExecuteOperation(operation, parameters, "Deploy dacpac", requestContext);
await ExecuteOperation(operation, parameters, SR.DeployDacpacTaskName, requestContext);
}
}
catch (Exception e)
@@ -164,7 +164,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
{
GenerateDeployScriptOperation operation = new GenerateDeployScriptOperation(parameters, connInfo);
SqlTask sqlTask = null;
TaskMetadata metadata = TaskMetadata.Create(parameters, "Generate script", operation, ConnectionServiceInstance);
TaskMetadata metadata = TaskMetadata.Create(parameters, SR.GenerateScriptTaskName, operation, ConnectionServiceInstance);
// want to show filepath in task history instead of server and database
metadata.ServerName = parameters.ScriptFilePath;

66
src/Microsoft.SqlTools.ServiceLayer/Localization/sr.cs
View File

@@ -2869,6 +2869,46 @@ namespace Microsoft.SqlTools.ServiceLayer
}
}
public static string ExportBacpacTaskName
{
get
{
return Keys.GetString(Keys.ExportBacpacTaskName);
}
}
public static string ImportBacpacTaskName
{
get
{
return Keys.GetString(Keys.ImportBacpacTaskName);
}
}
public static string ExtractDacpacTaskName
{
get
{
return Keys.GetString(Keys.ExtractDacpacTaskName);
}
}
public static string DeployDacpacTaskName
{
get
{
return Keys.GetString(Keys.DeployDacpacTaskName);
}
}
public static string GenerateScriptTaskName
{
get
{
return Keys.GetString(Keys.GenerateScriptTaskName);
}
}
public static string ExtractInvalidVersion
{
get
@@ -2877,6 +2917,14 @@ namespace Microsoft.SqlTools.ServiceLayer
}
}
public static string PublishChangesTaskName
{
get
{
return Keys.GetString(Keys.PublishChangesTaskName);
}
}
public static string ConnectionServiceListDbErrorNotConnected(string uri)
{
return Keys.GetString(Keys.ConnectionServiceListDbErrorNotConnected, uri);
@@ -4190,9 +4238,27 @@ namespace Microsoft.SqlTools.ServiceLayer
public const string Error_ExistingDirectoryName = "Error_ExistingDirectoryName";
public const string ExportBacpacTaskName = "ExportBacpacTaskName";
public const string ImportBacpacTaskName = "ImportBacpacTaskName";
public const string ExtractDacpacTaskName = "ExtractDacpacTaskName";
public const string DeployDacpacTaskName = "DeployDacpacTaskName";
public const string GenerateScriptTaskName = "GenerateScriptTaskName";
public const string ExtractInvalidVersion = "ExtractInvalidVersion";
public const string PublishChangesTaskName = "PublishChangesTaskName";
private Keys()
{ }

24
src/Microsoft.SqlTools.ServiceLayer/Localization/sr.resx
View File

@@ -1687,8 +1687,32 @@
<value>For directory {0} a file with name {1} already exist</value>
<comment></comment>
</data>
<data name="ExportBacpacTaskName" xml:space="preserve">
<value>Export bacpac</value>
<comment></comment>
</data>
<data name="ImportBacpacTaskName" xml:space="preserve">
<value>Import bacpac</value>
<comment></comment>
</data>
<data name="ExtractDacpacTaskName" xml:space="preserve">
<value>Extract dacpac</value>
<comment></comment>
</data>
<data name="DeployDacpacTaskName" xml:space="preserve">
<value>Deploy dacpac</value>
<comment></comment>
</data>
<data name="GenerateScriptTaskName" xml:space="preserve">
<value>Generate script</value>
<comment></comment>
</data>
<data name="ExtractInvalidVersion" xml:space="preserve">
<value>Invalid version '{0}' passed. Version must be in the format x.x.x.x where x is a number.</value>
<comment></comment>
</data>
<data name="PublishChangesTaskName" xml:space="preserve">
<value>Apply schema compare changes</value>
<comment></comment>
</data>
</root>

11
src/Microsoft.SqlTools.ServiceLayer/Localization/sr.strings
View File

@@ -786,4 +786,13 @@ Error_ExistingDirectoryName = For directory {0} a file with name {1} already exi
############################################################################
# DacFx
ExtractInvalidVersion = Invalid version '{0}' passed. Version must be in the format x.x.x.x where x is a number.
ExportBacpacTaskName = Export bacpac
ImportBacpacTaskName = Import bacpac
ExtractDacpacTaskName = Extract dacpac
DeployDacpacTaskName = Deploy dacpac
GenerateScriptTaskName = Generate script
ExtractInvalidVersion = Invalid version '{0}' passed. Version must be in the format x.x.x.x where x is a number.
############################################################################
# Schema Compare
PublishChangesTaskName = Apply schema compare changes

30
src/Microsoft.SqlTools.ServiceLayer/Localization/sr.xlf
View File

@@ -1961,6 +1961,36 @@
<target state="new">Invalid version '{0}' passed. Version must be in the format x.x.x.x where x is a number.</target>
<note></note>
</trans-unit>
<trans-unit id="ExportBacpacTaskName">
<source>Export bacpac</source>
<target state="new">Export bacpac</target>
<note></note>
</trans-unit>
<trans-unit id="ImportBacpacTaskName">
<source>Import bacpac</source>
<target state="new">Import bacpac</target>
<note></note>
</trans-unit>
<trans-unit id="ExtractDacpacTaskName">
<source>Extract dacpac</source>
<target state="new">Extract dacpac</target>
<note></note>
</trans-unit>
<trans-unit id="DeployDacpacTaskName">
<source>Deploy dacpac</source>
<target state="new">Deploy dacpac</target>
<note></note>
</trans-unit>
<trans-unit id="GenerateScriptTaskName">
<source>Generate script</source>
<target state="new">Generate script</target>
<note></note>
</trans-unit>
<trans-unit id="PublishChangesTaskName">
<source>Apply schema compare changes</source>
<target state="new">Apply schema compare changes</target>
<note></note>
</trans-unit>
</body>
</file>
</xliff>

17
src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/Contracts/SchemaCompareGenerateScriptRequest.cs
View File

@@ -13,27 +13,12 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare.Contracts
/// <summary>
/// Parameters for a schema compare generate script request.
/// </summary>
public class SchemaCompareGenerateScriptParams
public class SchemaCompareGenerateScriptParams : SchemaComparePublishChangesParams
{
/// <summary>
/// Operation id of the schema compare operation
/// </summary>
public string OperationId { get; set; }
/// <summary>
/// Name of target database
/// </summary>
public string TargetDatabaseName { get; set; }
/// <summary>
/// Gets or sets the filepath where to save the generated script
/// </summary>
public string ScriptFilePath { get; set; }
/// <summary>
/// Execution mode for the operation. Default is execution
/// </summary>
public TaskExecutionMode TaskExecutionMode { get; set; }
}
/// <summary>

45
src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/Contracts/SchemaComparePublishChangesRequest.cs Normal file
View File

@@ -0,0 +1,45 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlTools.Hosting.Protocol.Contracts;
using Microsoft.SqlTools.ServiceLayer.TaskServices;
using Microsoft.SqlTools.ServiceLayer.Utility;
namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare.Contracts
{
/// <summary>
/// Parameters for a schema compare publish changes request.
/// </summary>
public class SchemaComparePublishChangesParams
{
/// <summary>
/// Operation id of the schema compare operation
/// </summary>
public string OperationId { get; set; }
/// <summary>
/// Name of target server
/// </summary>
public string TargetServerName { get; set; }
/// <summary>
/// Name of target database
/// </summary>
public string TargetDatabaseName { get; set; }
/// <summary>
/// Execution mode for the operation. Default is execution
/// </summary>
public TaskExecutionMode TaskExecutionMode { get; set; }
}
/// <summary>
/// Defines the Schema Compare publish changes request type
/// </summary>
class SchemaComparePublishChangesRequest
{
public static readonly RequestType<SchemaComparePublishChangesParams, ResultStatus> Type =
RequestType<SchemaComparePublishChangesParams, ResultStatus>.Create("schemaCompare/publish");
}
}

73
src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaComparePublishChangesOperation.cs Normal file
View File

@@ -0,0 +1,73 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlServer.Dac.Compare;
using Microsoft.SqlTools.ServiceLayer.SchemaCompare.Contracts;
using Microsoft.SqlTools.ServiceLayer.TaskServices;
using Microsoft.SqlTools.Utility;
using System;
using System.Diagnostics;
using System.IO;
using System.Threading;
namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
{
/// <summary>
/// Class to represent an in-progress schema compare publish changes operation
/// </summary>
class SchemaComparePublishChangesOperation : ITaskOperation
{
private CancellationTokenSource cancellation = new CancellationTokenSource();
private bool disposed = false;
/// <summary>
/// Gets the unique id associated with this instance.
/// </summary>
public string OperationId { get; private set; }
public SchemaComparePublishChangesParams Parameters { get; }
protected CancellationToken CancellationToken { get { return this.cancellation.Token; } }
public string ErrorMessage { get; set; }
public SqlTask SqlTask { get; set; }
public SchemaComparisonResult ComparisonResult { get; set; }
public SchemaComparePublishResult PublishResult { get; set; }
public SchemaComparePublishChangesOperation(SchemaComparePublishChangesParams parameters, SchemaComparisonResult comparisonResult)
{
Validate.IsNotNull("parameters", parameters);
this.Parameters = parameters;
Validate.IsNotNull("comparisonResult", comparisonResult);
this.ComparisonResult = comparisonResult;
}
public void Execute(TaskExecutionMode mode)
{
if (this.CancellationToken.IsCancellationRequested)
{
throw new OperationCanceledException(this.CancellationToken);
}
try
{
this.PublishResult = this.ComparisonResult.PublishChangesToTarget();
}
catch (Exception e)
{
ErrorMessage = e.Message;
Logger.Write(TraceEventType.Error, string.Format("Schema compare publish changes operation {0} failed with exception {1}", this.OperationId, e.Message));
throw;
}
}
// The schema compare public api doesn't currently take a cancellation token so the operation can't be cancelled
public void Cancel()
{
}
}
}

45
src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaCompareService.cs
View File

@@ -43,6 +43,7 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCopmare
{
serviceHost.SetRequestHandler(SchemaCompareRequest.Type, this.HandleSchemaCompareRequest);
serviceHost.SetRequestHandler(SchemaCompareGenerateScriptRequest.Type, this.HandleSchemaCompareGenerateScriptRequest);
serviceHost.SetRequestHandler(SchemaComparePublishChangesRequest.Type, this.HandleSchemaComparePublishChangesRequest);
}
/// <summary>
@@ -83,13 +84,13 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCopmare
Differences = operation.Differences
});
}
catch
catch(Exception e)
{
await requestContext.SendResult(new SchemaCompareResult()
{
OperationId = operation != null ? operation.OperationId : null,
Success = false,
ErrorMessage = operation.ErrorMessage,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
});
@@ -117,7 +118,7 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCopmare
// want to show filepath in task history instead of server and database
metadata.ServerName = parameters.ScriptFilePath;
metadata.DatabaseName = string.Empty;
metadata.Name = "Generate Script";
metadata.Name = SR.GenerateScriptTaskName;
sqlTask = SqlTaskManagerInstance.CreateAndRun<SqlTask>(metadata);
@@ -127,14 +128,50 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCopmare
ErrorMessage = operation.ErrorMessage
});
}
catch
catch (Exception e)
{
await requestContext.SendResult(new ResultStatus()
{
Success = false,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
}
/// <summary>
/// Handles request for schema compare publish changes script
/// </summary>
/// <returns></returns>
public async Task HandleSchemaComparePublishChangesRequest(SchemaComparePublishChangesParams parameters, RequestContext<ResultStatus> requestContext)
{
SchemaComparePublishChangesOperation operation = null;
try
{
SchemaComparisonResult compareResult = schemaCompareResults.Value[parameters.OperationId];
operation = new SchemaComparePublishChangesOperation(parameters, compareResult);
SqlTask sqlTask = null;
TaskMetadata metadata = new TaskMetadata();
metadata.TaskOperation = operation;
metadata.ServerName = parameters.TargetServerName;
metadata.DatabaseName = parameters.TargetDatabaseName;
metadata.Name = SR.PublishChangesTaskName;
sqlTask = SqlTaskManagerInstance.CreateAndRun<SqlTask>(metadata);
await requestContext.SendResult(new ResultStatus()
{
Success = true,
ErrorMessage = operation.ErrorMessage
});
}
catch (Exception e)
{
await requestContext.SendResult(new ResultStatus()
{
Success = false,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
}
private SqlTaskManager SqlTaskManagerInstance

154
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/SchemaCompare/SchemaCompareServiceTests.cs
View File

@@ -301,6 +301,141 @@ CREATE TABLE [dbo].[table3]
return schemaCompareRequestContext;
}
private async Task<Mock<RequestContext<SchemaCompareResult>>> SendAndValidateSchemaComparePublishChangesRequestDacpacToDatabase()
{
var result = GetLiveAutoCompleteTestObjects();
var schemaCompareRequestContext = new Mock<RequestContext<SchemaCompareResult>>();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny<SchemaCompareResult>())).Returns(Task.FromResult(new object()));
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "SchemaCompareSource");
SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "SchemaCompareTarget");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "SchemaCompareTest");
Directory.CreateDirectory(folderPath);
try
{
string sourceDacpacFilePath = CreateDacpac(sourceDb);
SchemaCompareEndpointInfo sourceInfo = new SchemaCompareEndpointInfo();
SchemaCompareEndpointInfo targetInfo = new SchemaCompareEndpointInfo();
sourceInfo.EndpointType = SchemaCompareEndpointType.Dacpac;
sourceInfo.PackageFilePath = sourceDacpacFilePath;
targetInfo.EndpointType = SchemaCompareEndpointType.Database;
targetInfo.DatabaseName = targetDb.DatabaseName;
var schemaCompareParams = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo
};
SchemaCompareOperation schemaCompareOperation = new SchemaCompareOperation(schemaCompareParams, result.ConnectionInfo, result.ConnectionInfo);
schemaCompareOperation.Execute(TaskExecutionMode.Execute);
Assert.True(schemaCompareOperation.ComparisonResult.IsValid);
Assert.False(schemaCompareOperation.ComparisonResult.IsEqual);
Assert.NotNull(schemaCompareOperation.ComparisonResult.Differences);
var enumerator = schemaCompareOperation.ComparisonResult.Differences.GetEnumerator();
enumerator.MoveNext();
Assert.True(enumerator.Current.SourceObject.Name.ToString().Equals("[dbo].[table1]"));
enumerator.MoveNext();
Assert.True(enumerator.Current.SourceObject.Name.ToString().Equals("[dbo].[table2]"));
// update target
var publishChangesParams = new SchemaComparePublishChangesParams
{
TargetDatabaseName = targetDb.DatabaseName,
OperationId = schemaCompareOperation.OperationId,
};
SchemaComparePublishChangesOperation publishChangesOperation = new SchemaComparePublishChangesOperation(publishChangesParams, schemaCompareOperation.ComparisonResult);
publishChangesOperation.Execute(TaskExecutionMode.Execute);
Assert.True(publishChangesOperation.PublishResult.Success);
Assert.Empty(publishChangesOperation.PublishResult.Errors);
// Verify that there are no differences after the publish by running the comparison again
schemaCompareOperation.Execute(TaskExecutionMode.Execute);
Assert.True(schemaCompareOperation.ComparisonResult.IsValid);
Assert.True(schemaCompareOperation.ComparisonResult.IsEqual);
Assert.Empty(schemaCompareOperation.ComparisonResult.Differences);
// cleanup
VerifyAndCleanup(sourceDacpacFilePath);
}
finally
{
sourceDb.Cleanup();
targetDb.Cleanup();
}
return schemaCompareRequestContext;
}
private async Task<Mock<RequestContext<SchemaCompareResult>>> SendAndValidateSchemaComparePublishChangesRequestDatabaseToDatabase()
{
var result = GetLiveAutoCompleteTestObjects();
var schemaCompareRequestContext = new Mock<RequestContext<SchemaCompareResult>>();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny<SchemaCompareResult>())).Returns(Task.FromResult(new object()));
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "SchemaCompareSource");
SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "SchemaCompareTarget");
try
{
SchemaCompareEndpointInfo sourceInfo = new SchemaCompareEndpointInfo();
SchemaCompareEndpointInfo targetInfo = new SchemaCompareEndpointInfo();
sourceInfo.EndpointType = SchemaCompareEndpointType.Database;
sourceInfo.DatabaseName = sourceDb.DatabaseName;
targetInfo.EndpointType = SchemaCompareEndpointType.Database;
targetInfo.DatabaseName = targetDb.DatabaseName;
var schemaCompareParams = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo
};
SchemaCompareOperation schemaCompareOperation = new SchemaCompareOperation(schemaCompareParams, result.ConnectionInfo, result.ConnectionInfo);
schemaCompareOperation.Execute(TaskExecutionMode.Execute);
Assert.True(schemaCompareOperation.ComparisonResult.IsValid);
Assert.False(schemaCompareOperation.ComparisonResult.IsEqual);
Assert.NotNull(schemaCompareOperation.ComparisonResult.Differences);
var enumerator = schemaCompareOperation.ComparisonResult.Differences.GetEnumerator();
enumerator.MoveNext();
Assert.True(enumerator.Current.SourceObject.Name.ToString().Equals("[dbo].[table1]"));
enumerator.MoveNext();
Assert.True(enumerator.Current.SourceObject.Name.ToString().Equals("[dbo].[table2]"));
// update target
var publishChangesParams = new SchemaComparePublishChangesParams
{
TargetDatabaseName = targetDb.DatabaseName,
OperationId = schemaCompareOperation.OperationId,
};
SchemaComparePublishChangesOperation publishChangesOperation = new SchemaComparePublishChangesOperation(publishChangesParams, schemaCompareOperation.ComparisonResult);
publishChangesOperation.Execute(TaskExecutionMode.Execute);
Assert.True(publishChangesOperation.PublishResult.Success);
Assert.Empty(publishChangesOperation.PublishResult.Errors);
// Verify that there are no differences after the publish by running the comparison again
schemaCompareOperation.Execute(TaskExecutionMode.Execute);
Assert.True(schemaCompareOperation.ComparisonResult.IsValid);
Assert.True(schemaCompareOperation.ComparisonResult.IsEqual);
Assert.Empty(schemaCompareOperation.ComparisonResult.Differences);
}
finally
{
sourceDb.Cleanup();
targetDb.Cleanup();
}
return schemaCompareRequestContext;
}
/// <summary>
/// Verify the schema compare request comparing two dacpacs
/// </summary>
@@ -346,6 +481,25 @@ CREATE TABLE [dbo].[table3]
Assert.NotNull(await SendAndValidateSchemaCompareGenerateScriptRequestDacpacToDatabase());
}
/// <summary>
/// Verify the schema compare publish changes request comparing a dacpac to a database
/// </summary>
[Fact]
public async void SchemaComparePublishChangesDacpacToDatabase()
{
Assert.NotNull(await SendAndValidateSchemaComparePublishChangesRequestDacpacToDatabase());
}
/// <summary>
/// Verify the schema compare publish changes request comparing a database to a database
/// </summary>
[Fact]
public async void SchemaComparePublishChangesDatabaseToDatabase()
{
Assert.NotNull(await SendAndValidateSchemaComparePublishChangesRequestDatabaseToDatabase());
}
private void VerifyAndCleanup(string filePath)
{
// Verify it was created