cs-codex-dist-tests/DistTestCore/Helpers/PeerDownloadTestHelpers.cs

using DistTestCore.Codex;
using FileUtils;
using Logging;
using Utils;
using static DistTestCore.Helpers.FullConnectivityHelper;

namespace DistTestCore.Helpers
{
    public class PeerDownloadTestHelpers : IFullConnectivityImplementation
    {
        private readonly FullConnectivityHelper helper;
        private readonly BaseLog log;
        private readonly FileManager fileManager;
        private ByteSize testFileSize;

        public PeerDownloadTestHelpers(BaseLog log, FileManager fileManager)
        {
            helper = new FullConnectivityHelper(log, this);
            testFileSize = 1.MB();
            this.log = log;
            this.fileManager = fileManager;
        }

        public void AssertFullDownloadInterconnectivity(IEnumerable<IOnlineCodexNode> nodes, ByteSize testFileSize)
        {
            AssertFullDownloadInterconnectivity(nodes.Select(n => ((OnlineCodexNode)n).CodexAccess), testFileSize);
        }

        public void AssertFullDownloadInterconnectivity(IEnumerable<CodexAccess> nodes, ByteSize testFileSize)
        {
            this.testFileSize = testFileSize;
            helper.AssertFullyConnected(nodes);
        }

        public string Description()
        {
            return "Download Connectivity";
        }

        public string ValidateEntry(Entry entry, Entry[] allEntries)
        {
            return string.Empty;
        }

        public PeerConnectionState Check(Entry from, Entry to)
        {
            return fileManager.ScopedFiles(() => CheckConnectivity(from, to));
        }

        private PeerConnectionState CheckConnectivity(Entry from, Entry to)
        { 
            var expectedFile = GenerateTestFile(from.Node, to.Node);

            using var uploadStream = File.OpenRead(expectedFile.Filename);
            var contentId = Stopwatch.Measure(log, "Upload", () => from.Node.UploadFile(uploadStream));

            try
            {
                var downloadedFile = Stopwatch.Measure(log, "Download", () => DownloadFile(to.Node, contentId, expectedFile.Label + "_downloaded"));
                expectedFile.AssertIsEqual(downloadedFile);
                return PeerConnectionState.Connection;
            }
            catch
            {
                // Should an exception occur during the download or file-content assertion,
                // We consider that as no-connection for the purpose of this test.
                return PeerConnectionState.NoConnection;
            }
            // Should an exception occur during upload, then this try is inconclusive and we try again next loop.
        }

        private TestFile DownloadFile(CodexAccess node, string contentId, string label)
        {
            var downloadedFile = fileManager.CreateEmptyTestFile(label);
            using var downloadStream = File.OpenWrite(downloadedFile.Filename);
            using var stream = node.DownloadFile(contentId);
            stream.CopyTo(downloadStream);
            return downloadedFile;
        }

        private TestFile GenerateTestFile(CodexAccess uploader, CodexAccess downloader)
        {
            var up = uploader.GetName().Replace("<", "").Replace(">", "");
            var down = downloader.GetName().Replace("<", "").Replace(">", "");
            var label = $"~from:{up}-to:{down}~";
            return fileManager.GenerateTestFile(testFileSize, label);
        }
    }
}