public async Task<HttpResponseMessage> Manifest(string filename)
{
filename = Uri.UnescapeDataString(filename);
FileAndPages fileAndPages = null;
try
{
Storage.Batch(accessor => fileAndPages = accessor.GetFile(filename, 0, 0));
}
catch (FileNotFoundException)
{
Log.Debug("Signature manifest for a file '{0}' was not found", filename);
return Request.CreateResponse(HttpStatusCode.NotFound);
}
long? fileLength = fileAndPages.TotalSize;
using (var signatureRepository = new StorageSignatureRepository(Storage, filename))
{
var rdcManager = new LocalRdcManager(signatureRepository, Storage, SigGenerator);
var signatureManifest =
await rdcManager.GetSignatureManifestAsync(new DataInfo
{
Name = filename,
CreatedAt =
Convert.ToDateTime(fileAndPages.Metadata["Last-Modified"])
.ToUniversalTime()
});
signatureManifest.FileLength = fileLength ?? 0;
Log.Debug("Signature manifest for a file '{0}' was downloaded. Signatures count was {1}", filename,
signatureManifest.Signatures.Count);
return Request.CreateResponse(HttpStatusCode.OK, signatureManifest);
}
}
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 override async Task<SynchronizationReport> PerformAsync(string destination)
{
AssertLocalFileExistsAndIsNotConflicted(FileMetadata);
var destinationRavenFileSystemClient = new RavenFileSystemClient(destination);
var destinationMetadata = await destinationRavenFileSystemClient.GetMetadataForAsync(FileName);
if (destinationMetadata == null)
{
// if file doesn't exist on destination server - upload it there
return await UploadToAsync(destination);
}
var destinationServerRdcStats = await destinationRavenFileSystemClient.Synchronization.GetRdcStatsAsync();
if (!IsRemoteRdcCompatible(destinationServerRdcStats))
throw new SynchronizationException("Incompatible RDC version detected on destination server");
var conflict = CheckConflictWithDestination(FileMetadata, destinationMetadata, ServerInfo.Url);
if (conflict != null)
return await ApplyConflictOnDestinationAsync(conflict, destination, ServerInfo.Url, 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(destinationRavenFileSystemClient, 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 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 filename)
{
filename = Uri.UnescapeDataString(filename);
Log.Debug("Got signatures of a file '{0}' request", filename);
using (var signatureRepository = new StorageSignatureRepository(Storage, filename))
{
var localRdcManager = new LocalRdcManager(signatureRepository, Storage, SigGenerator);
var resultContent = localRdcManager.GetSignatureContentForReading(filename);
return StreamResult(filename, 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 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);
}
}