/// <summary>
/// Raises the SyncProgress event.
/// </summary>
/// <param name="args">A SyncProgressEventArgs object that contains event data.</param>
protected virtual void OnSyncProgress(SyncProgressEventArgs args)
{
if (SyncProgress != null)
{
SyncProgress(this, args);
}
}
private void manager_SyncProgress(object sender, SyncProgressEventArgs e)
{
OnProgress(e.Configuration, e.Status, e.Percent, e.Message, e.InnerException);
Logger.Log("[{3}] [{4}] {2} Sync: {1}% - {0}", e.Message, e.Percent, e.Status, DateTime.Now, e.Configuration.Name);
if (e.InnerException != null)
{
var ie = e.InnerException;
while (ie != null)
{
Logger.Log("[{0}] [{1}] {2}{3}{4}", DateTime.Now, e.Configuration.Name, ie.Message, Environment.NewLine, ie.StackTrace);
ie = ie.InnerException;
}
}
}
protected override void OnSyncProgress(SyncProgressEventArgs value)
{
Console.Write("on sync progress on client..");
base.OnSyncProgress(value);
}
private static void SyncProgress(SyncProgressEventArgs e, ConsoleColor?consoleColor = null)
{
var sessionId = e.Context.SessionId.ToString();
if (consoleColor.HasValue)
{
Console.ForegroundColor = consoleColor.Value;
}
switch (e.Context.SyncStage)
{
case SyncStage.BeginSession:
Console.WriteLine($"Begin Session.");
break;
case SyncStage.EndSession:
Console.WriteLine($"End Session.");
break;
case SyncStage.EnsureScopes:
Console.WriteLine($"Ensure Scopes");
break;
case SyncStage.EnsureConfiguration:
Console.WriteLine($"Ensure Configuration");
if (e.Configuration != null)
{
var ds = e.Configuration.ScopeSet;
Console.WriteLine($"Configuration readed. {ds.Tables.Count} table(s) involved.");
Func <JsonSerializerSettings> settings = new Func <JsonSerializerSettings>(() =>
{
var s = new JsonSerializerSettings();
s.Formatting = Formatting.Indented;
s.StringEscapeHandling = StringEscapeHandling.Default;
return(s);
});
JsonConvert.DefaultSettings = settings;
var dsString = JsonConvert.SerializeObject(new DmSetSurrogate(ds));
//Console.WriteLine(dsString);
}
break;
case SyncStage.EnsureDatabase:
Console.WriteLine($"Ensure Database");
break;
case SyncStage.SelectingChanges:
Console.WriteLine($"Selecting changes...");
break;
case SyncStage.SelectedChanges:
Console.WriteLine($"Changes selected : {e.ChangesStatistics.TotalSelectedChanges}");
break;
case SyncStage.ApplyingChanges:
Console.WriteLine($"Applying changes...");
break;
case SyncStage.ApplyingInserts:
Console.WriteLine($"\tApplying Inserts : {e.ChangesStatistics.AppliedChanges.Where(ac => ac.State == DmRowState.Added).Sum(ac => ac.ChangesApplied) }");
break;
case SyncStage.ApplyingDeletes:
Console.WriteLine($"\tApplying Deletes : {e.ChangesStatistics.AppliedChanges.Where(ac => ac.State == DmRowState.Deleted).Sum(ac => ac.ChangesApplied) }");
break;
case SyncStage.ApplyingUpdates:
Console.WriteLine($"\tApplying Updates : {e.ChangesStatistics.AppliedChanges.Where(ac => ac.State == DmRowState.Modified).Sum(ac => ac.ChangesApplied) }");
break;
case SyncStage.AppliedChanges:
Console.WriteLine($"Changes applied : {e.ChangesStatistics.TotalAppliedChanges}");
break;
case SyncStage.WriteMetadata:
if (e.Scopes != null)
{
Console.WriteLine($"Writing Scopes : ");
e.Scopes.ForEach(sc => Console.WriteLine($"\t{sc.Id} synced at {sc.LastSync}. "));
}
break;
case SyncStage.CleanupMetadata:
Console.WriteLine($"CleanupMetadata");
break;
}
Console.ResetColor();
}
private static void SyncProgress(object sender, SyncProgressEventArgs e)
{
SyncProgress(e);
}
private void SyncProgress(object sender, SyncProgressEventArgs e)
{
var sessionId = e.Context.SessionId.ToString();
switch (e.Context.SyncStage)
{
case SyncStage.BeginSession:
Output($"Begin Session.");
break;
case SyncStage.EndSession:
Output($"End Session.");
break;
case SyncStage.EnsureScopes:
Output($"Ensure Scopes");
break;
case SyncStage.EnsureConfiguration:
Output($"Configuration readed. {e.Configuration.ScopeSet.Tables.Count} table(s) involved.");
break;
case SyncStage.EnsureDatabase:
Output($"Ensure Database");
break;
case SyncStage.SelectingChanges:
Output($"Selecting changes...");
break;
case SyncStage.SelectedChanges:
Output($"Changes selected : {e.ChangesStatistics.TotalSelectedChanges}");
break;
case SyncStage.ApplyingChanges:
Output($"Applying changes...");
break;
case SyncStage.ApplyingInserts:
Output($"\tApplying Inserts : {e.ChangesStatistics.AppliedChanges.Where(ac => ac.State == DmRowState.Added).Sum(ac => ac.ChangesApplied) }");
break;
case SyncStage.ApplyingDeletes:
Output($"\tApplying Deletes : {e.ChangesStatistics.AppliedChanges.Where(ac => ac.State == DmRowState.Deleted).Sum(ac => ac.ChangesApplied) }");
break;
case SyncStage.ApplyingUpdates:
Output($"\tApplying Updates : {e.ChangesStatistics.AppliedChanges.Where(ac => ac.State == DmRowState.Modified).Sum(ac => ac.ChangesApplied) }");
break;
case SyncStage.AppliedChanges:
Output($"Changes applied : {e.ChangesStatistics.TotalAppliedChanges}");
break;
case SyncStage.WriteMetadata:
if (e.Scopes != null)
{
Output($"Writing Scopes : ");
e.Scopes.ForEach(sc => Output($"\t{sc.Id} synced at {sc.LastSync}. "));
}
break;
case SyncStage.CleanupMetadata:
Output($"CleanupMetadata");
break;
}
Console.ResetColor();
}
static void sync_SyncProgress(object sender, SyncProgressEventArgs e)
{
Console.WriteLine("Sync Progress: {0} Status: {1}. {2}", e.Percent, e.Status, e.Message);
}
/// <summary>
/// Enumerates the changes from the server and puts them to the synccontext object
/// </summary>
/// <param name="groupMetadata">the metadata about the synchronization tables</param>
/// <param name="syncSession">the object that contains synchronization variables</param>
/// <param name="syncContext">the synchronization context to be changed</param>
/// <param name="schema">the schema of the synchronization tables</param>
private void EnumerateChanges(SyncGroupMetadata groupMetadata, SyncSession syncSession, SyncContext syncContext, SyncSchema schema)
{//#DOWNLOAD a batch 2
SyncStage syncStage = SyncStage.DownloadingChanges;
SpSyncGroupAnchor newSyncAnchor = new SpSyncGroupAnchor();
bool hasMoreData = false;
foreach (SyncTableMetadata tableMetadata in groupMetadata.TablesMetadata)
{
SpSyncAdapter adapter = null;
if (this.SyncAdapters.Contains(tableMetadata.TableName))
{
adapter = this.SyncAdapters[tableMetadata.TableName];
}
if (adapter == null)
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
Messages.InvalidTableName, tableMetadata.TableName));
}
if (!schema.SchemaDataSet.Tables.Contains(tableMetadata.TableName))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
Messages.TableNotInSchema, tableMetadata.TableName));
}
DataTable dataTable = schema.SchemaDataSet.Tables[tableMetadata.TableName].Clone();
SyncTableProgress tableProgress = syncContext.GroupProgress.FindTableProgress(tableMetadata.TableName);
SpSyncAnchor tableAnchor = SpSyncAnchor.Empty;
if (tableMetadata.LastReceivedAnchor != null &&
tableMetadata.LastReceivedAnchor.Anchor != null)
{
SpSyncGroupAnchor anchors = SpSyncGroupAnchor.Deserialize(tableMetadata.LastReceivedAnchor.Anchor);
if (anchors != null)
{
if (anchors.Contains(connString, tableMetadata.TableName))
{
tableAnchor = anchors[connString, tableMetadata.TableName];
}
newSyncAnchor = anchors;
}
}
SpSyncAnchor newAnchor = SpSyncAnchor.Empty;
try
{
if (tableMetadata.SyncDirection == SyncDirection.Snapshot)
{
newAnchor = adapter.SelectAll(tableAnchor, BatchSize, dataTable, Connection);
}
else
{
newAnchor = adapter.SelectIncremental(tableAnchor, BatchSize, Connection, dataTable);
}
hasMoreData = hasMoreData || newAnchor.HasMoreData;
if (syncContext.DataSet.Tables.Contains(tableMetadata.TableName))
{
DataTable contextTable = syncContext.DataSet.Tables[tableMetadata.TableName];
foreach (DataRow row in dataTable.Rows)
{
contextTable.ImportRow(row);
}
}
else
{
dataTable.TableName = tableMetadata.TableName;
syncContext.DataSet.Tables.Add(dataTable);
}
}
catch (Exception e)
{
var e2 = new Microsoft.Synchronization.SyncException(e.Message, e);
throw e2;
}
finally
{
newSyncAnchor[connString, tableMetadata.TableName] = newAnchor;
}
tableProgress.DataTable = dataTable;
SyncProgressEventArgs args = new SyncProgressEventArgs(tableMetadata, tableProgress, groupMetadata, syncContext.GroupProgress, syncStage);//SYNC TODO
OnSyncProgress(args);
tableProgress.DataTable = null;
}
syncContext.NewAnchor = new SyncAnchor();
syncContext.NewAnchor.Anchor = SpSyncGroupAnchor.Serialize(newSyncAnchor);
int batchCount = groupMetadata.BatchCount == 0 ? 1 : groupMetadata.BatchCount;
if (hasMoreData)
{
syncContext.BatchCount = batchCount + 1;
}
else
{
syncContext.BatchCount = batchCount;
}
}
/// #UPLOAD 2
private void ApplyChangesInternal(SyncGroupMetadata groupMetadata, DataSet dataSet, SyncSession syncSession, SyncContext syncContext)
{
SyncStage syncStage = SyncStage.UploadingChanges;
foreach (SyncTableMetadata tableMetadata in groupMetadata.TablesMetadata)
{
SpSyncAdapter adapter = null;
if (this.SyncAdapters.Contains(tableMetadata.TableName))
{
adapter = this.SyncAdapters[tableMetadata.TableName];
}
if (adapter == null)
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
Messages.InvalidTableName, tableMetadata.TableName));
}
// SpSyncAnchor anchor
if (!dataSet.Tables.Contains(tableMetadata.TableName))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
Messages.TableNotInSchema, tableMetadata.TableName));
}
SyncTableProgress tableProgress = syncContext.GroupProgress.FindTableProgress(tableMetadata.TableName);
DataTable dataTable = dataSet.Tables[tableMetadata.TableName];
try
{
Collection <SyncConflict> conflicts;
int changesCount = dataTable.Rows.Count;
adapter.Update(dataTable, Connection, out conflicts);
if (conflicts != null)
{
foreach (SyncConflict conflict in conflicts)
{
ApplyChangeFailedEventArgs failureArgs = new ApplyChangeFailedEventArgs(tableMetadata, conflict, null, syncSession, syncContext, Connection, null);
OnApplyChangeFailed(failureArgs);
if (failureArgs.Action == ApplyAction.Continue)
{
if (conflict != null)
{
tableProgress.ChangesFailed++;
tableProgress.Conflicts.Add(conflict);
}
}
}
}
tableProgress.ChangesApplied = changesCount - tableProgress.ChangesFailed;
}
catch (Exception e)
{
SyncConflict conflict = new SyncConflict(ConflictType.ErrorsOccurred, SyncStage.UploadingChanges)
{
ErrorMessage = e.Message + ", InnerException:" + e.InnerException.ToString(), ServerChange = dataTable, ClientChange = dataTable
};
ApplyChangeFailedEventArgs failureArgs = new ApplyChangeFailedEventArgs(tableMetadata, conflict, null, syncSession, syncContext, Connection, null);
OnApplyChangeFailed(failureArgs);
// handle errors?
if (SyncTracer.IsErrorEnabled())
{
SyncTracer.Error(e.ToString());
}
}
SyncProgressEventArgs args = new SyncProgressEventArgs(tableMetadata, tableProgress, groupMetadata, syncContext.GroupProgress, syncStage);
OnSyncProgress(args);
}
}
private static void ServerProvider_SyncProgress(object sender, SyncProgressEventArgs e)
{
SyncProgress(e, ConsoleColor.Red);
}
protected void OnSyncProgress(SyncProgressEventArgs syncProgressEventArgs)
{
var temp = SyncProgress;
temp?.Invoke(this, syncProgressEventArgs);
}
private static void SyncProgress(SyncProgressEventArgs e, ConsoleColor?consoleColor = null)
{
var sessionId = e.Context.SessionId.ToString();
if (consoleColor.HasValue)
{
Console.ForegroundColor = consoleColor.Value;
}
switch (e.Context.SyncStage)
{
case SyncStage.BeginSession:
Console.WriteLine($"Begin Session {sessionId}");
e.Action = ChangeApplicationAction.Rollback;
break;
case SyncStage.EndSession:
Console.WriteLine($"End Session {sessionId}");
break;
case SyncStage.EnsureMetadata:
Console.WriteLine($"{sessionId}. EnsureMetadata");
if (e.ScopeInfo != null)
{
Console.WriteLine($"{sessionId}. Ensure scope : {e.ScopeInfo.Name} - Last provider timestamp {e.ScopeInfo.LastTimestamp} - Is new : {e.ScopeInfo.IsNewScope} ");
}
if (e.Configuration != null)
{
Console.WriteLine("Configuration set.");
var ds = e.Configuration.ScopeSet;
Func <JsonSerializerSettings> settings = new Func <JsonSerializerSettings>(() =>
{
var s = new JsonSerializerSettings();
s.Formatting = Formatting.Indented;
s.StringEscapeHandling = StringEscapeHandling.Default;
return(s);
});
JsonConvert.DefaultSettings = settings;
var dsString = JsonConvert.SerializeObject(new DmSetSurrogate(ds));
Console.WriteLine(dsString);
}
if (e.DatabaseScript != null)
{
Console.WriteLine($"{sessionId}. Ensure database is created");
Console.WriteLine(e.DatabaseScript);
}
break;
case SyncStage.SelectedChanges:
Console.WriteLine($"{sessionId}. Selected added Changes : {e.ChangesStatistics.TotalSelectedChangesInserts}");
Console.WriteLine($"{sessionId}. Selected updates Changes : {e.ChangesStatistics.TotalSelectedChangesUpdates}");
Console.WriteLine($"{sessionId}. Selected deleted Changes : {e.ChangesStatistics.TotalSelectedChangesDeletes}");
break;
case SyncStage.ApplyingInserts:
Console.WriteLine($"{sessionId}. Applying Inserts : {e.ChangesStatistics.AppliedChanges.Where(ac => ac.State == DmRowState.Added).Sum(ac => ac.ChangesApplied) }");
break;
case SyncStage.ApplyingDeletes:
Console.WriteLine($"{sessionId}. Applying Deletes : {e.ChangesStatistics.AppliedChanges.Where(ac => ac.State == DmRowState.Deleted).Sum(ac => ac.ChangesApplied) }");
break;
case SyncStage.ApplyingUpdates:
Console.WriteLine($"{sessionId}. Applying Updates : {e.ChangesStatistics.AppliedChanges.Where(ac => ac.State == DmRowState.Modified).Sum(ac => ac.ChangesApplied) }");
break;
case SyncStage.WriteMetadata:
Console.WriteLine($"{sessionId}. Writing Scopes");
break;
case SyncStage.ApplyingChanges:
Console.WriteLine($"{sessionId}. Applying Changes");
break;
case SyncStage.CleanupMetadata:
Console.WriteLine($"{sessionId}. CleanupMetadata");
break;
}
Console.ResetColor();
}
private static void Sync_SyncProgress(object sender, SyncProgressEventArgs e)
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("[{3}] [{4}] {2} Sync: {1}% - {0}", e.Message, e.Percent, e.Status, DateTime.Now, e.Configuration.Name);
Console.ResetColor();
}
void Instance_SynchronizationProgress(object sender, SyncProgressEventArgs e)
{
if (InvokeRequired)
{
this.Invoke(new EventHandler<SyncProgressEventArgs>(Instance_SynchronizationProgress), sender, e);
}
else
{
synchroProgress.Value = e.Progress;
}
}
private void DeviceInstanceSyncProgress(object sender, SyncProgressEventArgs e)
{
SyncCount = e.Total;
SyncRemain = e.Remaining;
}
