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 override async Task <SynchronizationReport> PerformAsync(IAsyncFilesSynchronizationCommands destination)
{
AssertLocalFileExistsAndIsNotConflicted(FileMetadata);
var destinationMetadata = await destination.Commands.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)
{
var report = await HandleConflict(destination, 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(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.Any())
{
var destinationSignatureManifest = await destinationRdcManager.SynchronizeSignaturesAsync(FileDataInfo, Cts.Token);
if (destinationSignatureManifest.Signatures.Any())
{
return(await SynchronizeTo(destination, localSignatureRepository, remoteSignatureCache, localSignatureManifest, destinationSignatureManifest));
}
}
return(await UploadToAsync(destination));
}
}
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 HttpResponseMessage Signatures(string id)
{
var filename = Uri.UnescapeDataString(id);
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 async Task <HttpResponseMessage> Manifest(string id)
{
var filename = Uri.UnescapeDataString(id);
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.Value <string>("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(this.GetMessageWithObject(signatureManifest, HttpStatusCode.OK)
.WithNoCache());
}
}
