private static async Task DeprovisionClientManuallyAsync()
{
// Create client provider
var clientProvider = new SqlSyncProvider(clientConnectionString);
// Create standard Setup and Options
var setup = new SyncSetup(new string[] { "Address", "Customer", "CustomerAddress" });
var options = new SyncOptions();
// Create a local orchestrator used to Deprovision everything
var localOrchestrator = new LocalOrchestrator(clientProvider, options, setup);
// Get the local scope
var clientScope = await localOrchestrator.GetClientScopeAsync();
// Deprovision everything
await localOrchestrator.DeprovisionAsync(SyncProvision.StoredProcedures
| SyncProvision.Triggers | SyncProvision.TrackingTable | SyncProvision.Table);
// affect good values
clientScope.Setup = null;
clientScope.Schema = null;
// save the local scope
await localOrchestrator.SaveClientScopeAsync(clientScope);
}
private static async Task DeprovisionClientManuallyAsync()
{
// Create client provider
var clientProvider = new SqlSyncProvider(clientConnectionString);
// Create a local orchestrator used to Deprovision everything
var localOrchestrator = new LocalOrchestrator(clientProvider);
var p = SyncProvision.ClientScope |
SyncProvision.StoredProcedures | SyncProvision.TrackingTable |
SyncProvision.Triggers;
// Deprovision everything
await localOrchestrator.DeprovisionAsync(p);
}
private static async Task DeprovisionClientManuallyAsync()
{
// Create client provider
var clientProvider = new SqlSyncProvider(clientConnectionString);
// Create standard Setup and Options
var setup = new SyncSetup(new string[] { "Address", "Customer", "CustomerAddress" });
var options = new SyncOptions();
// Create a local orchestrator used to Deprovision everything
var localOrchestrator = new LocalOrchestrator(clientProvider, options, setup);
// Deprovision everything
await localOrchestrator.DeprovisionAsync();
}
private static async Task SynchronizeThenDeprovisionThenProvisionAsync()
{
// Create 2 Sql Sync providers
var serverProvider = new SqlSyncProvider(serverConnectionString);
var clientProvider = new SqlSyncProvider(clientConnectionString);
// Create standard Setup and Options
var setup = new SyncSetup(new string[] { "Address", "Customer", "CustomerAddress" });
var options = new SyncOptions();
// Creating an agent that will handle all the process
var agent = new SyncAgent(clientProvider, serverProvider, options, setup);
// Using the Progress pattern to handle progession during the synchronization
var progress = new SynchronousProgress <ProgressArgs>(args => Console.WriteLine($"{args.ProgressPercentage:p}:\t{args.Message}"));
// First sync to have a starting point
var s1 = await agent.SynchronizeAsync(progress);
Console.WriteLine(s1);
// -----------------------------------------------------------------
// Migrating a table by adding a new column
// -----------------------------------------------------------------
// Adding a new column called CreatedDate to Address table, on the server, and on the client.
await Helper.AddNewColumnToAddressAsync(serverProvider.CreateConnection());
await Helper.AddNewColumnToAddressAsync(clientProvider.CreateConnection());
// -----------------------------------------------------------------
// Server side
// -----------------------------------------------------------------
// Creating a setup regarding only the table Address
var setupAddress = new SyncSetup(new string[] { "Address" });
// Create a server orchestrator used to Deprovision and Provision only table Address
var remoteOrchestrator = new RemoteOrchestrator(serverProvider, options, setupAddress);
// Unprovision the old Address triggers / stored proc.
// We can conserve the Address tracking table, since we just add a column,
// that is not a primary key used in the tracking table
// That way, we are preserving historical data
await remoteOrchestrator.DeprovisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers);
// Provision the new Address triggers / stored proc again,
// This provision method will fetch the address schema from the database,
// so it will contains all the columns, including the new Address column added
await remoteOrchestrator.ProvisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers);
// -----------------------------------------------------------------
// Client side
// -----------------------------------------------------------------
// Now go for local orchestrator
var localOrchestrator = new LocalOrchestrator(clientProvider, options, setupAddress);
// Unprovision the Address triggers / stored proc. We can conserve tracking table, since we just add a column, that is not a primary key used in the tracking table
// In this case, we will
await localOrchestrator.DeprovisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers);
// Provision the Address triggers / stored proc again,
// This provision method will fetch the address schema from the database, so it will contains all the columns, including the new one added
await localOrchestrator.ProvisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers);
// Now test a new sync, everything should work as expected.
do
{
// Console.Clear();
Console.WriteLine("Sync Start");
try
{
var s2 = await agent.SynchronizeAsync();
// Write results
Console.WriteLine(s2);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
} while (Console.ReadKey().Key != ConsoleKey.Escape);
Console.WriteLine("End");
}
private static async Task SynchronizeThenDeprovisionThenProvisionAsync()
{
// Create 2 Sql Sync providers
var serverProvider = new SqlSyncProvider(DBHelper.GetDatabaseConnectionString(serverDbName));
var clientProvider = new SqlSyncProvider(DBHelper.GetDatabaseConnectionString(clientDbName));
// Create standard Setup and Options
var setup = new SyncSetup(new string[] { "Address", "Customer", "CustomerAddress" });
var options = new SyncOptions();
// Creating an agent that will handle all the process
var agent = new SyncAgent(clientProvider, serverProvider, options, setup);
// Using the Progress pattern to handle progession during the synchronization
var progress = new SynchronousProgress <ProgressArgs>(s => Console.WriteLine($"{s.Context.SyncStage}:\t{s.Message}"));
// First sync to have a starting point
var s1 = await agent.SynchronizeAsync(progress);
Console.WriteLine(s1);
// -----------------------------------------------------------------
// Migrating a table by adding a new column
// -----------------------------------------------------------------
// Adding a new column called CreatedDate to Address table, on the server, and on the client.
await AddNewColumnToAddressAsync(serverProvider.CreateConnection());
await AddNewColumnToAddressAsync(clientProvider.CreateConnection());
// -----------------------------------------------------------------
// Server side
// -----------------------------------------------------------------
// Creating a setup regarding only the table Address
var setupAddress = new SyncSetup(new string[] { "Address" });
// Create a server orchestrator used to Deprovision and Provision only table Address
var remoteOrchestrator = new RemoteOrchestrator(serverProvider, options, setupAddress);
// Unprovision the Address triggers / stored proc.
// We can conserve the Address tracking table, since we just add a column,
// that is not a primary key used in the tracking table
// That way, we are preserving historical data
await remoteOrchestrator.DeprovisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers);
// Provision the Address triggers / stored proc again,
// This provision method will fetch the address schema from the database,
// so it will contains all the columns, including the new Address column added
await remoteOrchestrator.ProvisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers);
// Now we need the full setup to get the full schema.
// Setup includes [Address] [Customer] and [CustomerAddress]
remoteOrchestrator.Setup = setup;
var newSchema = await remoteOrchestrator.GetSchemaAsync();
// Now we need to save this new schema to the serverscope table
// get the server scope again
var serverScope = await remoteOrchestrator.GetServerScopeAsync();
// affect good values
serverScope.Setup = setup;
serverScope.Schema = newSchema;
// save it
await remoteOrchestrator.WriteServerScopeAsync(serverScope);
// -----------------------------------------------------------------
// Client side
// -----------------------------------------------------------------
// Now go for local orchestrator
var localOrchestrator = new LocalOrchestrator(clientProvider, options, setupAddress);
// Unprovision the Address triggers / stored proc. We can conserve tracking table, since we just add a column, that is not a primary key used in the tracking table
// In this case, we will
await localOrchestrator.DeprovisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers);
// Provision the Address triggers / stored proc again,
// This provision method will fetch the address schema from the database, so it will contains all the columns, including the new one added
await localOrchestrator.ProvisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers);
// Now we need to save this to clientscope
// get the server scope again
var clientScope = await localOrchestrator.GetClientScopeAsync();
// At this point, if you need the schema and you are not able to create a RemoteOrchestrator,
// You can create a WebClientOrchestrator and get the schema as well
// var proxyClientProvider = new WebClientOrchestrator("https://localhost:44369/api/Sync");
// var newSchema = proxyClientProvider.GetSchemaAsync();
// affect good values
clientScope.Setup = setup;
clientScope.Schema = newSchema;
// save it
await localOrchestrator.WriteClientScopeAsync(clientScope);
// Now test a new sync, everything should work as expected.
do
{
// Console.Clear();
Console.WriteLine("Sync Start");
try
{
var s2 = await agent.SynchronizeAsync();
// Write results
Console.WriteLine(s2);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
} while (Console.ReadKey().Key != ConsoleKey.Escape);
Console.WriteLine("End");
}
public async Task LocalOrchestrator_MultipleScopes_Check_Metadatas_Are_Deleted()
{
var dbName = HelperDatabase.GetRandomName("tcp_lo_");
await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true);
var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName);
var sqlProvider = new SqlSyncProvider(cs);
var ctx = new AdventureWorksContext((dbName, ProviderType.Sql, sqlProvider), true, false);
await ctx.Database.EnsureCreatedAsync();
var options = new SyncOptions();
var localOrchestrator = new LocalOrchestrator(sqlProvider, options);
var setup = new SyncSetup(this.Tables);
var setup2 = new SyncSetup(this.Tables);
setup2.Filters.Add("Customer", "EmployeeID");
var schema = await localOrchestrator.GetSchemaAsync(setup);
var localScopeInfo1 = await localOrchestrator.GetClientScopeInfoAsync();
var localScopeInfo2 = await localOrchestrator.GetClientScopeInfoAsync("A");
var serverScope1 = new ServerScopeInfo
{
Name = localScopeInfo1.Name,
Schema = schema,
Setup = setup,
Version = localScopeInfo1.Version
};
var serverScope2 = new ServerScopeInfo
{
Name = localScopeInfo2.Name,
Schema = schema,
Setup = setup2,
Version = localScopeInfo2.Version
};
// Provision two scopes (already tested in previous test)
localScopeInfo1 = await localOrchestrator.ProvisionAsync(serverScope1);
localScopeInfo2 = await localOrchestrator.ProvisionAsync(serverScope2);
Assert.NotNull(localScopeInfo1.Setup);
Assert.NotNull(localScopeInfo1.Schema);
Assert.NotNull(localScopeInfo2.Setup);
Assert.NotNull(localScopeInfo2.Schema);
// Deprovision
await localOrchestrator.DeprovisionAsync("A");
foreach (var table in localScopeInfo1.Setup.Tables)
{
var tableName = table.TableName;
var schemaName = table.SchemaName;
foreach (var objectSpType in Enum.GetValues(typeof(Builders.DbStoredProcedureType)))
{
var spType = (Builders.DbStoredProcedureType)objectSpType;
var exists1 = await localOrchestrator.ExistStoredProcedureAsync(
localScopeInfo1, tableName, schemaName, spType);
var exists2 = await localOrchestrator.ExistStoredProcedureAsync(
localScopeInfo2, tableName, schemaName, spType);
if (spType == Builders.DbStoredProcedureType.SelectChangesWithFilters ||
spType == Builders.DbStoredProcedureType.SelectInitializedChangesWithFilters)
{
Assert.False(exists1);
}
else
{
Assert.True(exists1);
}
Assert.False(exists2);
}
foreach (var objectSpType in Enum.GetValues(typeof(Builders.DbTriggerType)))
{
var trigType = (Builders.DbTriggerType)objectSpType;
var existsTrig1 = await localOrchestrator.ExistTriggerAsync(localScopeInfo1, tableName, schemaName, trigType);
var existsTrig2 = await localOrchestrator.ExistTriggerAsync(localScopeInfo2, tableName, schemaName, trigType);
Assert.False(existsTrig1);
Assert.False(existsTrig2);
}
var trackTableExists1 = await localOrchestrator.ExistTrackingTableAsync(localScopeInfo1, tableName, schemaName);
var trackTableExists2 = await localOrchestrator.ExistTrackingTableAsync(localScopeInfo2, tableName, schemaName);
// Tracking table are still existing for others scopes
Assert.True(trackTableExists1);
Assert.True(trackTableExists2);
}
// Deprovision
await localOrchestrator.DeprovisionAsync();
foreach (var table in localScopeInfo1.Setup.Tables)
{
var tableName = table.TableName;
var schemaName = table.SchemaName;
foreach (var objectSpType in Enum.GetValues(typeof(Builders.DbStoredProcedureType)))
{
var spType = (Builders.DbStoredProcedureType)objectSpType;
var exists1 = await localOrchestrator.ExistStoredProcedureAsync(
localScopeInfo1, tableName, schemaName, spType);
var exists2 = await localOrchestrator.ExistStoredProcedureAsync(
localScopeInfo2, tableName, schemaName, spType);
Assert.False(exists1);
Assert.False(exists2);
}
}
HelperDatabase.DropDatabase(ProviderType.Sql, dbName);
}
public async Task Scenario_Using_ExistingClientDatabase_ProvisionDeprovision_WithoutAccessToServerSide(SyncOptions options)
{
// This test works only if we have the same exact provider on both sides
// create client orchestrator that is the same as server
var clientDatabaseName = HelperDatabase.GetRandomName("tcpfilt_cli_");
var clientProvider = this.CreateProvider(this.ServerType, clientDatabaseName);
var client = (clientDatabaseName, Server.ProviderType, Provider : clientProvider);
// create a client schema without seeding
await this.EnsureDatabaseSchemaAndSeedAsync(client, false, UseFallbackSchema);
// Since we don't have access to remote orchestrator,
// we can simulate a server scope
var localOrchestrator = new LocalOrchestrator(client.Provider, options);
// Get the local scope
var localScopeInfo = await localOrchestrator.GetClientScopeInfoAsync();
// getting local scope did not get the schema
var schema = await localOrchestrator.GetSchemaAsync(this.FilterSetup);
// getting local schema from these provider will not fill the schema name for each table
// and we need the exact same name even if it's not used on client
if (client.ProviderType == ProviderType.MySql || client.ProviderType == ProviderType.MariaDB || client.ProviderType == ProviderType.Sqlite)
{
foreach (var table in schema.Tables)
{
var setupTable = this.FilterSetup.Tables.First(t => t.TableName == table.TableName);
table.SchemaName = setupTable.SchemaName;
}
}
// Simulate a server scope
var serverScope = new ServerScopeInfo
{
Name = localScopeInfo.Name,
Schema = schema,
Setup = this.FilterSetup,
Version = localScopeInfo.Version
};
// just check interceptor
var onTableCreatedCount = 0;
localOrchestrator.OnTableCreated(args => onTableCreatedCount++);
// Provision the database with all tracking tables, stored procedures, triggers and scope
var clientScope = await localOrchestrator.ProvisionAsync(serverScope);
//--------------------------
// ASSERTION
//--------------------------
// check if scope table is correctly created
var scopeInfoTableExists = await localOrchestrator.ExistScopeInfoTableAsync(clientScope.Name, DbScopeType.Client);
Assert.True(scopeInfoTableExists);
// get the db manager
foreach (var setupTable in this.FilterSetup.Tables)
{
Assert.True(await localOrchestrator.ExistTrackingTableAsync(clientScope, setupTable.TableName, setupTable.SchemaName));
Assert.True(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Delete));
Assert.True(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Insert));
Assert.True(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Update));
if (client.ProviderType == ProviderType.Sql)
{
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkDeleteRows));
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkTableType));
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkUpdateRows));
}
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteMetadata));
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteRow));
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.Reset));
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChanges));
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChanges));
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectRow));
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.UpdateRow));
// Filters here
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChangesWithFilters));
Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChangesWithFilters));
}
//localOrchestrator.OnTableProvisioned(null);
//// Deprovision the database with all tracking tables, stored procedures, triggers and scope
await localOrchestrator.DeprovisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers | SyncProvision.ClientScope | SyncProvision.TrackingTable);
// check if scope table is correctly created
scopeInfoTableExists = await localOrchestrator.ExistScopeInfoTableAsync(clientScope.Name, DbScopeType.Client);
Assert.False(scopeInfoTableExists);
// get the db manager
foreach (var setupTable in this.FilterSetup.Tables)
{
Assert.False(await localOrchestrator.ExistTrackingTableAsync(clientScope, setupTable.TableName, setupTable.SchemaName));
Assert.False(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Delete));
Assert.False(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Insert));
Assert.False(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Update));
if (client.ProviderType == ProviderType.Sql)
{
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkDeleteRows));
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkTableType));
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkUpdateRows));
}
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteMetadata));
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteRow));
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.Reset));
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChanges));
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChanges));
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectRow));
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.UpdateRow));
// check filters are deleted
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChangesWithFilters));
Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChangesWithFilters));
}
}
