public async Task RemoteOrchestrator_GetServerScopeInfo_ShouldReturnSchema()
{
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 scopeName = "scope";
var options = new SyncOptions();
var setup = new SyncSetup(this.Tables);
var onSchemaRead = false;
var onSchemaReading = false;
var remoteOrchestrator = new RemoteOrchestrator(sqlProvider, options);
remoteOrchestrator.OnSchemaLoading(args =>
{
Assert.Equal(scopeName, args.Context.ScopeName);
onSchemaReading = true;
});
remoteOrchestrator.OnSchemaLoaded(args =>
{
Assert.IsType <SchemaLoadedArgs>(args);
Assert.Equal(SyncStage.Provisioning, args.Context.SyncStage);
Assert.Equal(scopeName, args.Context.ScopeName);
Assert.NotNull(args.Connection);
Assert.Null(args.Transaction);
Assert.Equal(ConnectionState.Open, args.Connection.State);
Assert.Equal(16, args.Schema.Tables.Count);
onSchemaRead = true;
});
AssertConnectionAndTransaction(remoteOrchestrator, scopeName);
var scopeInfo = await remoteOrchestrator.GetServerScopeInfoAsync(scopeName, setup);
Assert.NotNull(scopeInfo.Schema);
Assert.NotNull(scopeInfo.Setup);
Assert.Equal(16, scopeInfo.Schema.Tables.Count);
Assert.True(onSchemaRead);
Assert.True(onSchemaReading);
var schema = await remoteOrchestrator.GetSchemaAsync(scopeName, setup);
Assert.NotNull(schema);
Assert.Equal(16, schema.Tables.Count);
HelperDatabase.DropDatabase(ProviderType.Sql, dbName);
}
private static async Task ProvisionClientManuallyAsync()
{
// 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();
// -----------------------------------------------------------------
// Client side
// -----------------------------------------------------------------
// This method is useful if you want to provision by yourself the client database
// You will need to :
// - Create a local orchestrator with the correct setup to provision
// - Get the local scope that will contains after provisioning, the serialized version of your scope / schema
// - Get the schema from the server side using a RemoteOrchestrator or a WebClientOrchestrator
// - Provision everything locally
// - Save the local scope information
// Create a local orchestrator used to provision everything locally
var localOrchestrator = new LocalOrchestrator(clientProvider, options, setup);
// Because we need the schema from remote side, create a remote orchestrator
var remoteOrchestrator = new RemoteOrchestrator(serverProvider, options, setup);
// Getting the schema from server side
var serverSchema = await remoteOrchestrator.GetSchemaAsync();
// 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 serverSchema = proxyClientProvider.GetSchemaAsync();
// get the local scope
var clientScope = await localOrchestrator.GetClientScopeAsync();
// Provision everything needed (sp, triggers, tracking tables, AND TABLES)
await localOrchestrator.ProvisionAsync(serverSchema, SyncProvision.StoredProcedures
| SyncProvision.Triggers | SyncProvision.TrackingTable | SyncProvision.Table);
// affect good values
clientScope.Setup = setup;
clientScope.Schema = serverSchema;
// save the client scope
await localOrchestrator.SaveClientScopeAsync(clientScope);
}
/// <summary>
/// Create an orchestrator on the server database (to have an existing schema) and getting a table schema
/// </summary>
/// <returns></returns>
private static async Task GetTableSchemaAsync()
{
var provider = new SqlSyncProvider(serverConnectionString);
var options = new SyncOptions();
var setup = new SyncSetup("ProductCategory", "ProductModel", "Product");
var orchestrator = new RemoteOrchestrator(provider, options);
var serverSchema = await orchestrator.GetSchemaAsync(setup);
foreach (var column in serverSchema.Tables["Product"].Columns)
{
Console.WriteLine(column);
}
}
public async Task BaseOrchestrator_GetSchema_ShouldFail_If_SetupIsEmpty()
{
var dbName = HelperDatabase.GetRandomName("tcp_lo_");
await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true);
var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName);
var options = new SyncOptions();
var setup = new SyncSetup();
var provider = new SqlSyncProvider(cs);
var orchestrator = new RemoteOrchestrator(provider, options, setup);
var se = await Assert.ThrowsAsync <SyncException>(async() => await orchestrator.GetSchemaAsync());
Assert.Equal(SyncStage.SchemaReading, se.SyncStage);
Assert.Equal(SyncSide.ServerSide, se.Side);
Assert.Equal("MissingTablesException", se.TypeName);
HelperDatabase.DropDatabase(ProviderType.Sql, dbName);
}
private static async Task ProvisionClientManuallyAsync()
{
// 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();
// -----------------------------------------------------------------
// Client side
// -----------------------------------------------------------------
// This method is useful if you want to provision by yourself the client database
// You will need to :
// - Create a local orchestrator with the correct setup to provision
// - Get the schema from the server side using a RemoteOrchestrator or a WebClientOrchestrator
// - Provision everything locally
// Create a local orchestrator used to provision everything locally
var localOrchestrator = new LocalOrchestrator(clientProvider, options, setup);
// Because we need the schema from remote side, create a remote orchestrator
var remoteOrchestrator = new RemoteOrchestrator(serverProvider, options, setup);
// Getting the schema from server side
var serverSchema = await remoteOrchestrator.GetSchemaAsync();
// 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 serverSchema = proxyClientProvider.GetSchemaAsync();
// Provision everything needed (sp, triggers, tracking tables, AND TABLES)
await localOrchestrator.ProvisionAsync(serverSchema);
}
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");
}
