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); } }
/// <summary> /// Add the server provider (inherited from CoreProvider) and register in the DI a WebProxyServerProvider. /// Use the WebProxyServerProvider in your controller, by inject it. /// </summary> /// <typeparam name="TProvider">Provider inherited from CoreProvider (SqlSyncProvider, MySqlSyncProvider, OracleSyncProvider) Shoud have [CanBeServerProvider=true] </typeparam> /// <param name="serviceCollection"></param> /// <param name="connectionString">Provider connection string</param> /// <param name="action">Configuration server side. Adding at least tables to be synchronized</param> public static IServiceCollection AddSyncServer <TProvider>( this IServiceCollection serviceCollection, string connectionString, Action <SyncConfiguration> action) where TProvider : CoreProvider, new() { if (action == null) { throw new ArgumentNullException(nameof(action)); } var provider = new TProvider(); SyncConfiguration syncConfiguration = new SyncConfiguration(); action?.Invoke(syncConfiguration); provider.SetConfiguration(syncConfiguration); provider.ConnectionString = connectionString; var webProvider = new WebProxyServerProvider(provider) { // since we will register this proxy as a singleton, just signal it IsRegisterAsSingleton = true }; serviceCollection.AddSingleton(webProvider); return(serviceCollection); }
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); }
// Injected thanks to Dependency Injection public AuthSyncController(WebProxyServerProvider proxy) { webProxyServer = proxy; }
// Injected thanks to Dependency Injection public ValuesController(WebProxyServerProvider proxy) { webProxyServer = proxy; }
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); }
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 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); } }
/// <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 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); }