public void DialPeerAsync_ShouldThrowException()
{
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.DialExceptionIpEndpoint, out var endpoint);
_networkServer.ConnectAsync(endpoint).ShouldThrow <Exception>();
_peerPool.PeerCount.ShouldBe(0);
}
public async Task Connect_ConfirmFailed_Test()
{
var mockClient = new Mock <PeerService.PeerServiceClient>();
mockClient.Setup(m => m.ConfirmHandshakeAsync(It.IsAny <ConfirmHandshakeRequest>(),
It.IsAny <Metadata>(), It.IsAny <DateTime?>(),
CancellationToken.None)).Throws <Exception>();
var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.FakeIpEndpoint,
NetworkTestConstants.FakePubkey, mockClient.Object);
peer.UpdateLastReceivedHandshake(new Handshake
{
HandshakeData = new HandshakeData
{
LastIrreversibleBlockHeight = 1,
BestChainHash = HashHelper.ComputeFrom("BestChainHash"),
BestChainHeight = 10,
Time = TimestampHelper.GetUtcNow().AddMinutes(-1)
}
});
_peerPool.TryAddPeer(peer);
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.GoodPeerEndpoint, out var endpoint);
_connectionService.ConnectAsync(endpoint).ShouldThrow <Exception>();
var currentPeer = _peerPool.FindPeerByEndpoint(endpoint);
currentPeer.ShouldBeNull();
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out endpoint);
currentPeer = _peerPool.FindPeerByEndpoint(endpoint);
currentPeer.ShouldBeNull();
}
public void DialPeerAsync_HandshakeDataProblem_ShouldThrowException()
{
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.HandshakeWithNetExceptionIp, out var endpoint);
_networkServer.ConnectAsync(endpoint).ShouldThrow <Exception>();
_peerPool.PeerCount.ShouldBe(0);
}
public void DialPeerAsync_HandshakeError_ShouldThrowException()
{
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.BadHandshakeIp, out var endpoint);
_networkServer.ConnectAsync(endpoint).ShouldThrow <NetworkException>();
_peerPool.PeerCount.ShouldBe(0);
}
public async Task Connect_DialPeerFailed_Test()
{
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.DialExceptionIpEndpoint, out var endpoint);
var result = await _connectionService.ConnectAsync(endpoint);
result.ShouldBeFalse();
}
public async Task DialPeer_InvalidEndpoint_Test()
{
AElfPeerEndpointHelper.TryParse("127.0.0.1:2001", out var endpoint);
var grpcPeer = await _peerDialer.DialPeerAsync(endpoint);
grpcPeer.ShouldBeNull();
}
public void AddHandshakingPeer_AlreadyInPeerPool_Test()
{
var handshakingPeerHost = "192.168.100.1";
var peerMock = new Mock <IPeer>();
var peerInfo = new PeerConnectionInfo
{
Pubkey = "PeerPubkey",
};
AElfPeerEndpointHelper.TryParse("192.168.100.1:8001", out var endpoint);
peerMock.Setup(p => p.RemoteEndpoint).Returns(endpoint);
peerMock.Setup(p => p.Info).Returns(peerInfo);
_peerPool.TryAddPeer(peerMock.Object);
{
var pubkey = "pubkey1";
var addResult = _peerPool.AddHandshakingPeer(handshakingPeerHost, pubkey);
addResult.ShouldBeTrue();
var handshakingPeers = _peerPool.GetHandshakingPeers();
handshakingPeers.ShouldContainKey(handshakingPeerHost);
handshakingPeers[handshakingPeerHost].ShouldContainKey(pubkey);
}
{
var pubkey = "pubkey2";
var addResult = _peerPool.AddHandshakingPeer(handshakingPeerHost, pubkey);
addResult.ShouldBeFalse();
var handshakingPeers = _peerPool.GetHandshakingPeers();
handshakingPeers[handshakingPeerHost].ShouldNotContainKey(pubkey);
}
}
private IPeer BuildPeer(string ipAddress, string pubkey, Timestamp connectionTime, bool isInbound)
{
var connectionInfo = new PeerConnectionInfo
{
Pubkey = pubkey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = connectionTime,
IsInbound = isInbound
};
var peerMock = new Mock <IPeer>();
peerMock.SetupGet(p => p.Info).Returns(connectionInfo);
AElfPeerEndpointHelper.TryParse(ipAddress, out var ip);
peerMock.SetupGet(p => p.RemoteEndpoint).Returns(ip);
peerMock.Setup(p => p.GetRequestMetrics()).Returns(new Dictionary <string, List <RequestMetric> >
{
{ "test", new List <RequestMetric> {
new RequestMetric()
} }
});
return(peerMock.Object);
}
public async Task Connect_InboundPeerIsLater_Test()
{
var peer = CreatePeerAndAddToPeerPool();
peer.UpdateLastReceivedHandshake(new Handshake
{
HandshakeData = new HandshakeData
{
LastIrreversibleBlockHeight = 1,
BestChainHash = HashHelper.ComputeFrom("BestChainHash"),
BestChainHeight = 10,
Time = TimestampHelper.GetUtcNow().AddMinutes(1)
}
});
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.GoodPeerEndpoint, out var endpoint);
var added = await _connectionService.ConnectAsync(endpoint);
added.ShouldBeTrue();
var currentPeer = _peerPool.FindPeerByEndpoint(endpoint);
currentPeer.ShouldNotBeNull();
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out endpoint);
currentPeer = _peerPool.FindPeerByEndpoint(endpoint);
currentPeer.ShouldBeNull();
}
public async Task ProcessPeerDiscoveryJob_PeerPoolIsFull_Test()
{
var endpoint = new AElfPeerEndpoint("192.168.100.1", 8000);
var peer = new Mock <IPeer>();
peer.Setup(p => p.IsReady).Returns(true);
peer.Setup(p => p.Info).Returns(new PeerConnectionInfo
{
Pubkey = endpoint.ToString(), ConnectionTime = TimestampHelper.GetUtcNow()
});
peer.Setup(p => p.RemoteEndpoint).Returns(endpoint);
_peerPool.TryAddPeer(peer.Object);
await RunDiscoveryWorkerAsync();
var endpointString = "192.168.100.100:8003";
var nodeList = await _peerDiscoveryService.GetNodesAsync(10);
nodeList.Nodes.Count.ShouldBe(1);
nodeList.Nodes[0].Endpoint.ShouldBe(endpointString);
nodeList.Nodes[0].Pubkey.ShouldBe(ByteString.CopyFromUtf8(endpointString));
AElfPeerEndpointHelper.TryParse(endpointString, out var aelEndpoint);
var result = _peerPool.FindPeerByEndpoint(aelEndpoint);
result.ShouldBeNull();
}
public static GrpcPeer CreatePeerWithInfo(string ip, PeerConnectionInfo info)
{
AElfPeerEndpointHelper.TryParse(ip, out var endpoint);
var peer = new GrpcPeer(new GrpcClient(CreateMockChannel(), null), endpoint, info);
peer.InboundSessionId = new byte[] { 0, 1, 2 };
return(peer);
}
private static DnsEndPoint ParseEndPoint(string ipEndpoint)
{
if (!AElfPeerEndpointHelper.TryParse(ipEndpoint, out var endpoint))
{
throw new Exception($"Endpoint {ipEndpoint} could not be parsed.");
}
return(endpoint);
}
public async Task SchedulePeerReconnection_Test()
{
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out var endpoint);
var result = await _connectionService.SchedulePeerReconnection(endpoint);
result.ShouldBeTrue();
_reconnectionService.GetReconnectingPeer(NetworkTestConstants.FakeIpEndpoint).ShouldNotBeNull();
}
public async Task Connect_HostInBlackList_Test()
{
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out var endpoint);
_blackListedPeerProvider.AddHostToBlackList(endpoint.Host, 10);
var added = await _connectionService.ConnectAsync(endpoint);
added.ShouldBeFalse();
}
public async Task AddPeerAsync_CannotAddBlacklistedPeer()
{
AElfPeerEndpointHelper.TryParse("127.0.0.1:5000", out var endpoint);
var host = endpoint.Host;
_blackListProvider.AddHostToBlackList(host);
(await _networkService.AddPeerAsync(endpoint.ToString())).ShouldBeFalse();
}
public async Task DialBackPeer_InvalidEndpoint_Test()
{
AElfPeerEndpointHelper.TryParse("127.0.0.1:2001", out var endpoint);
var handshake = await _handshakeProvider.GetHandshakeAsync();
var grpcPeer = await _peerDialer.DialBackPeerAsync(endpoint, handshake);
grpcPeer.ShouldBeNull();
}
public void ParsingTest(string endpointToParse, bool isValid, int expectedPort = 0)
{
AElfPeerEndpointHelper.TryParse(endpointToParse, out var endpoint).ShouldBe(isValid);
if (isValid)
{
endpoint.Port.ShouldBe(expectedPort);
}
}
public static GrpcPeer CreatePeerWithClient(string ip, string pubkey, PeerService.PeerServiceClient client)
{
AElfPeerEndpointHelper.TryParse(ip, out var endpoint);
var peer = new GrpcPeer(new GrpcClient(CreateMockChannel(), client), endpoint, new PeerConnectionInfo {
Pubkey = pubkey, SessionId = new byte[] { 0, 1, 2 }
});
peer.InboundSessionId = new byte[] { 0, 1, 2 };
return(peer);
}
public async Task DialPeerAsync_GoodPeer_ShouldBeInPool()
{
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.GoodPeerEndpoint, out var endpoint);
// two different hosts with the same pubkey.
var added = await _networkServer.ConnectAsync(endpoint);
added.ShouldBeTrue();
_peerPool.FindPeerByEndpoint(endpoint).ShouldNotBeNull();
}
public static async Task <bool> CheckEndpointAvailableAsync(this IAElfNetworkServer networkServer,
string endpoint)
{
if (!AElfPeerEndpointHelper.TryParse(endpoint, out var aelfPeerEndpoint))
{
return(false);
}
return(await networkServer.CheckEndpointAvailableAsync(aelfPeerEndpoint));
}
public async Task <bool> AddPeerAsync(string address)
{
if (AElfPeerEndpointHelper.TryParse(address, out DnsEndPoint endpoint))
{
return(await _networkServer.ConnectAsync(endpoint));
}
Logger.LogWarning($"Could not parse endpoint {address}.");
return(false);
}
public async Task AddPeer_DotNotRemoveBlackList_Test()
{
AElfPeerEndpointHelper.TryParse("127.0.0.1:5000", out var endpoint);
var host = endpoint.Host;
_blackListProvider.AddHostToBlackList(host, NetworkConstants.DefaultPeerRemovalSeconds);
await _networkService.AddPeerAsync(endpoint.ToString());
_blackListProvider.IsIpBlackListed(host).ShouldBeTrue();
}
public async Task DoHandshake_DialBackFailed_Test()
{
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out var endpoint);
var handshake = CreateHandshake(port: endpoint.Port);
var result = await _connectionService.DoHandshakeAsync(endpoint, handshake);
result.Error.ShouldBe(HandshakeError.InvalidConnection);
_peerPool.GetHandshakingPeers().ShouldNotContainKey(endpoint.Host);
}
public async Task DialPeer_Test()
{
AElfPeerEndpointHelper.TryParse("127.0.0.1:2000", out var endpoint);
var grpcPeer = await _peerDialer.DialPeerAsync(endpoint);
grpcPeer.ShouldNotBeNull();
grpcPeer.CurrentBlockHash.ShouldBe(HashHelper.ComputeFrom("BestChainHash"));
grpcPeer.CurrentBlockHeight.ShouldBe(10);
grpcPeer.LastKnownLibHeight.ShouldBe(1);
}
public async Task AddTrustedPeer_Test()
{
var endpoint = "127.0.0.1:5000";
AElfPeerEndpointHelper.TryParse(endpoint, out var aelfPeerEndpoint);
var host = aelfPeerEndpoint.Host;
_blackListProvider.AddHostToBlackList(host, 5000);
await _networkService.AddTrustedPeerAsync(endpoint);
_blackListProvider.IsIpBlackListed(host).ShouldBeFalse();
}
public async Task DoHandshake_AlreadyInHandshaking_Test()
{
AElfPeerEndpointHelper.TryParse(NetworkTestConstants.GoodPeerEndpoint, out var endpoint);
var handshake = CreateHandshake();
_peerPool.AddHandshakingPeer(endpoint.Host, handshake.HandshakeData.Pubkey.ToHex());
var result = await _connectionService.DoHandshakeAsync(endpoint, handshake);
result.Error.ShouldBe(HandshakeError.ConnectionRefused);
_peerPool.GetHandshakingPeers().ShouldNotContainKey(endpoint.Host);
}
public async Task DialPeer_Test()
{
AElfPeerEndpointHelper.TryParse("127.0.0.1:2000", out var endpoint);
var grpcPeer = await _peerDialer.DialPeerAsync(endpoint);
grpcPeer.ShouldNotBeNull();
var peersHandshake = _networkTestContext.GeneratedHandshakes[endpoint.Host];
grpcPeer.CurrentBlockHash.ShouldBe(peersHandshake.HandshakeData.BestChainHash);
grpcPeer.CurrentBlockHeight.ShouldBe(peersHandshake.HandshakeData.BestChainHeight);
grpcPeer.LastKnownLibHeight.ShouldBe(peersHandshake.HandshakeData.LastIrreversibleBlockHeight);
}
public async Task DialBackPeer_Test()
{
AElfPeerEndpointHelper.TryParse("127.0.0.1:2000", out var endpoint);
var handshake = await _handshakeProvider.GetHandshakeAsync();
var grpcPeer = await _peerDialer.DialBackPeerAsync(endpoint, handshake);
grpcPeer.ShouldNotBeNull();
grpcPeer.CurrentBlockHash.ShouldBe(handshake.HandshakeData.BestChainHash);
grpcPeer.CurrentBlockHeight.ShouldBe(handshake.HandshakeData.BestChainHeight);
grpcPeer.LastKnownLibHeight.ShouldBe(handshake.HandshakeData.LastIrreversibleBlockHeight);
grpcPeer.Info.Pubkey.ShouldBe(handshake.HandshakeData.Pubkey.ToHex());
grpcPeer.Info.ProtocolVersion.ShouldBe(handshake.HandshakeData.Version);
}
public async Task RemovePeerByPubkeyAsync_BlackListTest()
{
var peerPubKey = "blacklistpeer";
AElfPeerEndpointHelper.TryParse("127.0.0.1:5000", out var endpoint);
var host = endpoint.Host;
await _networkService.RemovePeerByPubkeyAsync(peerPubKey);
_blackListProvider.IsIpBlackListed(host).ShouldBeFalse();
await _networkService.RemovePeerByPubkeyAsync(peerPubKey, true);
_blackListProvider.IsIpBlackListed(host).ShouldBeTrue();
}
public async Task RemovePeerByPubkey_Test()
{
AElfPeerEndpointHelper.TryParse("192.168.100.200:5000", out var endpoint);
var host = endpoint.Host;
//invalid pubkey
var result = await _networkService.RemovePeerByPubkeyAsync("InvalidPubkey");
result.ShouldBeFalse();
result = await _networkService.RemovePeerByPubkeyAsync("NormalPeer");
result.ShouldBeTrue();
_blackListProvider.IsIpBlackListed("192.168.100.200").ShouldBeTrue();
}
