private void SaveSynchronizationSourceInformation(ServerInfo sourceServer, Guid lastSourceEtag,
StorageActionsAccessor accessor)
{
var lastSynchronizationInformation = GetLastSynchronization(sourceServer.Id, accessor);
if (Buffers.Compare(lastSynchronizationInformation.LastSourceFileEtag.ToByteArray(), lastSourceEtag.ToByteArray()) >
0)
{
return;
}
var synchronizationSourceInfo = new SourceSynchronizationInformation
{
LastSourceFileEtag = lastSourceEtag,
SourceServerUrl = sourceServer.Url,
DestinationServerId = Storage.Id
};
var key = SynchronizationConstants.RavenSynchronizationSourcesBasePath + "/" + sourceServer.Id;
accessor.SetConfig(key, synchronizationSourceInfo.AsConfig());
Log.Debug("Saved last synchronized file ETag {0} from {1} ({2})", lastSourceEtag, sourceServer.Url, sourceServer.Id);
}
private IEnumerable<FileHeader> GetFilesToSynchronization(
SourceSynchronizationInformation destinationsSynchronizationInformationForSource, int take)
{
var filesToSynchronization = new List<FileHeader>();
Log.Debug("Getting files to synchronize with ETag greater than {0} [parameter take = {1}]",
destinationsSynchronizationInformationForSource.LastSourceFileEtag, take);
try
{
storage.Batch(
accessor =>
filesToSynchronization =
accessor.GetFilesAfter(destinationsSynchronizationInformationForSource.LastSourceFileEtag, take).ToList());
}
catch (Exception e)
{
Log.WarnException(
string.Format("Could not get files to synchronize after: " +
destinationsSynchronizationInformationForSource.LastSourceFileEtag), e);
}
return filesToSynchronization;
}
private SourceSynchronizationInformation GetLastSynchronization(Guid from, StorageActionsAccessor accessor)
{
SourceSynchronizationInformation info;
try
{
info =
accessor.GetConfig(SynchronizationConstants.RavenSynchronizationSourcesBasePath + "/" + from).AsObject
<SourceSynchronizationInformation>();
}
catch (FileNotFoundException)
{
info = new SourceSynchronizationInformation
{
LastSourceFileEtag = Guid.Empty,
DestinationServerId = Storage.Id
};
}
return info;
}
private async Task EnqueueMissingUpdatesAsync(RavenFileSystemClient destinationClient,
SourceSynchronizationInformation lastEtag,
IList<FileHeader> needSyncingAgain)
{
LogFilesInfo("There were {0} file(s) that needed synchronization because the previous one went wrong: {1}",
needSyncingAgain);
var destinationUrl = destinationClient.ServerUrl;
var filesToSynchronization = new HashSet<FileHeader>(GetFilesToSynchronization(lastEtag, 100),
new FileHeaderNameEqualityComparer());
LogFilesInfo("There were {0} file(s) that needed synchronization because of greater ETag value: {1}",
filesToSynchronization);
foreach (FileHeader needSyncing in needSyncingAgain)
{
filesToSynchronization.Add(needSyncing);
}
var filteredFilesToSynchronization =
filesToSynchronization.Where(
x => synchronizationStrategy.Filter(x, lastEtag.DestinationServerId, filesToSynchronization)).ToList();
if (filesToSynchronization.Count > 0)
{
LogFilesInfo("There were {0} file(s) that needed synchronization after filtering: {1}",
filteredFilesToSynchronization);
}
if (filteredFilesToSynchronization.Count == 0)
return;
foreach (var fileHeader in filteredFilesToSynchronization)
{
var file = fileHeader.Name;
var localMetadata = GetLocalMetadata(file);
NameValueCollection destinationMetadata;
try
{
destinationMetadata = await destinationClient.GetMetadataForAsync(file);
}
catch (Exception ex)
{
Log.WarnException(
string.Format(
"Could not retrieve a metadata of a file '{0}' from {1} in order to determine needed synchronization type", file,
destinationUrl), ex);
continue;
}
NoSyncReason reason;
var work = synchronizationStrategy.DetermineWork(file, localMetadata, destinationMetadata, ServerUrl, out reason);
if (work == null)
{
Log.Debug("File '{0}' were not synchronized to {1}. {2}", file, destinationUrl, reason.GetDescription());
if (reason == NoSyncReason.ContainedInDestinationHistory)
{
var etag = localMetadata.Value<Guid>("ETag");
destinationClient.Synchronization.IncrementLastETagAsync(storage.Id, ServerUrl, etag);
RemoveSyncingConfiguration(file, destinationClient.ServerUrl);
}
continue;
}
synchronizationQueue.EnqueueSynchronization(destinationUrl, work);
}
}