public async void SameHash()
{
var pkg = new R2Package("non-registered.pkg");
var actual = await _sut.IsUploadable(pkg, new CancellationToken());
actual.Should().BeFalse();
}
public async Task <bool> TargetIsOutdated(CancellationToken cancelTkn)
{
if (!ValidateTargetFile())
{
return(false);
}
_remotePkg = null;
var localPkg = _file.ToR2Package(TargetPath);
var fName = localPkg.Filename;
SetStatus($"Getting packages named “{fName}” ...");
var list = await _remote.ListByFilename(fName, cancelTkn);
if (list.Count == 0)
{
throw Fault
.NoItems($"Server packages named “{fName}”");
}
if (list.Count > 1)
{
throw Fault
.NonSolo($"Server packages named “{fName}”", list.Count);
}
_remotePkg = list.Single();
return(_remotePkg.Hash != localPkg.Hash);
}
public async void NotRegistered()
{
var moq = MockMgrReturning();
var sut = new D8PreUploadChecker1(moq.Object);
var pkg = new R2Package("non-registered.pkg");
(await sut.IsUploadable(pkg, new CancellationToken())).Should().BeFalse();
}
public async void Registered()
{
var pkg = new R2Package("Test_Package_1.pkg");
pkg.FileFound = true;
pkg.Hash = DateTime.Now.Ticks.ToString();
var actual = await _sut.IsUploadable(pkg, new CancellationToken());
actual.Should().BeTrue(_sut.ReasonWhyNot);
}
public async Task <string> IsolateFile(R2Package localPkg)
{
var srcPath = Chain(localPkg.LocalDir, localPkg.Filename);
var destPath = Path.GetTempFileName();
var task = Task.Run(()
=> File.Copy(srcPath, destPath, true));
await task;
return(destPath);
}
private async Task <string> TryDownloadAndGetHash(R2Package localPkg, CancellationToken cancelTkn)
{
SetStatus("Verifying uploaded parts ...");
var downloadedPkgPath = await _downloadr
.DownloadAndUnpack(localPkg, _fileIO.TempDir, cancelTkn);
var newHash = _fileIO.GetSHA1(downloadedPkgPath);
await _fileIO.Delete(downloadedPkgPath);
return(newHash);
}
public async Task <Reply> DeleteByPkgHash(R2Package package, CancellationToken cancelTkn)
{
var list = await ListByPkgHash(package, cancelTkn);
foreach (var item in list)
{
var reply = await _client.DeleteNode(item.nid, cancelTkn);
if (reply.Failed)
{
return(reply);
}
}
return(Reply.Success());
}
public async Task <string> DownloadAndUnpack(R2Package remotePackage, string targetDir, CancellationToken cancelTkn)
{
var list = await _parts.ListByPkgHash(remotePackage, cancelTkn);
if (list.Count == 0)
{
throw new ArgumentException
($"No parts found for package hash “{remotePackage.Hash}”.");
}
var orderedList = list.OrderBy(x => x.PartNumber).ToList();
var paths = await DownloadPartsToTemp(orderedList, cancelTkn);
return(await _archivr.MergeAndDecompress(paths, targetDir));
}
private async Task UpdatePackageNode(string revisionLog)
{
var node = new R2Package
{
nid = NODE_ID,
Filename = NODE_TITLE,
Hash = F.ke.Text
};
//var list = await _pkgMgr.ListByFilename(NODE_TITLE, new CancellationToken());
//list.Should().HaveCount(1);
//var node = list[0];
//node.Hash = F.ke.Text;
var reply = await _pkgMgr.UpdateRemoteNode(node, revisionLog, new CancellationToken());
reply.IsSuccessful.Should().BeTrue(reply.ErrorsText);
}
//public async Task<NodeReply> Upload(R2Package localPkg)
//{
// try
// {
// Alerter.Show(await ExecuteUpload(localPkg), "Upload");
// }
// catch (Exception ex)
// {
// Alerter.ShowError("Upload Error", ex.Info(false, true));
// }
//}
public async Task <NodeReply> StartUpload(R2Package localPkg, string revisionLog)
{
if (localPkg.nid == 0)
{
throw Fault
.BadData(localPkg, "nid should NOT be zero");
}
_cancelr = new CancellationTokenSource();
try
{
return(await ExecuteUpload(localPkg, revisionLog, _cancelr.Token));
}
catch (OperationCanceledException ex)
{
return(NodeReply.Fail(ex));
}
}
public static R2Package From(string filePath)
{
if (filePath.IsBlank())
{
return(null);
}
var inf = new FileInfo(filePath);
var pkg = new R2Package(inf.Name);
pkg.LocalDir = inf.DirectoryName;
pkg.FileFound = inf.Exists;
if (pkg.FileFound)
{
pkg.Hash = inf.SHA1ForFile();
}
return(pkg);
}
public async Task <bool> IsUploadable(R2Package localPkg, CancellationToken cancelTkn)
{
if (localPkg == null)
{
ReasonWhyNot = $"“{nameof(localPkg)}” argument is NULL.";
return(false);
}
var nme = localPkg.Filename;
if (!localPkg.FileFound)
{
ReasonWhyNot = $"“{nme}” not found in {localPkg.LocalDir}.";
return(false);
}
var list = await _pkgs.ListByFilename(nme, cancelTkn);
if (list == null)
{
ReasonWhyNot = "List from server is NULL.";
return(false);
}
if (list.Count < 1)
{
ReasonWhyNot = $"Package is not registered: “{nme}”.";
return(false);
}
if (list.Count > 1)
{
ReasonWhyNot = $"Package is registered {list.Count} times : “{nme}”.";
return(false);
}
LastPackage = list[0];
if (LastPackage.Hash == localPkg.Hash)
{
ReasonWhyNot = "Local hash matches remote hash.";
return(false);
}
return(true);
}
public async Task SendParts(IEnumerable <string> partPaths, R2Package localPkg, CancellationToken cancelTkn)
{
for (int i = 0; i < partPaths.Count(); i++)
{
var path = partPaths.ElementAt(i);
var partNode = new R2PackagePart
{
PackageFilename = localPkg.Filename,
PackageHash = localPkg.Hash,
PartHash = path.SHA1ForFile(),
PartNumber = i + 1,
TotalParts = partPaths.Count(),
Base64Content = _fileIO.ReadBase64(path)
};
SetStatus($"Sending {partNode.Description} ...");
var reply = await _partMgr.AddNode(partNode, cancelTkn);
if (reply.Failed)
{
throw new Exception(reply.ErrorsText);
}
}
}
private async Task <NodeReply> ExecuteUpload(R2Package localPkg, string revisionLog, CancellationToken cancelTkn)
{
SetStatus("Isolating local package file...");
var pkgPath = await _fileIO.IsolateFile(localPkg);
SetStatus("Compressing and splitting into parts...");
var partPaths = await _archivr.CompressAndSplit(pkgPath, MaxPartSizeMB);
await _fileIO.Delete(pkgPath);
await _sendr.SendParts(partPaths, localPkg, cancelTkn);
await _fileIO.Delete(partPaths);
var newHash = await TryDownloadAndGetHash(localPkg, cancelTkn);
if (newHash != localPkg.Hash)
{
throw Fault.HashMismatch("Original Package File", "Downloaded Package File");
}
SetStatus("Updating package node ...");
return(await _pkgMgr.UpdateRemoteNode(localPkg, revisionLog, cancelTkn));
}
public Task <List <R2PackagePart> > ListByPkgHash(R2Package package, CancellationToken cancelTkn) => ListByPkgHash(package.Filename, package.Hash, cancelTkn);
public Task <NodeReply> UpdateRemoteNode(R2Package updatedPkg, string revisionLog, CancellationToken cancelTkn) => _client.PatchNode(updatedPkg, cancelTkn, revisionLog);
public async Task <List <R2PackagePart> > ListByPkgHash(R2Package package, CancellationToken cancelTkn)
{
await Task.Delay(1);
return(new List <R2PackagePart>());
}
internal void EnableUpload(R2Package pkg) => Package = pkg;
private void SetFileToR2PackageToReturn(R2Package package) => _fileIO.Setup(x => x.ToR2Package(Any.Text)).Returns(package);
