public override async Task<SynchronizationReport> PerformAsync(ISynchronizationServerClient synchronizationServerClient)
{
AssertLocalFileExistsAndIsNotConflicted(FileMetadata);
var destinationMetadata = await synchronizationServerClient.GetMetadataForAsync(FileName);
if (destinationMetadata == null)
{
// if file doesn't exist on destination server - upload it there
return await UploadToAsync(synchronizationServerClient);
}
var destinationServerRdcStats = await synchronizationServerClient.GetRdcStatsAsync();
if (!IsRemoteRdcCompatible(destinationServerRdcStats))
throw new SynchronizationException("Incompatible RDC version detected on destination server");
var conflict = CheckConflictWithDestination(FileMetadata, destinationMetadata, FileSystemInfo.Url);
if (conflict != null)
{
var report = await HandleConflict(synchronizationServerClient, conflict, log);
if (report != null)
return report;
}
using (var localSignatureRepository = new StorageSignatureRepository(Storage, FileName))
using (var remoteSignatureCache = new VolatileSignatureRepository(FileName))
{
var localRdcManager = new LocalRdcManager(localSignatureRepository, Storage, sigGenerator);
var destinationRdcManager = new RemoteRdcManager(synchronizationServerClient, localSignatureRepository, remoteSignatureCache);
log.Debug("Starting to retrieve signatures of a local file '{0}'.", FileName);
Cts.Token.ThrowIfCancellationRequested();
// first we need to create a local file signatures before we synchronize with remote ones
var localSignatureManifest = await localRdcManager.GetSignatureManifestAsync(FileDataInfo);
log.Debug("Number of a local file '{0}' signatures was {1}.", FileName, localSignatureManifest.Signatures.Count);
if (localSignatureManifest.Signatures.Any())
{
var destinationSignatureManifest = await destinationRdcManager.SynchronizeSignaturesAsync(FileDataInfo, Cts.Token);
if (destinationSignatureManifest.Signatures.Any())
{
return await SynchronizeTo(synchronizationServerClient, localSignatureRepository, remoteSignatureCache, localSignatureManifest, destinationSignatureManifest);
}
}
return await UploadToAsync(synchronizationServerClient);
}
}
public void Should_be_the_same_signatures()
{
const int size = 1024 * 1024 * 5;
var randomStream = new RandomStream(size);
var buffer = new byte[size];
randomStream.Read(buffer, 0, size);
var stream = new MemoryStream(buffer);
var firstSigContentHashes = new List<string>();
using (var signatureRepository = new VolatileSignatureRepository("test"))
using (var rested = new SigGenerator())
{
var result = rested.GenerateSignatures(stream, "test", signatureRepository);
foreach (var signatureInfo in result)
{
using (var content = signatureRepository.GetContentForReading(signatureInfo.Name))
{
firstSigContentHashes.Add(content.GetMD5Hash());
}
}
}
stream.Position = 0;
var secondSigContentHashes = new List<string>();
using (var signatureRepository = new VolatileSignatureRepository("test"))
using (var rested = new SigGenerator())
{
var result = rested.GenerateSignatures(stream, "test", signatureRepository);
foreach (var signatureInfo in result)
{
using (var content = signatureRepository.GetContentForReading(signatureInfo.Name))
{
secondSigContentHashes.Add(content.GetMD5Hash());
}
}
}
Assert.Equal(firstSigContentHashes.Count, secondSigContentHashes.Count);
for (var i = 0; i < firstSigContentHashes.Count; i++)
{
Assert.Equal(firstSigContentHashes[i], secondSigContentHashes[i]);
}
}
public void Generate_check()
{
using (var signatureRepository = new VolatileSignatureRepository("test"))
using (var rested = new SigGenerator())
{
var result = rested.GenerateSignatures(_stream, "test", signatureRepository);
Assert.Equal(2, result.Count);
using (var content = signatureRepository.GetContentForReading(result[0].Name))
{
Assert.Equal("91b64180c75ef27213398979cc20bfb7", content.GetMD5Hash());
}
using (var content = signatureRepository.GetContentForReading(result[1].Name))
{
Assert.Equal("9fe9d408aed35769e25ece3a56f2d12f", content.GetMD5Hash());
}
}
}
public void Signatures_can_be_generated_on_the_same_repository()
{
const int size = 1024 * 1024 * 5;
var randomStream = new RandomStream(size);
var buffer = new byte[size];
randomStream.Read(buffer, 0, size);
var stream = new MemoryStream(buffer);
foreach (var fileName in new [] { "test", "content/test", "/content/test"})
{
using (var signatureRepository = new VolatileSignatureRepository(fileName))
using (var rested = new SigGenerator())
{
var signatures = signatureRepository.GetByFileName();
Assert.Equal(0, signatures.Count());
stream.Position = 0;
var result = rested.GenerateSignatures(stream, fileName, signatureRepository);
signatures = signatureRepository.GetByFileName();
Assert.Equal(2, signatures.Count());
stream.Position = 0;
result = rested.GenerateSignatures(stream, fileName, signatureRepository);
signatures = signatureRepository.GetByFileName();
Assert.Equal(2, signatures.Count());
}
}
}
