public void Test_ConnectionManager()
{
for (int i = 0; i < 4; i++)
{
TcpListener listener = new TcpListener(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 60000));
listener.Start();
var listenerAcceptSocket = listener.BeginAcceptSocket(null, null);
TcpClient client = new TcpClient();
client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 60000));
var server = listener.EndAcceptSocket(listenerAcceptSocket);
listener.Stop();
var tcpClient = new BaseConnection(new SocketCap(client.Client), null, Test_Library_Net_Amoeba.MaxReceiveCount, _bufferManager);
var tcpServer = new BaseConnection(new SocketCap(server), null, Test_Library_Net_Amoeba.MaxReceiveCount, _bufferManager);
List<ConnectionManager> connectionManagers = new List<ConnectionManager>();
{
ConnectionManager serverConnectionManager;
ConnectionManager clientConnectionManager;
Node serverNode = null;
Node clientNode = null;
byte[] serverSessionId = null;
byte[] clientSessionId = null;
{
var id = new byte[32];
_random.NextBytes(id);
var uris = new string[] { "tcp:localhost:9000", "tcp:localhost:9001", "tcp:localhost:9002" };
serverNode = new Node(id, uris);
}
{
var id = new byte[32];
_random.NextBytes(id);
var uris = new string[] { "tcp:localhost:9000", "tcp:localhost:9001", "tcp:localhost:9002" };
clientNode = new Node(id, uris);
}
{
serverSessionId = new byte[32];
_random.NextBytes(serverSessionId);
}
{
clientSessionId = new byte[32];
_random.NextBytes(clientSessionId);
}
serverConnectionManager = new ConnectionManager(tcpServer, serverSessionId, serverNode, ConnectDirection.In, _bufferManager);
clientConnectionManager = new ConnectionManager(tcpClient, clientSessionId, clientNode, ConnectDirection.Out, _bufferManager);
var serverTask = Task.Run(() => serverConnectionManager.Connect());
var clientTask = Task.Run(() => clientConnectionManager.Connect());
Task.WaitAll(serverTask, clientTask);
Assert.IsTrue(CollectionUtils.Equals(serverConnectionManager.SesstionId, clientSessionId), "ConnectionManager SessionId #1");
Assert.IsTrue(CollectionUtils.Equals(clientConnectionManager.SesstionId, serverSessionId), "ConnectionManager SessionId #2");
Assert.AreEqual(serverConnectionManager.Node, clientNode, "ConnectionManager Node #1");
Assert.AreEqual(clientConnectionManager.Node, serverNode, "ConnectionManager Node #2");
connectionManagers.Add(serverConnectionManager);
connectionManagers.Add(clientConnectionManager);
}
connectionManagers.Randomize();
{
var queue = new WaitQueue<PullNodesEventArgs>();
var receiverConnection = connectionManagers[0];
var senderConnection = connectionManagers[1];
receiverConnection.PullNodesEvent += (object sender, PullNodesEventArgs e) =>
{
queue.Enqueue(e);
};
List<Node> nodes = new List<Node>();
for (int j = 0; j < 32; j++)
{
Node node = null;
{
var id = new byte[32];
_random.NextBytes(id);
var uris = new string[] { "net.tcp://localhost:9000", "net.tcp://localhost:9001", "net.tcp://localhost:9002" };
node = new Node(id, uris);
}
nodes.Add(node);
}
senderConnection.PushNodes(nodes);
var item = queue.Dequeue();
Assert.IsTrue(CollectionUtils.Equals(nodes, item.Nodes), "ConnectionManager #1");
}
connectionManagers.Randomize();
{
var queue = new WaitQueue<PullBlocksLinkEventArgs>();
var receiverConnection = connectionManagers[0];
var senderConnection = connectionManagers[1];
receiverConnection.PullBlocksLinkEvent += (object sender, PullBlocksLinkEventArgs e) =>
{
queue.Enqueue(e);
};
var keys = new List<Key>();
for (int j = 0; j < 32; j++)
{
Key key = null;
{
var id = new byte[32];
_random.NextBytes(id);
key = new Key(HashAlgorithm.Sha256, id);
}
keys.Add(key);
}
senderConnection.PushBlocksLink(keys);
var item = queue.Dequeue();
Assert.IsTrue(CollectionUtils.Equals(keys, item.Keys), "ConnectionManager #2");
}
connectionManagers.Randomize();
{
var queue = new WaitQueue<PullBlocksRequestEventArgs>();
var receiverConnection = connectionManagers[0];
var senderConnection = connectionManagers[1];
receiverConnection.PullBlocksRequestEvent += (object sender, PullBlocksRequestEventArgs e) =>
{
queue.Enqueue(e);
};
var keys = new List<Key>();
for (int j = 0; j < 32; j++)
{
Key key = null;
{
var id = new byte[32];
_random.NextBytes(id);
key = new Key(HashAlgorithm.Sha256, id);
}
keys.Add(key);
}
senderConnection.PushBlocksRequest(keys);
var item = queue.Dequeue();
Assert.IsTrue(CollectionUtils.Equals(keys, item.Keys), "ConnectionManager #3");
}
connectionManagers.Randomize();
{
var queue = new WaitQueue<PullBlockEventArgs>();
var receiverConnection = connectionManagers[0];
var senderConnection = connectionManagers[1];
receiverConnection.PullBlockEvent += (object sender, PullBlockEventArgs e) =>
{
queue.Enqueue(e);
};
var buffer = _bufferManager.TakeBuffer(1024 * 1024 * 8);
var key = new Key(HashAlgorithm.Sha256, Sha256.ComputeHash(buffer));
senderConnection.PushBlock(key, new ArraySegment<byte>(buffer, 0, 1024 * 1024 * 4));
var item = queue.Dequeue();
Assert.AreEqual(key, item.Key, "ConnectionManager #4.1");
Assert.IsTrue(CollectionUtils.Equals(buffer, 0, item.Value.Array, item.Value.Offset, 1024 * 1024 * 4), "ConnectionManager #4.2");
_bufferManager.ReturnBuffer(buffer);
_bufferManager.ReturnBuffer(item.Value.Array);
}
connectionManagers.Randomize();
{
var queue = new WaitQueue<PullBroadcastMetadatasRequestEventArgs>();
var receiverConnection = connectionManagers[0];
var senderConnection = connectionManagers[1];
receiverConnection.PullBroadcastMetadatasRequestEvent += (object sender, PullBroadcastMetadatasRequestEventArgs e) =>
{
queue.Enqueue(e);
};
var digitalSignature = new DigitalSignature("123", DigitalSignatureAlgorithm.Rsa2048_Sha256);
var signatures = new SignatureCollection();
for (int j = 0; j < 32; j++)
{
signatures.Add(digitalSignature.ToString());
}
senderConnection.PushBroadcastMetadatasRequest(signatures);
var item = queue.Dequeue();
Assert.IsTrue(CollectionUtils.Equals(signatures, item.Signatures), "ConnectionManager #5.1");
}
connectionManagers.Randomize();
{
var queue = new WaitQueue<PullBroadcastMetadatasEventArgs>();
var receiverConnection = connectionManagers[0];
var senderConnection = connectionManagers[1];
receiverConnection.PullBroadcastMetadatasEvent += (object sender, PullBroadcastMetadatasEventArgs e) =>
{
queue.Enqueue(e);
};
var digitalSignature = new DigitalSignature("123", DigitalSignatureAlgorithm.Rsa2048_Sha256);
var metadatas1 = new List<BroadcastMetadata>();
for (int j = 0; j < 4; j++)
{
var key = new Key(HashAlgorithm.Sha256, new byte[32]);
var metadata = new Metadata(1, key, CompressionAlgorithm.Xz, CryptoAlgorithm.Aes256, new byte[32 + 32]);
var broadcastMetadata = new BroadcastMetadata("Type", DateTime.UtcNow, metadata, digitalSignature);
metadatas1.Add(broadcastMetadata);
}
senderConnection.PushBroadcastMetadatas(metadatas1);
var item = queue.Dequeue();
Assert.IsTrue(CollectionUtils.Equals(metadatas1, item.BroadcastMetadatas), "ConnectionManager #6.1");
}
connectionManagers.Randomize();
{
var queue = new WaitQueue<PullUnicastMetadatasRequestEventArgs>();
var receiverConnection = connectionManagers[0];
var senderConnection = connectionManagers[1];
receiverConnection.PullUnicastMetadatasRequestEvent += (object sender, PullUnicastMetadatasRequestEventArgs e) =>
{
queue.Enqueue(e);
};
var digitalSignature = new DigitalSignature("123", DigitalSignatureAlgorithm.Rsa2048_Sha256);
var signatures = new SignatureCollection();
for (int j = 0; j < 32; j++)
{
signatures.Add(digitalSignature.ToString());
}
senderConnection.PushUnicastMetadatasRequest(signatures);
var item = queue.Dequeue();
Assert.IsTrue(CollectionUtils.Equals(signatures, item.Signatures), "ConnectionManager #7.1");
}
connectionManagers.Randomize();
{
var queue = new WaitQueue<PullUnicastMetadatasEventArgs>();
var receiverConnection = connectionManagers[0];
var senderConnection = connectionManagers[1];
receiverConnection.PullUnicastMetadatasEvent += (object sender, PullUnicastMetadatasEventArgs e) =>
{
queue.Enqueue(e);
};
var digitalSignature = new DigitalSignature("123", DigitalSignatureAlgorithm.Rsa2048_Sha256);
var metadatas1 = new List<UnicastMetadata>();
for (int j = 0; j < 4; j++)
{
var key = new Key(HashAlgorithm.Sha256, new byte[32]);
var metadata = new Metadata(1, key, CompressionAlgorithm.Xz, CryptoAlgorithm.Aes256, new byte[32 + 32]);
var unicastMetadata = new UnicastMetadata("Type", digitalSignature.ToString(), DateTime.UtcNow, metadata, digitalSignature);
metadatas1.Add(unicastMetadata);
}
senderConnection.PushUnicastMetadatas(metadatas1);
var item = queue.Dequeue();
Assert.IsTrue(CollectionUtils.Equals(metadatas1, item.UnicastMetadatas), "ConnectionManager #8.1");
}
connectionManagers.Randomize();
{
var queue = new WaitQueue<PullMulticastMetadatasRequestEventArgs>();
var receiverConnection = connectionManagers[0];
var senderConnection = connectionManagers[1];
receiverConnection.PullMulticastMetadatasRequestEvent += (object sender, PullMulticastMetadatasRequestEventArgs e) =>
{
queue.Enqueue(e);
};
var tags = new TagCollection();
for (int j = 0; j < 32; j++)
{
var id = new byte[32];
_random.NextBytes(id);
tags.Add(new Tag(RandomString.GetValue(256), id));
}
senderConnection.PushMulticastMetadatasRequest(tags);
var item = queue.Dequeue();
Assert.IsTrue(CollectionUtils.Equals(tags, item.Tags), "ConnectionManager #9.1");
}
connectionManagers.Randomize();
{
var queue = new WaitQueue<PullMulticastMetadatasEventArgs>();
var receiverConnection = connectionManagers[0];
var senderConnection = connectionManagers[1];
receiverConnection.PullMulticastMetadatasEvent += (object sender, PullMulticastMetadatasEventArgs e) =>
{
queue.Enqueue(e);
};
var digitalSignature = new DigitalSignature("123", DigitalSignatureAlgorithm.Rsa2048_Sha256);
var metadatas1 = new List<MulticastMetadata>();
for (int j = 0; j < 4; j++)
{
var key = new Key(HashAlgorithm.Sha256, new byte[32]);
var metadata = new Metadata(1, key, CompressionAlgorithm.Xz, CryptoAlgorithm.Aes256, new byte[32 + 32]);
var tag = new Tag("oooo", new byte[32]);
var miner = new Miner(CashAlgorithm.Version1, -1, TimeSpan.Zero);
var multicastMetadata = new MulticastMetadata("Type", tag, DateTime.UtcNow, metadata, miner, digitalSignature);
metadatas1.Add(multicastMetadata);
}
senderConnection.PushMulticastMetadatas(metadatas1);
var item = queue.Dequeue();
Assert.IsTrue(CollectionUtils.Equals(metadatas1, item.MulticastMetadatas), "ConnectionManager #10.1");
}
foreach (var connectionManager in connectionManagers)
{
connectionManager.Dispose();
}
client.Close();
server.Close();
}
}
public void Upload(MulticastMetadata metadata)
{
if (_disposed) throw new ObjectDisposedException(this.GetType().FullName);
lock (_thisLock)
{
_settings.MetadataManager.SetMetadata(metadata);
}
}
private void MetadataUploadAndDownload(IEnumerable <CoreManager> coreManagers)
{
_callback.Invoke("----- CoreManager Metadata Send and Receive Test -----");
_callback.Invoke("");
var coreManagerList = coreManagers.ToList();
Parallel.ForEach(coreManagerList, coreManager =>
{
coreManager.Resize((long)1024 * 1024 * 256).Wait();
});
var broadcastMetadataList = new List <BroadcastMetadata>();
var unicastMetadataList = new List <UnicastMetadata>();
var multicastMetadataList = new List <MulticastMetadata>();
for (int i = 0; i < 8; i++)
{
BroadcastMetadata broadcastMetadata;
{
var digitalSignature = new DigitalSignature("Test", DigitalSignatureAlgorithm.EcDsaP521_Sha256_v3);
var metadata = new Metadata(0, new Hash(HashAlgorithm.Sha256, _random.GetBytes(32)));
broadcastMetadata = new BroadcastMetadata("Test", DateTime.UtcNow, metadata, digitalSignature);
}
coreManagerList[_random.Next(1, coreManagerList.Count)].UploadMetadata(broadcastMetadata);
broadcastMetadataList.Add(broadcastMetadata);
}
for (int i = 0; i < 8; i++)
{
UnicastMetadata unicastMetadata;
{
var targetSignature = new DigitalSignature("Test", DigitalSignatureAlgorithm.EcDsaP521_Sha256_v3).GetSignature();
var digitalSignature = new DigitalSignature("Test", DigitalSignatureAlgorithm.EcDsaP521_Sha256_v3);
var metadata = new Metadata(0, new Hash(HashAlgorithm.Sha256, _random.GetBytes(32)));
unicastMetadata = new UnicastMetadata("Test", targetSignature, DateTime.UtcNow, metadata, digitalSignature);
}
coreManagerList[_random.Next(1, coreManagerList.Count)].UploadMetadata(unicastMetadata);
unicastMetadataList.Add(unicastMetadata);
}
for (int i = 0; i < 8; i++)
{
MulticastMetadata multicastMetadata;
using (var tokenSource = new CancellationTokenSource())
{
var tag = new Tag("Test", _random.GetBytes(32));
var digitalSignature = new DigitalSignature("Test", DigitalSignatureAlgorithm.EcDsaP521_Sha256_v3);
var metadata = new Metadata(0, new Hash(HashAlgorithm.Sha256, _random.GetBytes(32)));
multicastMetadata = new MulticastMetadata("Test", tag, DateTime.UtcNow, metadata, digitalSignature, null, tokenSource.Token);
}
coreManagerList[_random.Next(1, coreManagerList.Count)].UploadMetadata(multicastMetadata);
multicastMetadataList.Add(multicastMetadata);
}
var sw = Stopwatch.StartNew();
{
var targetCoreManager = coreManagerList[0];
for (; ;)
{
Thread.Sleep(1000);
foreach (var broadcastMetadata in broadcastMetadataList.ToArray())
{
if (targetCoreManager.GetBroadcastMetadata(broadcastMetadata.Certificate.GetSignature(), "Test") == broadcastMetadata)
{
broadcastMetadataList.Remove(broadcastMetadata);
_callback.Invoke($"{sw.Elapsed.ToString("hh\\:mm\\:ss")}: Success BroadcastMetadata");
}
}
foreach (var unicastMetadata in unicastMetadataList.ToArray())
{
if (targetCoreManager.GetUnicastMetadatas(unicastMetadata.Signature, "Test").Contains(unicastMetadata))
{
unicastMetadataList.Remove(unicastMetadata);
_callback.Invoke($"{sw.Elapsed.ToString("hh\\:mm\\:ss")}: Success UnicastMetadata");
}
}
foreach (var multicastMetadata in multicastMetadataList.ToArray())
{
if (targetCoreManager.GetMulticastMetadatas(multicastMetadata.Tag, "Test").Contains(multicastMetadata))
{
multicastMetadataList.Remove(multicastMetadata);
_callback.Invoke($"{sw.Elapsed.ToString("hh\\:mm\\:ss")}: Success MulticastMetadata");
}
}
if (broadcastMetadataList.Count == 0 && unicastMetadataList.Count == 0 && multicastMetadataList.Count == 0)
{
break;
}
}
}
_callback.Invoke("----- End -----");
}
public bool SetMetadata(MulticastMetadata metadata)
{
lock (_thisLock)
{
var now = DateTime.UtcNow;
if (metadata == null
|| metadata.Type == null
|| metadata.Tag == null
|| metadata.Tag.Id == null || metadata.Tag.Id.Length == 0
|| string.IsNullOrWhiteSpace(metadata.Tag.Name)
|| (metadata.CreationTime - now).TotalMinutes > 30
|| metadata.Certificate == null) return false;
Dictionary<Tag, Dictionary<string, HashSet<MulticastMetadata>>> dic1;
if (!_multicastMetadatas.TryGetValue(metadata.Type, out dic1))
{
dic1 = new Dictionary<Tag, Dictionary<string, HashSet<MulticastMetadata>>>();
_multicastMetadatas[metadata.Type] = dic1;
}
Dictionary<string, HashSet<MulticastMetadata>> dic2;
if (!dic1.TryGetValue(metadata.Tag, out dic2))
{
dic2 = new Dictionary<string, HashSet<MulticastMetadata>>();
dic1[metadata.Tag] = dic2;
}
var signature = metadata.Certificate.ToString();
HashSet<MulticastMetadata> hashset;
if (!dic2.TryGetValue(signature, out hashset))
{
hashset = new HashSet<MulticastMetadata>();
dic2[signature] = hashset;
}
if (!hashset.Contains(metadata))
{
if (!metadata.VerifyCertificate()) throw new CertificateException();
hashset.Add(metadata);
}
return true;
}
}
