private async Task HandleTaskToSyncAsync(ISyncTask syncTask)
{
switch (syncTask)
{
case SyncSetTableSavable syncSetTableSavable:
await _snapshotStorage.SetTableSavableAsync(syncSetTableSavable.DbTable, syncSetTableSavable.Savable);
break;
case SyncTable syncTable:
await _snapshotStorage.SaveTableSnapshotAsync(syncTable.DbTable);
break;
case SyncPartition syncPartition:
var snapshot = syncPartition.DbTable.GetPartitionSnapshot(syncPartition.PartitionKey);
if (snapshot == null)
{
await _snapshotStorage.DeleteTablePartitionAsync(syncPartition.DbTable, syncPartition.PartitionKey);
}
else
{
await _snapshotStorage.SavePartitionSnapshotAsync(syncPartition.DbTable, snapshot);
}
break;
}
}
protected virtual void OnSyncTask()
{
try
{
//this.LogAction(CacheAction.SyncTime, CacheActionState.Debug, "SyncTaskBox OnSyncTask... ");
//0 indicates that the method is not in use.
if (0 == Interlocked.Exchange(ref synchronized, 1))
{
ISyncTask syncTask = null;
if (m_SynBox.TryDequeue(out syncTask))
{
//RenderTask(syncTask);
syncTask.DoSync();
//this.LogAction(CacheAction.SyncTime, CacheActionState.Debug, "SyncTaskBox OnSyncTask RenderTask Start {0}", syncTask.ItemName);
//Task task = Task.Factory.StartNew(() => syncTask.DoSynchronize());
}
}
}
catch (Exception ex)
{
Netlog.Exception("SyncTaskBox OnSyncTask End error :", ex);
}
finally
{
//Release the lock
Interlocked.Exchange(ref synchronized, 0);
}
}
protected ITask FindTask(IEnumerable <ITask> tasks, ISyncTask syncTask)
{
List <ITask> candidates = new List <ITask>();
foreach (var task in tasks)
{
bool nameMatches = task.Title.Trim().Equals(syncTask.Name.Trim(), StringComparison.OrdinalIgnoreCase);
bool dueMatches;
if (syncTask.Due != null)
{
dueMatches = task.Due.HasValue && task.Due.Value.Date.ToString("d") == syncTask.Due.Value.Date.ToString("d");
}
else
{
dueMatches = !task.Due.HasValue;
}
if (nameMatches && dueMatches)
{
candidates.Add(task);
}
}
return(candidates.FirstOrDefault(t => string.IsNullOrEmpty(t.SyncId)));
}
private ISyncTask Get()
{
ISyncTask res = null;
m_SynBox.TryDequeue(out res);
return(res);
}
//public void Add(SyncTask task, DataSyncEntity entity, IDataCache owner)
//{
// if (task == null || entity == null || owner == null)
// {
// this.LogAction(CacheAction.SyncTime, CacheActionState.Failed, "SyncTaskBox can not add task null!");
// return;
// }
// Add(new SyncBoxTask()
// {
// Entity = entity,
// //ItemName = task.ItemName,
// Owner = owner
// //TaskItem = task.Item
// });
//}
public void Add(ISyncTask item)
{
if (item == null)
{
Netlog.Warn("SyncTaskBox can not add task null!");
return;
}
m_SynBox.Enqueue(item);
Netlog.DebugFormat("SyncTaskBox Added SyncBoxTask {0}", item.ItemName);
}
public void RemoveSyncTask(ISyncTask syncTask)
{
try
{
_semaphore.Wait();
_syncTasks.Remove(syncTask);
}
finally
{
_semaphore.Release();
}
}
public ISyncer AddSyncTask(ISyncTask syncTask)
{
try
{
_semaphore.Wait();
_syncTasks.Add(syncTask);
}
finally
{
_semaphore.Release();
}
return(this);
}
private void EnqueueTask(DbTable dbTable, ISyncTask syncTask)
{
lock (_lockObject)
{
_taskId++;
syncTask.Id = _taskId;
if (!_syncTasks.ContainsKey(dbTable.Name))
{
_syncTasks.Add(dbTable.Name, new SyncQueueByTable());
}
_syncTasks[dbTable.Name].Enqueue(syncTask);
}
}
internal static void Configure(this Registry registry, ISyncTask task, RecurrencePatternConfiguration configuration)
{
switch (configuration)
{
case DailyRecurrencePatternConfiguration dailyConfiguration:
var dailySchedule = registry.Schedule(() => task.Execute());
Schedule(dailySchedule, dailyConfiguration);
break;
case MonthlyNamedRecurrencePatternConfiguration monthlyNamedConfiguration:
var monthlyNamedSchedule = registry.Schedule(() => task.Execute());
Schedule(monthlyNamedSchedule, monthlyNamedConfiguration);
break;
case MonthlyRecurrencePatternConfiguration monthlyConfiguration:
var monthlySchedule = registry.Schedule(() => task.Execute());
Schedule(monthlySchedule, monthlyConfiguration);
break;
case TimePartRecurrencePatternConfiguration timePartConfiguration:
var timePartSchedule = registry.Schedule(() => task.Execute());
Schedule(timePartSchedule, timePartConfiguration);
break;
case WeekendRecurrencePatternConfiguration weekendConfiguration:
var saturdayWeekendDaySchedule = registry.Schedule(() => task.Execute());
var sundayWeekendDaySchedule = registry.Schedule(() => task.Execute());
Schedule(saturdayWeekendDaySchedule, sundayWeekendDaySchedule, weekendConfiguration);
break;
case WeeklyRecurrencePatternConfiguration weeklyConfiguration:
var weeklySchedule = registry.Schedule(() => task.Execute());
Schedule(weeklySchedule, weeklyConfiguration);
break;
case WorkdayRecurrencePatternConfiguration workdayConfiguration:
var workdaySchedule = registry.Schedule(() => task.Execute());
Schedule(workdaySchedule, workdayConfiguration);
break;
}
}
async Task RunSyncServiceAsync(ISyncTask syncService)
{
await syncService.RunAsync();
Console.WriteLine(MessageResource.CommandCompleted);
}
public void Enqueue(ISyncTask syncTask)
{
_queue.Add(syncTask.Id, syncTask);
}
/// <summary>
/// Schedule task instance
/// </summary>
/// <param name="task"></param>
/// <param name="config"></param>
public void ScheduleTask(ISyncTask task, RecurrencePatternConfiguration config)
{
_registry.Configure(task, config);
}
