public async Task <DestinationSyncResult> CreateDestinationResult(SynchronizationDestination destination, IEnumerable <Task <SynchronizationReport> > synchronizations)
{
try
{
var reports = await Task.WhenAll(synchronizations).ConfigureAwait(false);
var destinationSyncResult = new DestinationSyncResult
{
DestinationServer = destination.ServerUrl,
DestinationFileSystem = destination.FileSystem
};
if (reports.Length > 0)
{
var successfulSynchronizationsCount = reports.Count(x => x.Exception == null);
var failedSynchronizationsCount = reports.Count(x => x.Exception != null);
if (successfulSynchronizationsCount > 0 || failedSynchronizationsCount > 0)
{
if (Log.IsDebugEnabled)
{
Log.Debug(
"Synchronization to a destination {0} has completed. {1} file(s) were synchronized successfully, {2} synchronization(s) were failed",
destination.Url, successfulSynchronizationsCount, failedSynchronizationsCount);
}
}
destinationSyncResult.Reports = reports;
}
return(destinationSyncResult);
}
catch (Exception ex)
{
Log.WarnException(string.Format("Failed to perform a synchronization to a destination {0}", destination), ex);
return(new DestinationSyncResult
{
DestinationServer = destination.ServerUrl,
DestinationFileSystem = destination.FileSystem,
Exception = ex
});
}
}
private async Task <DestinationSyncResult> SynchronizeDestinationAsync(SynchronizationDestination destination,
bool forceSyncingContinuation)
{
try
{
ICredentials credentials = null;
if (string.IsNullOrEmpty(destination.Username) == false)
{
credentials = string.IsNullOrEmpty(destination.Domain)
? new NetworkCredential(destination.Username, destination.Password)
: new NetworkCredential(destination.Username, destination.Password, destination.Domain);
}
var destinationClient = new AsyncFilesServerClient(destination.ServerUrl, destination.FileSystem,
apiKey: destination.ApiKey, credentials: credentials).Synchronization;
var lastETag = await destinationClient.GetLastSynchronizationFromAsync(storage.Id);
var activeTasks = synchronizationQueue.Active;
var filesNeedConfirmation = GetSyncingConfigurations(destination).Where(sync => activeTasks.All(x => x.FileName != sync.FileName)).ToList();
var confirmations = await ConfirmPushedFiles(filesNeedConfirmation, destinationClient);
var needSyncingAgain = new List <FileHeader>();
foreach (var confirmation in confirmations)
{
if (confirmation.Status == FileStatus.Safe)
{
Log.Debug("Destination server {0} said that file '{1}' is safe", destination, confirmation.FileName);
RemoveSyncingConfiguration(confirmation.FileName, destination.Url);
}
else
{
storage.Batch(accessor =>
{
var fileHeader = accessor.ReadFile(confirmation.FileName);
if (fileHeader != null)
{
needSyncingAgain.Add(fileHeader);
Log.Debug("Destination server {0} said that file '{1}' is {2}.", destination, confirmation.FileName, confirmation.Status);
}
});
}
}
await EnqueueMissingUpdatesAsync(destinationClient, lastETag, needSyncingAgain);
var reports = await Task.WhenAll(SynchronizePendingFilesAsync(destinationClient, forceSyncingContinuation));
var destinationSyncResult = new DestinationSyncResult
{
DestinationServer = destination.ServerUrl,
DestinationFileSystem = destination.FileSystem
};
if (reports.Length > 0)
{
var successfulSynchronizationsCount = reports.Count(x => x.Exception == null);
var failedSynchronizationsCount = reports.Count(x => x.Exception != null);
if (successfulSynchronizationsCount > 0 || failedSynchronizationsCount > 0)
{
Log.Debug(
"Synchronization to a destination {0} has completed. {1} file(s) were synchronized successfully, {2} synchronization(s) were failed",
destination.Url, successfulSynchronizationsCount, failedSynchronizationsCount);
}
destinationSyncResult.Reports = reports;
}
return(destinationSyncResult);
}
catch (Exception ex)
{
Log.WarnException(string.Format("Failed to perform a synchronization to a destination {0}", destination), ex);
return(new DestinationSyncResult
{
DestinationServer = destination.ServerUrl,
DestinationFileSystem = destination.FileSystem,
Exception = ex
});
}
}
