public RemoteRdcManager(RavenFileSystemClient.SynchronizationClient ravenFileSystemClient, ISignatureRepository localSignatureRepository,
ISignatureRepository remoteCacheSignatureRepository)
{
this.localSignatureRepository = localSignatureRepository;
this.remoteCacheSignatureRepository = remoteCacheSignatureRepository;
this.ravenFileSystemClient = ravenFileSystemClient;
}
public RemoteRdcManager(RavenFileSystemClient.SynchronizationClient ravenFileSystemClient, ISignatureRepository localSignatureRepository,
ISignatureRepository remoteCacheSignatureRepository)
{
this.localSignatureRepository = localSignatureRepository;
this.remoteCacheSignatureRepository = remoteCacheSignatureRepository;
this.ravenFileSystemClient = ravenFileSystemClient;
}
public override Task <SynchronizationReport> PerformAsync(RavenFileSystemClient.SynchronizationClient destination)
{
FileAndPages fileAndPages = null;
Storage.Batch(accessor => fileAndPages = accessor.GetFile(FileName, 0, 0));
return(destination.RenameAsync(FileName, rename, fileAndPages.Metadata, ServerInfo));
}
public override async Task <SynchronizationReport> PerformAsync(RavenFileSystemClient.SynchronizationClient destination)
{
AssertLocalFileExistsAndIsNotConflicted(FileMetadata);
var destinationMetadata = await destination.GetMetadataForAsync(FileName);
if (destinationMetadata == null)
{
// if file doesn't exist on destination server - upload it there
return(await UploadToAsync(destination));
}
var destinationServerRdcStats = await destination.GetRdcStatsAsync();
if (!IsRemoteRdcCompatible(destinationServerRdcStats))
{
throw new SynchronizationException("Incompatible RDC version detected on destination server");
}
var conflict = CheckConflictWithDestination(FileMetadata, destinationMetadata, ServerInfo.FileSystemUrl);
if (conflict != null)
{
return(await ApplyConflictOnDestinationAsync(conflict, destination, ServerInfo.FileSystemUrl, log));
}
using (var localSignatureRepository = new StorageSignatureRepository(Storage, FileName))
using (var remoteSignatureCache = new VolatileSignatureRepository(FileName))
{
var localRdcManager = new LocalRdcManager(localSignatureRepository, Storage, sigGenerator);
var destinationRdcManager = new RemoteRdcManager(destination, 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.Count > 0)
{
var destinationSignatureManifest = await destinationRdcManager.SynchronizeSignaturesAsync(FileDataInfo, Cts.Token);
if (destinationSignatureManifest.Signatures.Count > 0)
{
return
(await
SynchronizeTo(destination, localSignatureRepository, remoteSignatureCache, localSignatureManifest,
destinationSignatureManifest));
}
}
return(await UploadToAsync(destination));
}
}
public SynchronizationMultipartRequest(RavenFileSystemClient.SynchronizationClient destination, ServerInfo serverInfo, string fileName,
RavenJObject sourceMetadata, Stream sourceStream, IList<RdcNeed> needList)
{
this.destination = destination;
this.serverInfo = serverInfo;
this.fileName = fileName;
this.sourceMetadata = sourceMetadata;
this.sourceStream = sourceStream;
this.needList = needList;
syncingBoundary = "syncing";
}
public SynchronizationMultipartRequest(RavenFileSystemClient.SynchronizationClient destination, ServerInfo serverInfo, string fileName,
RavenJObject sourceMetadata, Stream sourceStream, IList <RdcNeed> needList)
{
this.destination = destination;
this.serverInfo = serverInfo;
this.fileName = fileName;
this.sourceMetadata = sourceMetadata;
this.sourceStream = sourceStream;
this.needList = needList;
syncingBoundary = "syncing";
}
public override Task <SynchronizationReport> PerformAsync(RavenFileSystemClient.SynchronizationClient destination)
{
AssertLocalFileExistsAndIsNotConflicted(FileMetadata);
var conflict = CheckConflictWithDestination(FileMetadata, destinationMetadata, ServerInfo.FileSystemUrl);
if (conflict != null)
{
return(ApplyConflictOnDestinationAsync(conflict, destination, ServerInfo.FileSystemUrl, log));
}
return(destination.UpdateMetadataAsync(FileName, FileMetadata, ServerInfo));
}
private Task <SynchronizationReport> PushByUsingMultipartRequest(RavenFileSystemClient.SynchronizationClient destination, Stream sourceFileStream,
IList <RdcNeed> needList)
{
Cts.Token.ThrowIfCancellationRequested();
multipartRequest = new SynchronizationMultipartRequest(destination, ServerInfo, FileName, FileMetadata, sourceFileStream, needList);
var bytesToTransferCount = needList.Where(x => x.BlockType == RdcNeedType.Source).Sum(x => (double)x.BlockLength);
log.Debug(
"Synchronizing a file '{0}' (ETag {1}) to {2} by using multipart request. Need list length is {3}. Number of bytes that needs to be transfered is {4}",
FileName, FileETag, destination, needList.Count, bytesToTransferCount);
return(multipartRequest.PushChangesAsync(Cts.Token));
}
public async Task <SynchronizationReport> UploadToAsync(RavenFileSystemClient.SynchronizationClient destination)
{
using (var sourceFileStream = StorageStream.Reading(Storage, FileName))
{
var fileSize = sourceFileStream.Length;
var onlySourceNeed = new List <RdcNeed>
{
new RdcNeed
{
BlockType = RdcNeedType.Source,
BlockLength = (ulong)fileSize,
FileOffset = 0
}
};
return(await PushByUsingMultipartRequest(destination, sourceFileStream, onlySourceNeed));
}
}
private async Task <SynchronizationReport> SynchronizeTo(RavenFileSystemClient.SynchronizationClient destination,
ISignatureRepository localSignatureRepository,
ISignatureRepository remoteSignatureRepository,
SignatureManifest sourceSignatureManifest,
SignatureManifest destinationSignatureManifest)
{
var seedSignatureInfo = SignatureInfo.Parse(destinationSignatureManifest.Signatures.Last().Name);
var sourceSignatureInfo = SignatureInfo.Parse(sourceSignatureManifest.Signatures.Last().Name);
using (var localFile = StorageStream.Reading(Storage, FileName))
{
IList <RdcNeed> needList;
using (var needListGenerator = new NeedListGenerator(remoteSignatureRepository, localSignatureRepository))
{
needList = needListGenerator.CreateNeedsList(seedSignatureInfo, sourceSignatureInfo, Cts.Token);
}
return(await PushByUsingMultipartRequest(destination, localFile, needList));
}
}
public RemoteSignaturePartialAccess(RavenFileSystemClient.SynchronizationClient synchronizationClient, string fileName)
{
this.synchronizationClient = synchronizationClient;
_fileName = fileName;
}
public RemoteSignaturePartialAccess(RavenFileSystemClient.SynchronizationClient synchronizationClient, string fileName)
{
this.synchronizationClient = synchronizationClient;
_fileName = fileName;
}
public abstract Task <SynchronizationReport> PerformAsync(RavenFileSystemClient.SynchronizationClient destination);
protected async Task <SynchronizationReport> ApplyConflictOnDestinationAsync(ConflictItem conflict, RavenFileSystemClient.SynchronizationClient destination, string localServerUrl, ILog log)
{
log.Debug("File '{0}' is in conflict with destination version from {1}. Applying conflict on destination", FileName, destination.FileSystemUrl);
try
{
var version = conflict.RemoteHistory.Last().Version;
var serverId = conflict.RemoteHistory.Last().ServerId;
var history = new List <HistoryItem>(conflict.RemoteHistory);
history.RemoveAt(conflict.RemoteHistory.Count - 1);
await destination.ApplyConflictAsync(FileName, version, serverId, history, localServerUrl);
}
catch (Exception ex)
{
log.WarnException(string.Format("Failed to apply conflict on {0} for file '{1}'", destination, FileName), ex);
}
return(new SynchronizationReport(FileName, FileETag, SynchronizationType)
{
Exception = new SynchronizationException(string.Format("File {0} is conflicted", FileName)),
});
}
