public void ResolveConflictLocalWins(SyncConflict conflict)
{
if (_closed)
{
throw new InvalidOperationException();
}
var tickCount = _store.IncrementLocalRepilcaTickCount();
var modifiedReplica = new ReplicaInfo
{
ReplicaId = _store.GetLocalReplicaId(),
ReplicaTickCount = tickCount
};
var resolvedStatus = conflict.LocalItemInfo.Deleted ? SyncStatus.Delete : SyncStatus.Update;
var data = JObject.Parse("{item:{itemRefs:[]}}");
if (resolvedStatus != SyncStatus.Delete)
{
var builder = SyncUtil.JsonItemFromSyncableItemInfo(conflict.LocalItemInfo);
_store.BuildItemData(conflict.LocalItemInfo, builder);
data = new JObject {
{ "item", builder }
};
}
using (var connection = _syncSessionDbConnectionProvider.GetSyncSessionDbConnection(_localSessionId))
{
SessionDbHelper.ResolveItemWithData(connection, conflict.RemoteItemInfo, resolvedStatus, modifiedReplica,
data);
}
}
public string GetDbState()
{
JObject state = new JObject();
var knowledge = GenerateLocalKnowledge().OrderBy((ri) => { return(ri.ReplicaId + ri.ReplicaTickCount.ToString()); });
state.Add("knowledge", SyncUtil.KnowledgeToJson(knowledge));
foreach (var itemType in GetItemTypes())
{
var handler = HandlerForItemType(itemType);
JArray items = new JArray();
IDbCommand selectCommand = _connection.CreateCommand();
selectCommand.CommandText = String.Format("SELECT CreatedReplica, CreatedTickCount, ModifiedReplica, ModifiedTickCount FROM {0}", handler.DbTable);
IList <ISyncableItemInfo> itemInfos = new List <ISyncableItemInfo>();
using (IDataReader reader = selectCommand.ExecuteReader())
{
while (reader.Read())
{
IReplicaInfo createdReplicaInfo = ReplicaInfoFromDataReader(reader, "Created");
IReplicaInfo modifiedReplicaInfo = ReplicaInfoFromDataReader(reader, "Modified");
itemInfos.Add(new SyncableItemInfo {
ItemType = handler.TypeName, Created = createdReplicaInfo, Modified = modifiedReplicaInfo, Deleted = false
});
}
}
var sortedItemInfos = itemInfos.OrderBy((ii) => { return(ii.Created.ReplicaId + ii.Created.ReplicaTickCount.ToString()); });
foreach (var syncItemInfo in sortedItemInfos)
{
JObject builder = SyncUtil.JsonItemFromSyncableItemInfo(syncItemInfo);
BuildItemData(syncItemInfo, builder);
items.Add(builder);
}
state.Add(itemType, items);
}
return(state.ToString());
}
private async Task PushChanges()
{
ReportProgressAndCheckCacellation(new SyncProgress
{
Stage = SyncStage.FindingLocalChanges,
PercentComplete = 0,
Message = "Finding local changes"
});
var request = new JObject {
{ "sessionID", _remoteSessionId }
};
var localKnowledge = _store.GenerateLocalKnowledge();
var changedItemInfos = _store.LocateChangedItems(_remoteKnowledge).ToList();
int totalChanges = changedItemInfos.Count();
request.Add(new JProperty("knowledge", SyncUtil.KnowledgeToJson(localKnowledge)));
request.Add(new JProperty("changeCount", totalChanges));
await _transport.TransportAsync(SyncEndpoint.PutChanges, request);
ReportProgressAndCheckCacellation(new SyncProgress
{
Stage = SyncStage.FindingLocalChanges,
PercentComplete = 100,
Message = String.Format("Found {0} local changes", totalChanges)
});
ReportProgressAndCheckCacellation(new SyncProgress
{
Stage = SyncStage.UploadingLocalChanges,
PercentComplete = 0,
Message = String.Format("Uploading {0} local changes", totalChanges)
});
int maxBatchCount = PushMaxBatchCount;
int maxBatchSize = PushMaxBatchSize;
long startTick = Environment.TickCount;
int previousPercentComplete = -1;
int i = 0;
var batchArray = new JArray();
int batchSize = 0;
foreach (ISyncableItemInfo syncItemInfo in changedItemInfos)
{
i++;
int percentComplete = ((i * 100) / totalChanges);
if (percentComplete != previousPercentComplete)
{
ReportProgressAndCheckCacellation(new SyncProgress
{
Stage = SyncStage.UploadingLocalChanges,
PercentComplete = 100,
Message =
String.Format("Uploading local changes, {0}% complete ({1})", percentComplete,
String.Format("Averaging {0}ms/item over {1} items",
(Environment.TickCount - startTick) / i, i))
});
}
previousPercentComplete = percentComplete;
var builder = SyncUtil.JsonItemFromSyncableItemInfo(syncItemInfo);
if (!syncItemInfo.Deleted)
{
_store.BuildItemData(syncItemInfo, builder);
}
var singleItemRequest = new JObject {
{ "changeNumber", i }, { "item", builder }
};
batchSize += singleItemRequest.ToString().Length;
batchArray.Add(singleItemRequest);
if (i == totalChanges || (i % maxBatchCount) == 0 || batchSize >= maxBatchSize)
{
var batchRequest = new JObject {
{ "sessionID", _remoteSessionId }, { "batch", batchArray }
};
await _transport.TransportAsync(SyncEndpoint.PutItemDataBatch, batchRequest);
batchArray = new JArray();
batchSize = 0;
}
}
ReportProgressAndCheckCacellation(new SyncProgress
{
Stage = SyncStage.UploadingLocalChanges,
PercentComplete = 100,
Message = String.Format("Uploaded {0} local changes", totalChanges)
});
await ApplyChanges(totalChanges);
}
private IEnumerable <SyncConflict> CheckForDuplicates(IDbConnection connection)
{
var conflicts = new List <SyncConflict>();
var changedItemInfos = _store.LocateChangedItems(_remoteKnowledge).ToList();
foreach (string itemType in _store.GetItemTypes())
{
IDbCommand getInsertedItemsCommand = connection.CreateCommand();
getInsertedItemsCommand.CommandText =
String.Format(
"SELECT ItemID, SyncStatus, ItemType, GlobalCreatedReplica, CreatedTickCount, GlobalModifiedReplica, ModifiedTickCount, ItemData FROM SyncItems WHERE SyncStatus={0} AND ItemType='{1}'",
(int)SyncStatus.Insert, itemType);
using (IDataReader reader = getInsertedItemsCommand.ExecuteReader())
{
while (reader != null && reader.Read())
{
long itemId = Convert.ToInt64(reader["ItemID"]);
IReplicaInfo createdReplicaInfo = SessionDbHelper.ReplicaInfoFromDataReader(reader, "Created");
IReplicaInfo modifiedReplicaInfo = SessionDbHelper.ReplicaInfoFromDataReader(reader, "Modified");
ISyncableItemInfo remoteItemInfo = new SyncableItemInfo
{
ItemType = itemType,
Created = createdReplicaInfo,
Modified = modifiedReplicaInfo,
Deleted = false
};
var remoteItemData = JObject.Parse((string)reader["ItemData"]);
foreach (var changedItemInfo in changedItemInfos)
{
if (changedItemInfo.ItemType != remoteItemInfo.ItemType)
{
continue;
}
if (SyncUtil.KnowledgeContains(_remoteKnowledge, changedItemInfo.Created))
{
continue;
}
// Inserted here without remote knowledge, could be a dup
var builder = SyncUtil.JsonItemFromSyncableItemInfo(changedItemInfo);
_store.BuildItemData(changedItemInfo, builder);
var localItemData = new JObject {
{ "item", builder }
};
DuplicateStatus dupStatus = _store.GetDuplicateStatus(remoteItemInfo.ItemType, localItemData,
remoteItemData);
if (dupStatus == DuplicateStatus.Exact)
{
SessionDbHelper.ReplaceAllItemRefs(connection, _store, remoteItemInfo, changedItemInfo);
long tickCount = _store.IncrementLocalRepilcaTickCount();
IReplicaInfo modifiedReplica = new ReplicaInfo
{
ReplicaId = _store.GetLocalReplicaId(),
ReplicaTickCount = tickCount
};
SessionDbHelper.ResolveItemNoData(connection, remoteItemInfo,
SyncStatus.DeleteNonExisting, modifiedReplica);
break;
}
if (dupStatus == DuplicateStatus.Possible)
{
// TODO: clean this up, this call does more than we need
SessionDbHelper.ResolveItemNoData(connection, remoteItemInfo, SyncStatus.InsertConflict,
remoteItemInfo.Modified);
conflicts.Add(new SyncConflict(itemId, SyncStatus.InsertConflict, changedItemInfo,
remoteItemInfo));
break;
}
}
}
}
}
return(conflicts);
}
private IEnumerable <SyncConflict> LoadConflicts(IDbConnection connection)
{
var conflicts = new List <SyncConflict>();
IDbCommand getInsertedItemsCommand = connection.CreateCommand();
getInsertedItemsCommand.CommandText =
String.Format(
"SELECT ItemID, SyncStatus, ItemType, GlobalCreatedReplica, CreatedTickCount, GlobalModifiedReplica, ModifiedTickCount, ItemData FROM SyncItems WHERE SyncStatus NOT IN ({0},{1},{2},{3},{4},{5})",
(int)SyncStatus.Insert,
(int)SyncStatus.Update,
(int)SyncStatus.Delete,
(int)SyncStatus.DeleteNonExisting,
(int)SyncStatus.MayBeNeeded,
(int)SyncStatus.InsertConflict
);
using (var reader = getInsertedItemsCommand.ExecuteReader())
{
while (reader != null && reader.Read())
{
var createdReplicaInfo = SessionDbHelper.ReplicaInfoFromDataReader(reader, "Created");
var modifiedReplicaInfo = SessionDbHelper.ReplicaInfoFromDataReader(reader, "Modified");
var itemType = (string)reader["ItemType"];
var remoteItemInfo = new SyncableItemInfo
{
ItemType = itemType,
Created = createdReplicaInfo,
Modified = modifiedReplicaInfo,
Deleted = false
};
var itemId = Convert.ToInt64(reader["ItemID"]);
var status = (SyncStatus)reader["SyncStatus"];
ISyncableItemInfo localItemInfo = _store.LocateCurrentItemInfo(remoteItemInfo);
if (status == SyncStatus.UpdateConflict)
{
// Check to see if the "conflict" is actually an exact same update
var builder = SyncUtil.JsonItemFromSyncableItemInfo(localItemInfo);
_store.BuildItemData(localItemInfo, builder);
var localItemData = new JObject {
{ "item", builder }
};
var remoteItemData = JObject.Parse((string)reader["ItemData"]);
var dupStatus = _store.GetDuplicateStatus(remoteItemInfo.ItemType, localItemData,
remoteItemData);
if (dupStatus == DuplicateStatus.Exact)
{
var tickCount = _store.IncrementLocalRepilcaTickCount();
var modifiedReplica = new ReplicaInfo
{
ReplicaId = _store.GetLocalReplicaId(),
ReplicaTickCount = tickCount
};
SessionDbHelper.ResolveItemNoData(connection, remoteItemInfo, SyncStatus.Update,
modifiedReplica);
// TODO: Really should have an update status that just updates the modified repos without doing everything else, but this should work
continue;
}
}
conflicts.Add(new SyncConflict(itemId, status, localItemInfo, remoteItemInfo));
}
}
return(conflicts);
}