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();
}
}
private void EncodeThread()
{
for (;;)
{
Thread.Sleep(1000 * 1);
if (this.State == ManagerState.Stop) return;
BackgroundUploadItem item = null;
try
{
lock (_thisLock)
{
if (_settings.UploadItems.Count > 0)
{
item = _settings.UploadItems
.Where(n => n.State == BackgroundUploadState.Encoding)
.FirstOrDefault();
}
}
}
catch (Exception)
{
return;
}
if (item == null) continue;
try
{
if (item.Groups.Count == 0 && item.Keys.Count == 0)
{
Stream stream = null;
try
{
if (item.Scheme == "Broadcast")
{
if (item.Type == "Link")
{
var value = item.Link;
if (value == null) throw new FormatException();
stream = ContentConverter.ToStream(value);
}
else if (item.Type == "Profile")
{
var value = item.Profile;
if (value == null) throw new FormatException();
stream = ContentConverter.ToStream(value);
}
else if (item.Type == "Store")
{
var value = item.Store;
if (value == null) throw new FormatException();
stream = ContentConverter.ToStream(value);
}
}
else if (item.Scheme == "Unicast")
{
if (item.Type == "Message")
{
var value = item.Message;
if (value == null) throw new FormatException();
stream = ContentConverter.ToCryptoStream(value, item.ExchangePublicKey);
}
}
else if (item.Scheme == "Multicast")
{
if (item.Type == "Message")
{
var value = item.Message;
if (value == null) throw new FormatException();
stream = ContentConverter.ToStream(value);
}
}
else
{
throw new FormatException();
}
if (stream.Length == 0)
{
lock (_thisLock)
{
if (item.Scheme == "Broadcast")
{
_connectionsManager.Upload(new BroadcastMetadata(item.Type, item.CreationTime, null, item.DigitalSignature));
}
else if (item.Scheme == "Unicast")
{
_connectionsManager.Upload(new UnicastMetadata(item.Type, item.Signature, item.CreationTime, null, item.DigitalSignature));
}
else if (item.Scheme == "Multicast")
{
_connectionsManager.Upload(new MulticastMetadata(item.Type, item.Tag, item.CreationTime, null, null, item.DigitalSignature));
}
item.State = BackgroundUploadState.Completed;
}
}
else
{
KeyCollection keys = null;
try
{
using (ProgressStream encodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
{
isStop = (this.State == ManagerState.Stop || !_settings.UploadItems.Contains(item));
}, 1024 * 1024, true))
{
if (stream.Length == 0) throw new InvalidOperationException("Stream Length");
encodingProgressStream.Seek(0, SeekOrigin.Begin);
item.State = BackgroundUploadState.Encoding;
keys = _cacheManager.Encoding(encodingProgressStream, CompressionAlgorithm.None, CryptoAlgorithm.None, null, item.BlockLength, item.HashAlgorithm);
}
}
catch (StopIoException)
{
continue;
}
lock (_thisLock)
{
if (!_settings.UploadItems.Contains(item))
{
foreach (var key in keys)
{
_cacheManager.Unlock(key);
}
continue;
}
foreach (var key in keys)
{
item.UploadKeys.Add(key);
item.LockedKeys.Add(key);
}
item.Keys.AddRange(keys);
}
}
}
finally
{
if (stream != null) stream.Dispose();
}
}
else if (item.Groups.Count == 0 && item.Keys.Count == 1)
{
BroadcastMetadata broadcastMetadata = null;
UnicastMetadata unicastMetadata = null;
MulticastMetadata multicastMetadata = null;
{
var metadata = new Metadata(item.Depth, item.Keys[0], CompressionAlgorithm.None, CryptoAlgorithm.None, null);
if (item.Scheme == "Broadcast")
{
broadcastMetadata = new BroadcastMetadata(item.Type, item.CreationTime, metadata, item.DigitalSignature);
}
else if (item.Scheme == "Unicast")
{
unicastMetadata = new UnicastMetadata(item.Type, item.Signature, item.CreationTime, metadata, item.DigitalSignature);
}
else if (item.Scheme == "Multicast")
{
var miner = new Miner(CashAlgorithm.Version1, item.MiningLimit, item.MiningTime);
try
{
var task = Task.Run(() =>
{
return new MulticastMetadata(item.Type, item.Tag, item.CreationTime, metadata, miner, item.DigitalSignature);
});
while (!task.IsCompleted)
{
if (this.State == ManagerState.Stop) miner.Cancel();
lock (_thisLock)
{
if (!_settings.UploadItems.Contains(item))
{
miner.Cancel();
}
}
Thread.Sleep(1000);
}
multicastMetadata = task.Result;
}
catch (Exception)
{
continue;
}
}
}
lock (_thisLock)
{
if (!_settings.UploadItems.Contains(item)) continue;
if (item.Scheme == "Broadcast")
{
_connectionsManager.Upload(broadcastMetadata);
}
else if (item.Scheme == "Unicast")
{
_connectionsManager.Upload(unicastMetadata);
}
else if (item.Scheme == "Multicast")
{
_connectionsManager.Upload(multicastMetadata);
}
item.Keys.Clear();
foreach (var key in item.UploadKeys)
{
_connectionsManager.Upload(key);
}
item.State = BackgroundUploadState.Uploading;
this.CheckState(item);
}
}
else if (item.Keys.Count > 0)
{
var length = Math.Min(item.Keys.Count, 128);
var keys = new KeyCollection(item.Keys.Take(length));
Group group = null;
try
{
using (var tokenSource = new CancellationTokenSource())
{
var task = _cacheManager.ParityEncoding(keys, item.HashAlgorithm, item.BlockLength, item.CorrectionAlgorithm, tokenSource.Token);
while (!task.IsCompleted)
{
if (this.State == ManagerState.Stop || !_settings.UploadItems.Contains(item)) tokenSource.Cancel();
Thread.Sleep(1000);
}
group = task.Result;
}
}
catch (Exception)
{
continue;
}
lock (_thisLock)
{
if (!_settings.UploadItems.Contains(item))
{
foreach (var key in group.Keys.Skip(group.InformationLength))
{
_cacheManager.Unlock(key);
}
continue;
}
foreach (var key in group.Keys.Skip(group.InformationLength))
{
item.UploadKeys.Add(key);
item.LockedKeys.Add(key);
}
item.Groups.Add(group);
item.Keys.RemoveRange(0, length);
}
}
else if (item.Groups.Count > 0 && item.Keys.Count == 0)
{
var index = new Index();
index.Groups.AddRange(item.Groups);
KeyCollection keys = null;
try
{
using (var stream = index.Export(_bufferManager))
using (ProgressStream encodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
{
isStop = (this.State == ManagerState.Stop || !_settings.UploadItems.Contains(item));
}, 1024 * 1024, true))
{
encodingProgressStream.Seek(0, SeekOrigin.Begin);
item.State = BackgroundUploadState.Encoding;
keys = _cacheManager.Encoding(encodingProgressStream, CompressionAlgorithm.None, CryptoAlgorithm.None, null, item.BlockLength, item.HashAlgorithm);
}
}
catch (StopIoException)
{
continue;
}
lock (_thisLock)
{
if (!_settings.UploadItems.Contains(item))
{
foreach (var key in keys)
{
_cacheManager.Unlock(key);
}
continue;
}
foreach (var key in keys)
{
item.UploadKeys.Add(key);
item.LockedKeys.Add(key);
}
item.Keys.AddRange(keys);
item.Depth++;
item.Groups.Clear();
}
}
}
catch (Exception e)
{
item.State = BackgroundUploadState.Error;
Log.Error(e);
this.Remove(item);
}
}
}
public void Upload(BroadcastMetadata 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(BroadcastMetadata metadata)
{
lock (_thisLock)
{
var now = DateTime.UtcNow;
if (metadata == null
|| metadata.Type == null
|| (metadata.CreationTime - now).TotalMinutes > 30
|| metadata.Certificate == null) return false;
Dictionary<string, BroadcastMetadata> dic;
if (!_broadcastMetadatas.TryGetValue(metadata.Type, out dic))
{
dic = new Dictionary<string, BroadcastMetadata>();
_broadcastMetadatas[metadata.Type] = dic;
}
var signature = metadata.Certificate.ToString();
BroadcastMetadata tempMetadata;
if (!dic.TryGetValue(signature, out tempMetadata)
|| metadata.CreationTime > tempMetadata.CreationTime)
{
if (!metadata.VerifyCertificate()) throw new CertificateException();
dic[signature] = metadata;
}
return true;
}
}
