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 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)), }); }