v0.8.1

[Mimetis]

v0.8.1 is in progress dev.
You can grab the pre-release here : https://www.nuget.org/packages?q=Dotmim.Sync

Upgrade to version v0.8.1

Do not forget to call the UpgradeAsync method to upgrade your current schema version the last version.

• Client Side : No need to call UpgradeAsync, since it's handled by default by DMS
• Server Side : You need to create a RemoteOrchestrator with the correct SyncSetup and call the UpgradeAsync method

// Upgrade to last version
if (await remoteOrchestrator.NeedsToUpgradeAsync())
   await remoteOrchestrator.UpgradeAsync(progress:progress);

When making the upgrade of your system (server / clients), be sure to remember that:

• A client upgraded is not compatible with a non upgraded server.
• A server upgraded will be compatible with non upgraded clients

That being said, be sure to firstly upgrade your server to the last version, call the UpgradeAsync (as explained before), then upgrade your clients.

Once upgraded your schema should be updated to the last version

Breaking Changes

A new way of handling web server controller has been implemented.
I've removed all the server cache usages, and replace them with the client session.
Instead of relying on IMemoryCache, the Web Api is using now the ISession to stick all the httpclient call and be sure there is no collision.

• The server code has changed.
• The client code has not changed and is still compatible

I've removed the WebServerManager instance, and I'm injecting directly a WebServerOrchestrator in the pipeline.
Be careful, the code on the controller is slightly different (see example below)

Since we are using now the session, you need to add the session service and middleware.
See here for more info : https://docs.microsoft.com/en-us/aspnet/core/fundamentals/app-state?view=aspnetcore-5.0#configure-session-state.

Sample 1: Simple orchestrator injected

Here is the new version of the Startup.cs file

Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddDistributedMemoryCache();
    services.AddSession(options => options.IdleTimeout = TimeSpan.FromMinutes(30));

    var connectionString = Configuration.GetSection("ConnectionStrings")["SqlConnection"];

    var tables = new string[] {"ProductCategory", "ProductModel", "Product",
    "Address", "Customer", "CustomerAddress", "SalesOrderHeader", "SalesOrderDetail" };

    services.AddSyncServer<SqlSyncChangeTrackingProvider>(connectionString, tables);
}

Be careful, order is important here : UseSession is AFTER UseRouting and UseAuthorization and BEFORE UseEndpoints

// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    app.UseHttpsRedirection();
    app.UseRouting();
    app.UseAuthorization();
    app.UseSession();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

Here is the new version of SyncController.
As you can see we are injecting directly a WebServerOrchestrator instead of the old WebServerManager.

SyncController.cs:

[ApiController]
[Route("api/[controller]")]
public class SyncController : ControllerBase
{
    public WebServerOrchestrator Orchestrator { get; }

    // Injected thanks to Dependency Injection
    public SyncController(WebServerOrchestrator webServerOrchestrator) 
          => this.Orchestrator = webServerOrchestrator;

    /// <summary>
    /// This POST handler is mandatory to handle all the sync process
    /// </summary>
    /// <returns></returns>
    [HttpPost]
    public Task Post() => this.Orchestrator.HandleRequestAsync(this.HttpContext);

    /// <summary>
    /// This GET handler is optional. It allows you to see the configuration hosted on the server
    /// </summary>
    [HttpGet]
    public Task Get() => WebServerOrchestrator.WriteHelloAsync(this.HttpContext, this.Orchestrator);

}

Sample 2: Multi orchestrators injected

You may need to add multiples orchestrators. The code is slightly the same, and we are now relying on the core methods of the ASP.Net Core Dependency Injection mechanism

Here, we are injecting two kind of orchestrators.

• One for SQL Server, using a scope name SqlServerScope
• One for MySql, using a scope name MySqlScope

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddDistributedMemoryCache();
    services.AddSession(options => options.IdleTimeout = TimeSpan.FromMinutes(30));

    // [Required]: Get a connection string to your server data source
    var connectionString = Configuration.GetSection("ConnectionStrings")["SqlConnection"];
    var mysqlConnectionString = Configuration.GetSection("ConnectionStrings")["MySqlConnection"];

    var options = new SyncOptions { };

    // [Required] Tables involved in the sync process:
    var tables = new string[] {"ProductCategory", "ProductModel", "Product",
    "Address", "Customer", "CustomerAddress", "SalesOrderHeader", "SalesOrderDetail" };

    // [Required]: Add a SqlSyncProvider acting as the server hub.
    services.AddSyncServer<SqlSyncChangeTrackingProvider>(connectionString,"SqlServerScope", tables, options);
    services.AddSyncServer<MySqlSyncProvider>(mysqlConnectionString, "MySqlScope", tables, options);
}

In the controller, we can inject an IEnumerable<WebServerOrchestrator>, instead of a single instance of WebServerOrchestrator:

[ApiController]
[Route("api/[controller]")]
public class SyncController : ControllerBase
{
    public IEnumerable<WebServerOrchestrator> Orchestrators { get; }

    // Injected thanks to Dependency Injection
    public SyncController(IEnumerable<WebServerOrchestrator> webServerOrchestrators) 
        => this.Orchestrators = webServerOrchestrators;

    /// <summary>
    /// This POST handler is mandatory to handle all the sync process
    /// </summary>
    /// <returns></returns>
    [HttpPost]
    public async Task Post()
    {
        // Get Scope Name sent by the client
        var scopeName = WebServerOrchestrator.GetScopeName(HttpContext);

        // Get the orchestrator
        var orchestrator = this.Orchestrators.FirstOrDefault(c => c.ScopeName == scopeName);

        // Handle the request
        await orchestrator.HandleRequestAsync(HttpContext).ConfigureAwait(false);
    }

    /// <summary>
    /// This GET handler is optional. It allows you to see the configuration hosted on the server
    /// The configuration is shown only if Environmenent == Development
    /// </summary>
    [HttpGet]
    public Task Get() => WebServerOrchestrator.WriteHelloAsync(this.HttpContext, this.Orchestrators);
}

[VagueGit]

Thank you @Mimetis for providing this fix. We can only test internally as the last beta frightened the horses. But so far it's looking good.

We'll have to wait for the horses to settle before we run another beta.