public async Task <HttpResponseMessage> ApplyConflict(string filename, long remoteVersion, string remoteServerId, string remoteServerUrl)
{
var canonicalFilename = FileHeader.Canonize(filename);
var localMetadata = Synchronizations.GetLocalMetadata(canonicalFilename);
if (localMetadata == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var contentStream = await Request.Content.ReadAsStreamAsync().ConfigureAwait(false);
var current = new HistoryItem
{
ServerId = Storage.Id.ToString(),
Version = localMetadata.Value <long>(SynchronizationConstants.RavenSynchronizationVersion)
};
var currentConflictHistory = Historian.DeserializeHistory(localMetadata);
currentConflictHistory.Add(current);
var remote = new HistoryItem
{
ServerId = remoteServerId,
Version = remoteVersion
};
var remoteMetadata = RavenJObject.Load(new JsonTextReader(new StreamReader(contentStream)));
var remoteConflictHistory = Historian.DeserializeHistory(remoteMetadata);
remoteConflictHistory.Add(remote);
var conflict = new ConflictItem
{
CurrentHistory = currentConflictHistory,
RemoteHistory = remoteConflictHistory,
FileName = canonicalFilename,
RemoteServerUrl = Uri.UnescapeDataString(remoteServerUrl)
};
ConflictArtifactManager.Create(canonicalFilename, conflict);
Publisher.Publish(new ConflictNotification
{
FileName = filename,
SourceServerUrl = remoteServerUrl,
Status = ConflictStatus.Detected,
RemoteFileHeader = new FileHeader(canonicalFilename, remoteMetadata)
});
if (Log.IsDebugEnabled)
{
Log.Debug("Conflict applied for a file '{0}' (remote version: {1}, remote server id: {2}).", filename, remoteVersion, remoteServerId);
}
return(GetEmptyMessage(HttpStatusCode.NoContent));
}
private void StrategyAsGetCurrent(string fileName)
{
Storage.Batch(accessor =>
{
var conflict = accessor.GetConfigurationValue <ConflictItem>(RavenFileNameHelper.ConflictConfigNameForFile(fileName));
var localMetadata = accessor.GetFile(fileName, 0, 0).Metadata;
var localHistory = Historian.DeserializeHistory(localMetadata);
// incorporate remote version history into local
foreach (var remoteHistoryItem in conflict.RemoteHistory.Where(remoteHistoryItem => !localHistory.Contains(remoteHistoryItem)))
{
localHistory.Add(remoteHistoryItem);
}
localMetadata[SynchronizationConstants.RavenSynchronizationHistory] = Historian.SerializeHistory(localHistory);
accessor.UpdateFileMetadata(fileName, localMetadata);
ConflictArtifactManager.Delete(fileName, accessor);
Publisher.Publish(new ConflictNotification
{
FileName = fileName,
Status = ConflictStatus.Resolved
});
});
}
private static List <HistoryItem> TransformToFullConflictHistory(RavenJObject metadata)
{
var version = metadata.Value <long>(SynchronizationConstants.RavenSynchronizationVersion);
var serverId = metadata.Value <string>(SynchronizationConstants.RavenSynchronizationSource);
var fullHistory = Historian.DeserializeHistory(metadata);
fullHistory.Add(new HistoryItem {
ServerId = serverId, Version = version
});
return(fullHistory);
}
public void ApplyCurrentStrategy(string fileName, ConflictItem conflict, RavenJObject localMetadata)
{
var localHistory = Historian.DeserializeHistory(localMetadata);
// incorporate remote version history into local
foreach (var remoteHistoryItem in conflict.RemoteHistory.Where(remoteHistoryItem => !localHistory.Contains(remoteHistoryItem)))
{
localHistory.Add(remoteHistoryItem);
}
localMetadata[SynchronizationConstants.RavenSynchronizationHistory] = Historian.SerializeHistory(localHistory);
}