public async Task<HttpResponseMessage> Manifest(string id) { var canonicalFilename = FileHeader.Canonize(id); FileAndPagesInformation fileAndPages = null; Storage.Batch(accessor => fileAndPages = accessor.GetFile(canonicalFilename, 0, 0)); long? fileLength = fileAndPages.TotalSize; using (var signatureRepository = new StorageSignatureRepository(Storage, canonicalFilename)) { var rdcManager = new LocalRdcManager(signatureRepository, Storage, SigGenerator); var signatureManifest = await rdcManager.GetSignatureManifestAsync( new DataInfo { Name = canonicalFilename, LastModified = fileAndPages.Metadata.Value<DateTime>(Constants.RavenLastModified).ToUniversalTime() }); signatureManifest.FileLength = fileLength ?? 0; Log.Debug("Signature manifest for a file '{0}' was downloaded. Signatures count was {1}", id, signatureManifest.Signatures.Count); return GetMessageWithObject(signatureManifest) .WithNoCache(); } }
public void Should_throw_FileNotFoundException_for_unknown_file() { transactionalStorage.Batch(accessor => { accessor.AddSignature("test", 1, stream => stream.Write(new byte[] { 3 }, 0, 1)); }); var tested = new StorageSignatureRepository(transactionalStorage, "test"); Assert.Throws(typeof(FileNotFoundException), () => tested.GetContentForReading("test.0.sig")); }
public void Should_read_from_storage() { transactionalStorage.Batch(accessor => { accessor.AddSignature("test", 1, stream => stream.Write(new byte[] { 3 }, 0, 1)); }); var tested = new StorageSignatureRepository(transactionalStorage, "test"); Assert.Equal(3, tested.GetContentForReading("test.1.sig").ReadByte()); }
public void Should_get_SignatureInfo() { transactionalStorage.Batch(accessor => { accessor.AddSignature("test", 1, stream => stream.Write(new byte[] { 3 }, 0, 1)); }); var tested = new StorageSignatureRepository(transactionalStorage, "test"); var result = tested.GetByName("test.1.sig"); Assert.Equal("test.1.sig", result.Name); Assert.Equal(1, result.Length); }
public HttpResponseMessage Signatures(string id) { var canonicalFilename = FileHeader.Canonize(id); Log.Debug("Got signatures of a file '{0}' request", id); using (var signatureRepository = new StorageSignatureRepository(Storage, canonicalFilename)) { var localRdcManager = new LocalRdcManager(signatureRepository, Storage, SigGenerator); var resultContent = localRdcManager.GetSignatureContentForReading(canonicalFilename); return StreamResult(canonicalFilename, resultContent); } }
public void Should_assign_signature_to_proper_file() { var tested = new StorageSignatureRepository(transactionalStorage, "test.bin"); using(var sigContent = tested.CreateContent("test.bin.0.sig")) { sigContent.WriteByte(3); } tested.Flush(new[] { SignatureInfo.Parse("test.bin.0.sig") } ); var result = tested.GetByName("test.bin.0.sig"); Assert.Equal("test.bin.0.sig", result.Name); Assert.Equal(1, result.Length); }
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_get_SignaturInfos_by_file_name() { var tested = new StorageSignatureRepository(transactionalStorage, "test"); transactionalStorage.Batch(accessor => { accessor.AddSignature("test", 0, stream => stream.Write(new byte[] { 3 }, 0, 1)); accessor.AddSignature("test", 1, stream => stream.Write(new byte[] { 3 }, 0, 1)); accessor.AddSignature("test", 2, stream => stream.Write(new byte[] { 3 }, 0, 1)); }); var signatureInfos = tested.GetByFileName().ToList(); Assert.Equal(3, signatureInfos.Count()); foreach (var item in signatureInfos) { Assert.Equal(1, item.Length); } }