public async Task SyncThroughHttp()
{
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
SqlSyncProvider serverProvider = new SqlSyncProvider(this.fixture.ServerConnectionString);
SyncConfiguration configuration = new SyncConfiguration(this.fixture.Tables);
configuration.DownloadBatchSizeInKB = 500;
WebProxyServerProvider proxyServerProvider = new WebProxyServerProvider(serverProvider);
proxyServerProvider.Configuration = configuration;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
var proxyProvider = new WebProxyClientProvider(new Uri(serviceUri));
var clientProvider = new SqlSyncProvider(this.fixture.Client1ConnectionString);
SyncAgent agent = new SyncAgent(clientProvider, proxyProvider);
var session = await agent.SynchronizeAsync();
Assert.Equal(5, session.TotalChangesDownloaded);
Assert.Equal(0, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
}
private async void SyncButton_Click(object sender, RoutedEventArgs e)
{
var clientProvider = new SqliteSyncProvider("employees.db");
var proxyClientProvider = new WebProxyClientProvider(
new Uri("http://localhost:58507/api/authsync"));
// adding bearer auth
if (authenticationResult != null && authenticationResult.AccessToken != null)
{
proxyClientProvider.AddCustomHeader("Authorization", authenticationResult.CreateAuthorizationHeader());
}
var agent = new SyncAgent(clientProvider, proxyClientProvider);
agent.SyncProgress += (s, a) => Debug(a.Message + a.PropertiesMessage);
try
{
var r = await agent.SynchronizeAsync();
Debug("TotalChangesDownloaded: " + r.TotalChangesDownloaded);
}
catch (Exception ex)
{
Debug("Error during sync " + ex.Message);
}
}
public SqliteSyncHttpTests(SqliteSyncHttpFixture fixture)
{
this.fixture = fixture;
configurationProvider = () => new SyncConfiguration(fixture.Tables);
serverProvider = new SqlSyncProvider(fixture.ServerConnectionString);
proxyServerProvider = new WebProxyServerProvider(serverProvider);
webApp = WebApp.Start(fixture.BaseAddress.OriginalString, (appBuilder) =>
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{actionid}/{id}",
defaults: new { actionid = RouteParameter.Optional, id = RouteParameter.Optional }
);
config.Services.Replace(typeof(IHttpControllerActivator), new TestControllerActivator(
() =>
{
proxyServerProvider.Configuration = configurationProvider();
return(proxyServerProvider);
}));
appBuilder.UseWebApi(config);
});
clientProvider = new SqliteSyncProvider(fixture.ClientSqliteFilePath);
proxyClientProvider = new WebProxyClientProvider(new Uri(fixture.BaseAddress, "api/values"));
agent = new SyncAgent(clientProvider, proxyClientProvider);
}
public SqliteSyncHttpTests(SqliteSyncHttpFixture fixture)
{
this.fixture = fixture;
serverProvider = new SqlSyncProvider(fixture.ServerConnectionString);
proxyServerProvider = new WebProxyServerProvider(serverProvider);
clientProvider = new SqliteSyncProvider(fixture.ClientSqliteFilePath);
proxyClientProvider = new WebProxyClientProvider();
agent = new SyncAgent(clientProvider, proxyClientProvider);
}
public SyncHttpTests(SyncSimpleHttpFixture fixture)
{
this.fixture = fixture;
serverProvider = new SqlSyncProvider(fixture.ServerConnectionString);
proxyServerProvider = new WebProxyServerProvider(serverProvider);
clientProvider = new SqlSyncProvider(fixture.Client1ConnectionString);
proxyClientProvider = new WebProxyClientProvider();
configuration = new SyncConfiguration(this.fixture.Tables);
agent = new SyncAgent(clientProvider, proxyClientProvider);
}
private static async Task TestSyncThroughWebApi()
{
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("config.json", true);
IConfiguration Configuration = configurationBuilder.Build();
//var clientConfig = Configuration["AppConfiguration:ClientSqliteConnectionString"];
//var clientProvider = new SqliteSyncProvider(clientConfig);
var clientConfig = Configuration["AppConfiguration:ClientConnectionString"];
var clientProvider = new SqlSyncProvider(clientConfig);
var proxyClientProvider = new WebProxyClientProvider(new Uri("http://localhost:56782/api/values"));
var agent = new SyncAgent(clientProvider, proxyClientProvider);
agent.SyncProgress += SyncProgress;
agent.ApplyChangedFailed += ApplyChangedFailed;
Console.WriteLine("Press a key to start...");
Console.ReadKey();
do
{
Console.Clear();
Console.WriteLine("Sync Start");
try
{
var s = await agent.SynchronizeAsync();
}
catch (SyncException e)
{
Console.WriteLine(e.ToString());
}
catch (Exception e)
{
Console.WriteLine("UNKNOW EXCEPTION : " + e.Message);
}
Console.WriteLine("Sync Ended. Press a key to start again, or Escapte to end");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
Console.WriteLine("End");
}
private void Init()
{
// Servers providers
masterSqlSyncProvider = new SqlSyncProvider(
settingsHelper[ConnectionType.Server_SqlServer]);
webProxyProvider = new WebProxyClientProvider(
new Uri(settingsHelper[ConnectionType.WebProxy]));
// clients providers
sqlSyncProvider = new SqlSyncProvider(
settingsHelper[ConnectionType.Client_SqlServer]);
sqliteSyncProvider = new SqliteSyncProvider(
settingsHelper[ConnectionType.Client_Sqlite]);
mySqlSyncProvider = new MySqlSyncProvider(
settingsHelper[ConnectionType.Client_MySql]);
}
static async Task PerformSync()
{
var serverUri = new Uri(Properties.Settings.Default.SyncServer);
var proxyClientProvider = new WebProxyClientProvider(serverUri);
var clientProvider = new SqliteSyncProvider("advworks.db");
var agent = new SyncAgent(clientProvider, proxyClientProvider);
var progress = new Progress <ProgressArgs>(s =>
Console.WriteLine($"{s.Context.SyncStage}:\t{s.Message}"));
do
{
var context = await agent.SynchronizeAsync(progress);
Console.WriteLine($"Total Changes downloaded: \t{context.TotalChangesDownloaded}");
Console.WriteLine($"Total Changes Uploaded: \t{context.TotalChangesUploaded}");
Console.WriteLine($"Total Changes Conflicts: \t{context.TotalSyncConflicts}");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
}
/// <summary>
/// Test a client syncing through a web api
/// </summary>
private static async Task TestSyncThroughWebApi()
{
var clientProvider = new SqlSyncProvider(sqlConnectionStringClient);
var proxyClientProvider = new WebProxyClientProvider(
new Uri("http://localhost:56782/api/values"));
var agent = new SyncAgent(clientProvider, proxyClientProvider);
agent.SyncProgress += SyncProgress;
agent.ApplyChangedFailed += ApplyChangedFailed;
Console.WriteLine("Press a key to start...");
Console.ReadKey();
do
{
Console.Clear();
Console.WriteLine("Sync Start");
try
{
var s = await agent.SynchronizeAsync();
Console.WriteLine(GetResultString(s));
}
catch (SyncException e)
{
Console.WriteLine(e.ToString());
}
catch (Exception e)
{
Console.WriteLine("UNKNOW EXCEPTION : " + e.Message);
}
Console.WriteLine("Sync Ended. Press a key to start again, or Escapte to end");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
Console.WriteLine("End");
}
/// <summary>
/// Test a client syncing through a web api
/// </summary>
private static async Task TestSyncThroughWebApi()
{
var clientProvider = new SqlSyncProvider(DbHelper.GetDatabaseConnectionString(clientDbName));
var proxyClientProvider = new WebProxyClientProvider(
new Uri("http://localhost:52288/api/Sync"));
var agent = new SyncAgent(clientProvider, proxyClientProvider);
Console.WriteLine("Press a key to start (be sure web api is running ...)");
Console.ReadKey();
do
{
Console.Clear();
Console.WriteLine("Web sync start");
try
{
var progress = new Progress <ProgressArgs>(pa => Console.WriteLine($"{pa.Context.SessionId} - {pa.Context.SyncStage}\t {pa.Message}"));
var s = await agent.SynchronizeAsync(progress);
Console.WriteLine(s);
}
catch (SyncException e)
{
Console.WriteLine(e.ToString());
}
catch (Exception e)
{
Console.WriteLine("UNKNOW EXCEPTION : " + e.Message);
}
Console.WriteLine("Sync Ended. Press a key to start again, or Escapte to end");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
Console.WriteLine("End");
}
/// <summary>
/// Test a client syncing through a web api
/// </summary>
private static async Task TestSyncThroughWebApi()
{
var clientProvider = new SqlSyncProvider(GetDatabaseConnectionString("NW1"));
var proxyClientProvider = new WebProxyClientProvider(
new Uri("http://localhost:54347/api/values"));
var agent = new SyncAgent(clientProvider, proxyClientProvider);
Console.WriteLine("Press a key to start (be sure web api is running ...)");
Console.ReadKey();
do
{
Console.Clear();
Console.WriteLine("Web sync start");
try
{
var s = await agent.SynchronizeAsync();
Console.WriteLine(s);
}
catch (SyncException e)
{
Console.WriteLine(e.ToString());
}
catch (Exception e)
{
Console.WriteLine("UNKNOW EXCEPTION : " + e.Message);
}
Console.WriteLine("Sync Ended. Press a key to start again, or Escapte to end");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
Console.WriteLine("End");
}
/// <summary>
/// Test syncking through Kestrell server
/// </summary>
private static async Task TestSyncThroughKestrellAsync()
{
var id = Guid.NewGuid();
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("config.json", true);
IConfiguration Configuration = configurationBuilder.Build();
var serverConfig = Configuration["AppConfiguration:ServerConnectionString"];
var clientConfig = Configuration["AppConfiguration:ClientConnectionString"];
// Server side
var serverHandler = new RequestDelegate(async context =>
{
// Create the internal provider
SqlSyncProvider serverProvider = new SqlSyncProvider(serverConfig);
// Create the configuration stuff
ServiceConfiguration configuration = new ServiceConfiguration(new string[] { "ServiceTickets" });
configuration.DownloadBatchSizeInKB = 500;
serverProvider.SetConfiguration(configuration);
// Create the proxy provider
WebProxyServerProvider proxyServerProvider = new WebProxyServerProvider(serverProvider, SerializationFormat.Json);
serverProvider.SyncProgress += ServerProvider_SyncProgress;
try
{
CancellationTokenSource cts = new CancellationTokenSource();
// cts.CancelAfter(60000);
CancellationToken token = cts.Token;
await proxyServerProvider.HandleRequestAsync(context, token);
}
catch (WebSyncException webSyncException)
{
Console.WriteLine("Proxy Server WebSyncException : " + webSyncException.Message);
}
catch (Exception e)
{
Console.WriteLine("Proxy Server Exception : " + e.Message);
throw e;
}
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
var proxyProvider = new WebProxyClientProvider(new Uri(serviceUri), SerializationFormat.Json);
var clientProvider = new SqlSyncProvider(clientConfig);
SyncAgent agent = new SyncAgent(clientProvider, proxyProvider);
agent.SyncProgress += Agent_SyncProgress;
do
{
try
{
CancellationTokenSource cts = new CancellationTokenSource();
//cts.CancelAfter(1000);
CancellationToken token = cts.Token;
var s = await agent.SynchronizeAsync(token);
}
catch (WebSyncException webSyncException)
{
Console.WriteLine("Proxy Client WebSyncException : " + webSyncException.Message);
}
catch (Exception e)
{
Console.WriteLine("Proxy Client Exception : " + e.Message);
}
Console.WriteLine("Sync Ended. Press a key to start again, or Escapte to end");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
});
await TestKestrelHttpServer.LaunchKestrellAsync(serverHandler, clientHandler);
}
public SyncService(SyncProvider provider, IConfiguration configuration, ISyncSender sync, ILogger <SyncService> logger)
{
_provider = provider;
_configuration = configuration;
ConnectionString = _configuration.GetConnectionString("HUB");
_clientProvider = new SqliteSyncProvider("box.db");
_proxyClientProvider = new WebProxyClientProvider(new Uri(_configuration["ClaWebApiServer"] + "/sync/post"));
_agent = new SyncAgent(_clientProvider, _proxyClientProvider);
_agent.LocalProvider.InterceptConnectionOpen(args =>
{
var connection = args.Connection as SqliteConnection;
if (connection == null)
{
_logger.LogError("Couldn't convert db connection to SqliteConnection");
return;
}
var cmd = connection.CreateCommand();
var password = _configuration["SqlPassword"];
// Prevent SQL Injection
cmd.CommandText = "SELECT quote($password);";
cmd.Parameters.AddWithValue("$password", password);
var quotedPassword = (string)cmd.ExecuteScalar();
// Encrypt database
cmd.CommandText = "PRAGMA key = " + quotedPassword;
cmd.Parameters.Clear();
cmd.ExecuteNonQuery();
});
_sync = sync;
_logger = logger;
//_sync.ChangeDetect += async (sender, args) => { await _provider.UpdateServer(_hubConnection, _myJwt); };
_sync.ChangeDetect += (sender, args) =>
{
_logger.LogInformation($"[SyncService] Change Registered. Debouncing for 5 seconds...");
_changeSubject.OnNext(true);
};
_changeSubject
.Throttle(TimeSpan.FromSeconds(5))
.Subscribe(async s =>
{
try
{
_logger.LogInformation($"[SyncService] Debounce complete. Attempting to update.");
if (_sync.GetConnectedStatus())
{
await RequestSync();
}
else
{
_logger.LogInformation($"[SyncService] Server connection offline. Not updating.");
}
}
catch (Exception e)
{
_logger.LogError($"[ChangeDetect] Exception {e.Message}");
}
});
_hubConnection = new HubConnectionBuilder()
.WithUrl(_configuration["ClaWebApiServer"] + "/sync", options =>
{
options.AccessTokenProvider = async() => _myJwt;
})
.AddJsonProtocol(options =>
{
options.PayloadSerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
})
.Build();
_boxUiHubConnection = new HubConnectionBuilder()
.WithUrl("http://localhost:5001/signalr", options =>
{
options.Transports = HttpTransportType.WebSockets;
options.SkipNegotiation = true;
})
.Build();
_registryManager = RegistryManager.CreateFromConnectionString(ConnectionString);
}
public async static Task SyncHttpThroughKestellAsync()
{
// server provider
var serverProvider = new SqlSyncProvider(GetDatabaseConnectionString("AdventureWorks"));
// proxy server based on server provider
var proxyServerProvider = new WebProxyServerProvider(serverProvider);
// client provider
var client1Provider = new SqlSyncProvider(GetDatabaseConnectionString("Adv"));
// proxy client provider
var proxyClientProvider = new WebProxyClientProvider();
var tables = new string[] { "ProductCategory",
"ProductDescription", "ProductModel",
"Product", "ProductModelProductDescription",
"Address", "Customer", "CustomerAddress",
"SalesOrderHeader", "SalesOrderDetail" };
var configuration = new SyncConfiguration(tables)
{
ScopeName = "AdventureWorks",
ScopeInfoTableName = "tscopeinfo",
SerializationFormat = Dotmim.Sync.Enumerations.SerializationFormat.Binary,
DownloadBatchSizeInKB = 400,
StoredProceduresPrefix = "s",
StoredProceduresSuffix = "",
TrackingTablesPrefix = "t",
TrackingTablesSuffix = "",
};
var serverHandler = new RequestDelegate(async context =>
{
proxyServerProvider.Configuration = configuration;
await proxyServerProvider.HandleRequestAsync(context);
});
using (var server = new KestrellTestServer())
{
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
var syncAgent = new SyncAgent(client1Provider, proxyClientProvider);
do
{
Console.Clear();
Console.WriteLine("Sync Start");
try
{
CancellationTokenSource cts = new CancellationTokenSource();
Console.WriteLine("--------------------------------------------------");
Console.WriteLine("1 : Normal synchronization.");
Console.WriteLine("2 : Fill configuration from server side");
Console.WriteLine("3 : Synchronization with reinitialize");
Console.WriteLine("4 : Synchronization with upload and reinitialize");
Console.WriteLine("5 : Deprovision everything from client side (tables included)");
Console.WriteLine("6 : Deprovision everything from client side (tables not included)");
Console.WriteLine("7 : Deprovision everything from server side (tables not included)");
Console.WriteLine("8 : Provision everything on the client side (tables included)");
Console.WriteLine("9 : Provision everything on the server side (tables not included)");
Console.WriteLine("10 : Insert datas on client");
Console.WriteLine("--------------------------------------------------");
Console.WriteLine("What's your choice ? ");
Console.WriteLine("--------------------------------------------------");
var choice = Console.ReadLine();
if (int.TryParse(choice, out int choiceNumber))
{
Console.WriteLine($"You choose {choice}. Start operation....");
switch (choiceNumber)
{
case 1:
var s1 = await syncAgent.SynchronizeAsync(cts.Token);
Console.WriteLine(s1);
break;
case 2:
SyncContext ctx = new SyncContext(Guid.NewGuid());
SqlSyncProvider syncConfigProvider = new SqlSyncProvider(GetDatabaseConnectionString("AdventureWorks"));
(ctx, configuration.Schema) = await syncConfigProvider.EnsureSchemaAsync(ctx, new Dotmim.Sync.Messages.MessageEnsureSchema
{
Schema = configuration.Schema,
SerializationFormat = Dotmim.Sync.Enumerations.SerializationFormat.Json
});
break;
case 3:
s1 = await syncAgent.SynchronizeAsync(SyncType.Reinitialize, cts.Token);
Console.WriteLine(s1);
break;
case 4:
s1 = await syncAgent.SynchronizeAsync(SyncType.ReinitializeWithUpload, cts.Token);
Console.WriteLine(s1);
break;
case 5:
SqlSyncProvider clientSyncProvider = syncAgent.LocalProvider as SqlSyncProvider;
await clientSyncProvider.DeprovisionAsync(configuration, SyncProvision.All | SyncProvision.Table);
Console.WriteLine("Deprovision complete on client");
break;
case 6:
SqlSyncProvider client2SyncProvider = syncAgent.LocalProvider as SqlSyncProvider;
await client2SyncProvider.DeprovisionAsync(configuration, SyncProvision.All);
Console.WriteLine("Deprovision complete on client");
break;
case 7:
SqlSyncProvider remoteSyncProvider = new SqlSyncProvider(GetDatabaseConnectionString("AdventureWorks"));
await remoteSyncProvider.DeprovisionAsync(configuration, SyncProvision.All);
Console.WriteLine("Deprovision complete on remote");
break;
case 8:
SqlSyncProvider clientSyncProvider2 = syncAgent.LocalProvider as SqlSyncProvider;
await clientSyncProvider2.ProvisionAsync(configuration, SyncProvision.All | SyncProvision.Table);
Console.WriteLine("Provision complete on client");
break;
case 9:
SqlSyncProvider remoteSyncProvider2 = new SqlSyncProvider(GetDatabaseConnectionString("AdventureWorks"));
await remoteSyncProvider2.ProvisionAsync(configuration, SyncProvision.All);
Console.WriteLine("Provision complete on remote");
break;
case 10:
var c = GetDatabaseConnectionString("Adv");
var catId = await InsertProductCategory(c);
var modelId = await InsertProductModel(c);
await InsertProduct(c, catId, modelId);
Console.WriteLine("Inserted a model, a category and a product.");
break;
default:
break;
}
}
}
catch (SyncException e)
{
Console.WriteLine(e.ToString());
}
catch (Exception e)
{
Console.WriteLine("UNKNOW EXCEPTION : " + e.Message);
}
Console.WriteLine("--------------------------------------------------");
Console.WriteLine("Press a key to choose again, or Escapte to end");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
});
await server.Run(serverHandler, clientHandler);
}
}
public static async Task SyncHttpThroughKestellAsync()
{
// server provider
var serverProvider = new SqlSyncProvider(DbHelper.GetDatabaseConnectionString(serverDbName));
// client provider
var client1Provider = new SqlSyncProvider(DbHelper.GetDatabaseConnectionString(clientDbName));
// proxy client provider
var proxyClientProvider = new WebProxyClientProvider();
var tables = new string[] { "ProductCategory",
"ProductDescription", "ProductModel",
"Product", "ProductModelProductDescription",
"Address", "Customer", "CustomerAddress",
"SalesOrderHeader", "SalesOrderDetail" };
var configuration = new Action <SyncConfiguration>(conf =>
{
conf.ScopeName = "AdventureWorks";
conf.ScopeInfoTableName = "tscopeinfo";
conf.SerializationFormat = Dotmim.Sync.Enumerations.SerializationFormat.Binary;
conf.StoredProceduresPrefix = "s";
conf.StoredProceduresSuffix = "";
conf.TrackingTablesPrefix = "t";
conf.TrackingTablesSuffix = "";
conf.Add(tables);
});
var optionsClient = new Action <SyncOptions>(opt =>
{
opt.BatchDirectory = Path.Combine(SyncOptions.GetDefaultUserBatchDiretory(), "client");
opt.BatchSize = 100;
opt.CleanMetadatas = true;
opt.UseBulkOperations = true;
opt.UseVerboseErrors = false;
});
var optionsServer = new Action <SyncOptions>(opt =>
{
opt.BatchDirectory = Path.Combine(SyncOptions.GetDefaultUserBatchDiretory(), "server");
opt.BatchSize = 100;
opt.CleanMetadatas = true;
opt.UseBulkOperations = true;
opt.UseVerboseErrors = false;
});
var serverHandler = new RequestDelegate(async context =>
{
var proxyServerProvider = WebProxyServerProvider.Create(context, serverProvider, configuration, optionsServer);
await proxyServerProvider.HandleRequestAsync(context);
});
using (var server = new KestrellTestServer())
{
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
var syncAgent = new SyncAgent(client1Provider, proxyClientProvider);
do
{
Console.Clear();
Console.WriteLine("Sync Start");
try
{
var cts = new CancellationTokenSource();
Console.WriteLine("--------------------------------------------------");
Console.WriteLine("1 : Normal synchronization.");
Console.WriteLine("2 : Synchronization with reinitialize");
Console.WriteLine("3 : Synchronization with upload and reinitialize");
Console.WriteLine("--------------------------------------------------");
Console.WriteLine("What's your choice ? ");
Console.WriteLine("--------------------------------------------------");
var choice = Console.ReadLine();
if (int.TryParse(choice, out var choiceNumber))
{
Console.WriteLine($"You choose {choice}. Start operation....");
switch (choiceNumber)
{
case 1:
var s1 = await syncAgent.SynchronizeAsync(cts.Token);
Console.WriteLine(s1);
break;
case 2:
s1 = await syncAgent.SynchronizeAsync(SyncType.Reinitialize, cts.Token);
Console.WriteLine(s1);
break;
case 3:
s1 = await syncAgent.SynchronizeAsync(SyncType.ReinitializeWithUpload, cts.Token);
Console.WriteLine(s1);
break;
default:
break;
}
}
}
catch (SyncException e)
{
Console.WriteLine(e.ToString());
}
catch (Exception e)
{
Console.WriteLine("UNKNOW EXCEPTION : " + e.Message);
}
Console.WriteLine("--------------------------------------------------");
Console.WriteLine("Press a key to choose again, or Escapte to end");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
});
await server.Run(serverHandler, clientHandler);
}
}
public async Task <ProviderRun> RunAsync(CoreProvider serverProvider, ProviderFixture <CoreProvider> serverFixture, string scopeName = null, string[] tables = null, SyncConfiguration conf = null,
bool reuseAgent = true)
{
// server proxy
var proxyServerProvider = new WebProxyServerProvider(serverProvider);
var proxyClientProvider = new WebProxyClientProvider();
var syncTables = tables ?? serverFixture.Tables;
// local test, through tcp
if (NetworkType == NetworkType.Tcp)
{
// create agent
if (this.Agent == null || !reuseAgent)
{
this.Agent = new SyncAgent(ClientProvider, serverProvider, syncTables);
}
// copy conf settings
if (conf != null)
{
serverFixture.CopyConfiguration(this.Agent.Configuration, conf);
}
// Add Filers
if (serverFixture.Filters != null && serverFixture.Filters.Count > 0)
{
serverFixture.Filters.ForEach(f => {
if (!Agent.Configuration.Filters.Contains(f))
{
Agent.Configuration.Filters.Add(f);
}
});
}
// Add Filers values
if (serverFixture.FilterParameters != null && serverFixture.FilterParameters.Count > 0)
{
foreach (var syncParam in serverFixture.FilterParameters)
{
if (!this.Agent.Parameters.Contains(syncParam))
{
this.Agent.Parameters.Add(syncParam);
}
}
}
// sync
try
{
BeginRun?.Invoke(this.Agent.RemoteProvider);
Results = await this.Agent.SynchronizeAsync();
EndRun?.Invoke(this.Agent.RemoteProvider);
}
catch (Exception ex)
{
Exception = ex;
Console.WriteLine(ex);
}
}
// -----------------------------------------------------------------------
// HTTP
// -----------------------------------------------------------------------
// tests through http proxy
if (NetworkType == NetworkType.Http)
{
// client handler
using (var server = new KestrellTestServer())
{
// server handler
var serverHandler = new RequestDelegate(async context =>
{
SyncConfiguration syncConfiguration = new SyncConfiguration(syncTables);// set proxy conf
// copy conf settings
if (conf != null)
{
serverFixture.CopyConfiguration(syncConfiguration, conf);
}
// set proxy conf
proxyServerProvider.Configuration = syncConfiguration;
// Add Filers
if (serverFixture.Filters != null && serverFixture.Filters.Count > 0)
{
serverFixture.Filters.ForEach(f => {
if (!proxyServerProvider.Configuration.Filters.Contains(f))
{
proxyServerProvider.Configuration.Filters.Add(f);
}
});
}
// sync
try
{
BeginRun?.Invoke(proxyServerProvider.LocalProvider);
await proxyServerProvider.HandleRequestAsync(context);
EndRun?.Invoke(proxyServerProvider.LocalProvider);
}
catch (Exception ew)
{
Console.WriteLine(ew);
}
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
// create agent
if (this.Agent == null || !reuseAgent)
{
this.Agent = new SyncAgent(ClientProvider, proxyClientProvider);
}
if (serverFixture.FilterParameters != null && serverFixture.FilterParameters.Count > 0)
{
foreach (var syncParam in serverFixture.FilterParameters)
{
if (!this.Agent.Parameters.Contains(syncParam))
{
this.Agent.Parameters.Add(syncParam);
}
}
}
((WebProxyClientProvider)this.Agent.RemoteProvider).ServiceUri = new Uri(serviceUri);
try
{
Results = await Agent.SynchronizeAsync();
}
catch (Exception ew)
{
Exception = ew;
Console.WriteLine(ew);
}
});
await server.Run(serverHandler, clientHandler);
}
}
return(this);
}
public async Task <ProviderRun> RunAsync(ProviderFixture serverFixture, string[] tables = null,
Action <SyncConfiguration> conf = null, bool reuseAgent = true)
{
// server proxy
var proxyClientProvider = new WebProxyClientProvider();
var syncTables = tables ?? serverFixture.Tables;
// local test, through tcp
if (this.NetworkType == NetworkType.Tcp)
{
// create agent
if (this.Agent == null || !reuseAgent)
{
this.Agent = new SyncAgent(this.ClientProvider, serverFixture.ServerProvider, syncTables);
}
// copy conf settings
if (conf != null)
{
this.Agent.SetConfiguration(conf);
}
// Add Filers
if (serverFixture.Filters != null && serverFixture.Filters.Count > 0)
{
serverFixture.Filters.ForEach(f =>
{
if (!this.Agent.LocalProvider.Configuration.Filters.Contains(f))
{
this.Agent.LocalProvider.Configuration.Filters.Add(f);
}
});
}
// Add Filers values
if (serverFixture.FilterParameters != null && serverFixture.FilterParameters.Count > 0)
{
foreach (var syncParam in serverFixture.FilterParameters)
{
if (!this.Agent.Parameters.Contains(syncParam))
{
this.Agent.Parameters.Add(syncParam);
}
}
}
// sync
try
{
this.BeginRun?.Invoke(this.Agent.RemoteProvider);
this.Results = await this.Agent.SynchronizeAsync();
this.EndRun?.Invoke(this.Agent.RemoteProvider);
}
catch (Exception ex)
{
this.Exception = ex;
Console.WriteLine(ex);
}
}
// -----------------------------------------------------------------------
// HTTP
// -----------------------------------------------------------------------
// tests through http proxy
if (this.NetworkType == NetworkType.Http)
{
using (var server = new KestrellTestServer())
{
// server handler
var serverHandler = new RequestDelegate(async context =>
{
// test if <> directory name works
var options = new Action <SyncOptions>(o => o.BatchDirectory = Path.Combine(SyncOptions.GetDefaultUserBatchDiretory(), "server"));
// sync
try
{
var proxyServerProvider = WebProxyServerProvider.Create(
context, serverFixture.ServerProvider, conf, options);
var serverProvider = proxyServerProvider.GetLocalProvider(context);
serverProvider.Configuration.Add(syncTables);
this.BeginRun?.Invoke(serverProvider);
await proxyServerProvider.HandleRequestAsync(context);
this.EndRun?.Invoke(serverProvider);
}
catch (Exception ew)
{
Console.WriteLine(ew);
}
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
// create agent
if (this.Agent == null || !reuseAgent)
{
this.Agent = new SyncAgent(this.ClientProvider, proxyClientProvider);
}
if (serverFixture.FilterParameters != null && serverFixture.FilterParameters.Count > 0)
{
foreach (var syncParam in serverFixture.FilterParameters)
{
if (!this.Agent.Parameters.Contains(syncParam))
{
this.Agent.Parameters.Add(syncParam);
}
}
}
((WebProxyClientProvider)this.Agent.RemoteProvider).ServiceUri = new Uri(serviceUri);
try
{
this.Results = await this.Agent.SynchronizeAsync();
}
catch (Exception ew)
{
this.Exception = ew;
Console.WriteLine(ew);
}
});
await server.Run(serverHandler, clientHandler);
}
}
return(this);
}
internal SyncContext Sync(string value)
{
if (String.IsNullOrEmpty(value))
{
throw new Exception("Loading a project requires a name. Ex : dotnet sync --load project01");
}
Project project = DataStore.Current.LoadProject(value);
if (project == null)
{
throw new Exception($"Project {value} does not exists.");
}
if (project.ServerProvider == null || string.IsNullOrEmpty(project.ServerProvider.ConnectionString))
{
throw new Exception($"Server provider for project {project.Name} is not correctly defined. See help: dotnet sync provider --help");
}
if (project.ClientProvider == null || string.IsNullOrEmpty(project.ClientProvider.ConnectionString))
{
throw new Exception($"Client provider for project {project.Name} is not correctly defined. See help: dotnet sync provider --help");
}
if (project.ServerProvider.ProviderType != ProviderType.Web && (project.Tables == null || project.Tables.Count <= 0))
{
throw new Exception($"No table configured for project {project.Name}. See help: dotnet sync table --help");
}
IProvider serverProvider;
CoreProvider clientprovider;
switch (project.ServerProvider.ProviderType)
{
case ProviderType.Sqlite:
throw new Exception("Can't use Sqlite as a server provider");
case ProviderType.Web:
serverProvider = new WebProxyClientProvider(new Uri(project.ServerProvider.ConnectionString));
break;
case ProviderType.MySql:
serverProvider = new MySqlSyncProvider(project.ServerProvider.ConnectionString);
break;
case ProviderType.SqlServer:
default:
serverProvider = new SqlSyncProvider(project.ServerProvider.ConnectionString);
break;
}
switch (project.ClientProvider.ProviderType)
{
case ProviderType.Web:
throw new Exception("Web proxy is used as a proxy server. You have to use an ASP.NET web backend. CLI uses a proxy as server provider");
case ProviderType.Sqlite:
clientprovider = new SqliteSyncProvider(project.ClientProvider.ConnectionString);
break;
case ProviderType.MySql:
clientprovider = new MySqlSyncProvider(project.ClientProvider.ConnectionString);
break;
case ProviderType.SqlServer:
default:
clientprovider = new SqlSyncProvider(project.ClientProvider.ConnectionString);
break;
}
SyncAgent agent = null;
if (project.ServerProvider.ProviderType != ProviderType.Web)
{
agent = new SyncAgent(clientprovider, serverProvider);
var syncConfiguration = agent.LocalProvider.Configuration;
foreach (var t in project.Tables.OrderBy(tbl => tbl.Order))
{
// Potentially user can pass something like [SalesLT].[Product]
// or SalesLT.Product or Product. ParserName will handle it
var parser = ParserName.Parse(t.Name);
var tableName = parser.ObjectName;
var schema = string.IsNullOrEmpty(t.Schema) ? parser.SchemaName : t.Schema;
var dmTable = new DmTable(tableName);
if (!String.IsNullOrEmpty(schema))
{
dmTable.Schema = schema;
}
dmTable.SyncDirection = t.Direction;
syncConfiguration.Add(dmTable);
}
agent.LocalProvider.Options.BatchDirectory = string.IsNullOrEmpty(project.Configuration.BatchDirectory) ? null : project.Configuration.BatchDirectory;
agent.LocalProvider.Options.BatchSize = (int)Math.Min(Int32.MaxValue, project.Configuration.DownloadBatchSizeInKB);
//agent.Options.UseBulkOperations = project.Configuration.UseBulkOperation;
syncConfiguration.SerializationFormat = project.Configuration.SerializationFormat;
syncConfiguration.ConflictResolutionPolicy = project.Configuration.ConflictResolutionPolicy;
}
else
{
agent = new SyncAgent(clientprovider, serverProvider);
}
var interceptor = new Interceptor <TableChangesSelectedArgs, TableChangesAppliedArgs>(
tcs => Console.WriteLine($"Changes selected for table {tcs.TableChangesSelected.TableName}: {tcs.TableChangesSelected.TotalChanges}"),
tca => Console.WriteLine($"Changes applied for table {tca.TableChangesApplied.Table.TableName}: [{tca.TableChangesApplied.State}] {tca.TableChangesApplied.Applied}")
);
agent.SetInterceptor(interceptor);
// synchronous call
var syncContext = agent.SynchronizeAsync().GetAwaiter().GetResult();
var tsEnded = TimeSpan.FromTicks(syncContext.CompleteTime.Ticks);
var tsStarted = TimeSpan.FromTicks(syncContext.StartTime.Ticks);
var durationTs = tsEnded.Subtract(tsStarted);
var durationstr = $"{durationTs.Hours}:{durationTs.Minutes}:{durationTs.Seconds}.{durationTs.Milliseconds}";
Console.ForegroundColor = ConsoleColor.Green;
var s = $"Synchronization done. " + Environment.NewLine +
$"\tTotal changes downloaded: {syncContext.TotalChangesDownloaded} " + Environment.NewLine +
$"\tTotal changes uploaded: {syncContext.TotalChangesUploaded}" + Environment.NewLine +
$"\tTotal duration :{durationstr} ";
Console.WriteLine(s);
Console.ResetColor();
return(syncContext);
}
