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(); }