200 lines
6.7 KiB
C#
200 lines
6.7 KiB
C#
//using DistTestCore.Codex;
|
|
//using Logging;
|
|
//using NUnit.Framework;
|
|
|
|
//namespace DistTestCore.Helpers
|
|
//{
|
|
// public interface IFullConnectivityImplementation
|
|
// {
|
|
// string Description();
|
|
// string ValidateEntry(FullConnectivityHelper.Entry entry, FullConnectivityHelper.Entry[] allEntries);
|
|
// FullConnectivityHelper.PeerConnectionState Check(FullConnectivityHelper.Entry from, FullConnectivityHelper.Entry to);
|
|
// }
|
|
|
|
// public class FullConnectivityHelper
|
|
// {
|
|
// private static string Nl = Environment.NewLine;
|
|
// private readonly BaseLog log;
|
|
// private readonly IFullConnectivityImplementation implementation;
|
|
|
|
// public FullConnectivityHelper(BaseLog log, IFullConnectivityImplementation implementation)
|
|
// {
|
|
// this.log = log;
|
|
// this.implementation = implementation;
|
|
// }
|
|
|
|
// public void AssertFullyConnected(IEnumerable<CodexAccess> nodes)
|
|
// {
|
|
// AssertFullyConnected(nodes.ToArray());
|
|
// }
|
|
|
|
// private void AssertFullyConnected(CodexAccess[] nodes)
|
|
// {
|
|
// Log($"Asserting '{implementation.Description()}' for nodes: '{string.Join(",", nodes.Select(n => n.GetName()))}'...");
|
|
// var entries = CreateEntries(nodes);
|
|
// var pairs = CreatePairs(entries);
|
|
|
|
// // Each pair gets two chances.
|
|
// CheckAndRemoveSuccessful(pairs);
|
|
// CheckAndRemoveSuccessful(pairs);
|
|
|
|
// if (pairs.Any())
|
|
// {
|
|
// var pairDetails = string.Join(Nl, pairs.SelectMany(p => p.GetResultMessages()));
|
|
|
|
// Log($"Connections failed:{Nl}{pairDetails}");
|
|
|
|
// Assert.Fail(string.Join(Nl, pairs.SelectMany(p => p.GetResultMessages())));
|
|
// }
|
|
// else
|
|
// {
|
|
// Log($"'{implementation.Description()}' = Success! for nodes: {string.Join(",", nodes.Select(n => n.GetName()))}");
|
|
// }
|
|
// }
|
|
|
|
// private void CheckAndRemoveSuccessful(List<Pair> pairs)
|
|
// {
|
|
// var results = new List<string>();
|
|
// foreach (var pair in pairs.ToArray())
|
|
// {
|
|
// pair.Check();
|
|
// if (pair.Success)
|
|
// {
|
|
// results.AddRange(pair.GetResultMessages());
|
|
// pairs.Remove(pair);
|
|
// }
|
|
// }
|
|
// Log($"Connections successful:{Nl}{string.Join(Nl, results)}");
|
|
// }
|
|
|
|
// private Entry[] CreateEntries(CodexAccess[] nodes)
|
|
// {
|
|
// var entries = nodes.Select(n => new Entry(n)).ToArray();
|
|
|
|
// var errors = entries
|
|
// .Select(e => implementation.ValidateEntry(e, entries))
|
|
// .Where(s => !string.IsNullOrEmpty(s))
|
|
// .ToArray();
|
|
|
|
// if (errors.Any())
|
|
// {
|
|
// Assert.Fail("Some node entries failed to validate: " + string.Join(Nl, errors));
|
|
// }
|
|
|
|
// return entries;
|
|
// }
|
|
|
|
// private List<Pair> CreatePairs(Entry[] entries)
|
|
// {
|
|
// return CreatePairsIterator(entries).ToList();
|
|
// }
|
|
|
|
// private IEnumerable<Pair> CreatePairsIterator(Entry[] entries)
|
|
// {
|
|
// for (var x = 0; x < entries.Length; x++)
|
|
// {
|
|
// for (var y = x + 1; y < entries.Length; y++)
|
|
// {
|
|
// yield return new Pair(implementation, entries[x], entries[y]);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// private void Log(string msg)
|
|
// {
|
|
// log.Log(msg);
|
|
// }
|
|
|
|
// public class Entry
|
|
// {
|
|
// public Entry(CodexAccess node)
|
|
// {
|
|
// Node = node;
|
|
// Response = node.GetDebugInfo();
|
|
// }
|
|
|
|
// public CodexAccess Node { get; }
|
|
// public CodexDebugResponse Response { get; }
|
|
|
|
// public override string ToString()
|
|
// {
|
|
// if (Response == null || string.IsNullOrEmpty(Response.id)) return "UNKNOWN";
|
|
// return Response.id;
|
|
// }
|
|
// }
|
|
|
|
// public enum PeerConnectionState
|
|
// {
|
|
// Unknown,
|
|
// Connection,
|
|
// NoConnection,
|
|
// }
|
|
|
|
// public class Pair
|
|
// {
|
|
// private TimeSpan aToBTime = TimeSpan.FromSeconds(0);
|
|
// private TimeSpan bToATime = TimeSpan.FromSeconds(0);
|
|
// private readonly IFullConnectivityImplementation implementation;
|
|
|
|
// public Pair(IFullConnectivityImplementation implementation, Entry a, Entry b)
|
|
// {
|
|
// this.implementation = implementation;
|
|
// A = a;
|
|
// B = b;
|
|
// }
|
|
|
|
// public Entry A { get; }
|
|
// public Entry B { get; }
|
|
// public PeerConnectionState AKnowsB { get; private set; }
|
|
// public PeerConnectionState BKnowsA { get; private set; }
|
|
// public bool Success { get { return AKnowsB == PeerConnectionState.Connection && BKnowsA == PeerConnectionState.Connection; } }
|
|
// public bool Inconclusive { get { return AKnowsB == PeerConnectionState.Unknown || BKnowsA == PeerConnectionState.Unknown; } }
|
|
|
|
// public void Check()
|
|
// {
|
|
// aToBTime = Measure(() => AKnowsB = Check(A, B));
|
|
// bToATime = Measure(() => BKnowsA = Check(B, A));
|
|
// }
|
|
|
|
// public override string ToString()
|
|
// {
|
|
// return $"[{string.Join(",", GetResultMessages())}]";
|
|
// }
|
|
|
|
// public string[] GetResultMessages()
|
|
// {
|
|
// var aName = A.ToString();
|
|
// var bName = B.ToString();
|
|
|
|
// return new[]
|
|
// {
|
|
// $"[{aName} --> {bName}] = {AKnowsB} ({aToBTime.TotalSeconds} seconds)",
|
|
// $"[{aName} <-- {bName}] = {BKnowsA} ({bToATime.TotalSeconds} seconds)"
|
|
// };
|
|
// }
|
|
|
|
// private static TimeSpan Measure(Action action)
|
|
// {
|
|
// var start = DateTime.UtcNow;
|
|
// action();
|
|
// return DateTime.UtcNow - start;
|
|
// }
|
|
|
|
// private PeerConnectionState Check(Entry from, Entry to)
|
|
// {
|
|
// Thread.Sleep(10);
|
|
|
|
// try
|
|
// {
|
|
// return implementation.Check(from, to);
|
|
// }
|
|
// catch
|
|
// {
|
|
// // Didn't get a conclusive answer. Try again later.
|
|
// return PeerConnectionState.Unknown;
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
//}
|