public static GrpcPeer CreateNewPeer(string ipAddress = "127.0.0.1:2000", bool isValid = true)
{
var channel = new Channel(ipAddress, ChannelCredentials.Insecure);
PeerService.PeerServiceClient client;
if (isValid)
{
client = new PeerService.PeerServiceClient(channel.Intercept(metadata =>
{
metadata.Add(GrpcConstants.PubkeyMetadataKey, NetworkTestConstants.FakePubkey);
return(metadata);
}));
}
else
{
client = new PeerService.PeerServiceClient(channel);
}
var connectionInfo = new PeerInfo
{
Pubkey = NetworkTestConstants.FakePubkey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow().Seconds,
IsInbound = true
};
return(new GrpcPeer(new GrpcClient(channel, client), IpEndpointHelper.Parse(ipAddress), connectionInfo));
}
private static IPeer CreatePeer(string ip = NetworkTestConstants.FakeIpEndpoint)
{
var peerMock = new Mock <IPeer>();
var keyPair = CryptoHelper.GenerateKeyPair();
var pubkey = keyPair.PublicKey.ToHex();
var peerInfo = new PeerInfo
{
Pubkey = pubkey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow().Seconds,
IsInbound = true
};
if (!IpEndpointHelper.TryParse(ip, out var endpoint))
{
throw new Exception($"Endpoint {ip} could not be parsed.");
}
peerMock.Setup(p => p.RemoteEndpoint).Returns(endpoint);
peerMock.Setup(p => p.Info).Returns(peerInfo);
return(peerMock.Object);
}
public async Task DialPeerAsync_DialException_ShouldReturnFalse()
{
IpEndpointHelper.TryParse(NetworkTestConstants.DialExceptionIpEndpoint, out var endpoint);
var added = await _networkServer.ConnectAsync(endpoint);
added.ShouldBeFalse();
_peerPool.PeerCount.ShouldBe(0);
}
public async Task DialPeerAsync_HandshakeError_ShouldReturnFalse()
{
IpEndpointHelper.TryParse(NetworkTestConstants.BadHandshakeIp, out var endpoint);
var added = await _networkServer.ConnectAsync(endpoint);
added.ShouldBeFalse();
_peerPool.PeerCount.ShouldBe(0);
}
public async Task <bool> AddPeerAsync(string address)
{
if (IpEndpointHelper.TryParse(address, out IPEndPoint endpoint))
{
return(await _networkServer.ConnectAsync(endpoint));
}
return(false);
}
public async Task DialPeerAsync_GoodPeer_ShouldBeInPool()
{
IpEndpointHelper.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 async Task DialPeerAsync_KeyAlreadyInPool_ShouldReturnFalse()
{
// two different hosts with the same pubkey.
AddPeerToPool();
IpEndpointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint2, out var endpoint);
var added = await _networkServer.ConnectAsync(endpoint);
added.ShouldBeFalse();
_netTestHelpers.AllPeersWhereCleaned().ShouldBeTrue();
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
var publicKeys = new[]
{
OSConsensusDPosTestConstants.Bp1PublicKey,
OSConsensusDPosTestConstants.Bp2PublicKey,
OSConsensusDPosTestConstants.Bp3PublicKey
};
var services = context.Services;
services.AddSingleton <IPeerPool, PeerPool>();
var peerList = new List <IPeer>();
for (var i = 0; i < 3; i++)
{
var connectionInfo = new PeerInfo
{
Pubkey = publicKeys[i],
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow().Seconds,
IsInbound = true
};
peerList.Add(new GrpcPeer(new GrpcClient(null, null), IpEndpointHelper.Parse($"127.0.0.1:68{i + 1}0"), connectionInfo));
}
services.AddTransient(o =>
{
var mockService = new Mock <IPeerPool>();
mockService.Setup(m => m.FindPeerByPublicKey(It.Is <string>(s => s.Length > 0)))
.Returns(peerList[2]);
mockService.Setup(m => m.GetPeers(It.IsAny <bool>()))
.Returns(peerList);
return(mockService.Object);
});
services.AddTransient(o =>
{
var mockService = new Mock <IAEDPoSInformationProvider>();
mockService.Setup(m => m.GetCurrentMinerList(It.IsAny <ChainContext>()))
.Returns(async() =>
await Task.FromResult(publicKeys));
return(mockService.Object);
});
}
private IPeer BuildPeer(string ipAddress, string pubkey, long connectionTime, bool isInbound)
{
var connectionInfo = new PeerInfo
{
Pubkey = pubkey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = connectionTime,
IsInbound = isInbound
};
var peerMock = new Mock <IPeer>();
peerMock.SetupGet(p => p.Info).Returns(connectionInfo);
peerMock.SetupGet(p => p.RemoteEndpoint).Returns(IpEndpointHelper.Parse(ipAddress));
peerMock.Setup(p => p.GetRequestMetrics()).Returns(new Dictionary <string, List <RequestMetric> >());
return(peerMock.Object);
}
public async Task DialPeerAsync_GoodPeer_ShouldLaunchConnectionEvent()
{
PeerConnectedEventData eventData = null;
_eventBus.Subscribe <PeerConnectedEventData>(e =>
{
eventData = e;
return(Task.CompletedTask);
});
// two different hosts with the same pubkey.
IpEndpointHelper.TryParse(NetworkTestConstants.GoodPeerEndpoint, out var endpoint);
var added = await _networkServer.ConnectAsync(endpoint);
added.ShouldBeTrue();
_peerPool.FindPeerByEndpoint(endpoint).ShouldNotBeNull();
eventData.ShouldNotBeNull();
}
public async Task <bool> RemovePeerAsync(string address)
{
if (!IpEndpointHelper.TryParse(address, out IPEndPoint endpoint))
{
return(false);
}
var peer = _peerPool.FindPeerByEndpoint(endpoint);
if (peer == null)
{
Logger.LogWarning($"Could not find peer at address {address}");
return(false);
}
await _networkServer.DisconnectAsync(peer);
return(true);
}
/// <summary>
/// Connects to the boot nodes provided in the network options.
/// </summary>
private async Task DialBootNodesAsync()
{
if (NetworkOptions.BootNodes == null || !NetworkOptions.BootNodes.Any())
{
Logger.LogWarning("Boot nodes list is empty.");
return;
}
var taskList = NetworkOptions.BootNodes
.Select(async node =>
{
if (!IpEndpointHelper.TryParse(node, out IPEndPoint endpoint))
{
return(false);
}
return(await ConnectAsync(endpoint));
}).ToList();
await Task.WhenAll(taskList.ToArray <Task>());
}
public override void OnApplicationInitialization(ApplicationInitializationContext context)
{
base.OnApplicationInitialization(context);
var pool = context.ServiceProvider.GetRequiredService <IPeerPool>();
var channel = new Channel(NetworkTestConstants.FakeIpEndpoint, ChannelCredentials.Insecure);
var connectionInfo = new PeerInfo
{
Pubkey = NetworkTestConstants.FakePubkey2,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow().Seconds,
IsInbound = true
};
if (!IpEndpointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out var peerEnpdoint))
{
throw new Exception($"Ip {NetworkTestConstants.FakeIpEndpoint} is invalid.");
}
pool.TryAddPeer(new GrpcPeer(new GrpcClient(channel, new PeerService.PeerServiceClient(channel)), peerEnpdoint, connectionInfo));
}
public static GrpcPeer CreatePeerWithClient(string ip, string pubkey, PeerService.PeerServiceClient client)
{
return(new GrpcPeer(new GrpcClient(CreateMockChannel(), client), IpEndpointHelper.Parse(ip), new PeerInfo {
Pubkey = pubkey
}));
}
public static GrpcPeer CreatePeerWithInfo(string ip, PeerInfo info)
{
return(new GrpcPeer(new GrpcClient(CreateMockChannel(), null), IpEndpointHelper.Parse(ip), info));
}
private void AddPeer(string publicKey, int blockHeight)
{
var channel = new Channel(OSConsensusDPosTestConstants.FakeIpEndpoint, ChannelCredentials.Insecure);
var connectionInfo = new PeerInfo
{
Pubkey = publicKey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = _connectionTime,
IsInbound = true
};
var peer = new GrpcPeer(new GrpcClient(channel, new PeerService.PeerServiceClient(channel)), IpEndpointHelper.Parse(OSConsensusDPosTestConstants.FakeIpEndpoint), connectionInfo);
peer.IsConnected = true;
var blocks = _osTestHelper.BestBranchBlockList.GetRange(0, blockHeight);
foreach (var block in blocks)
{
peer.AddKnowBlock(new BlockAnnouncement
{
BlockHash = block.GetHash(), BlockHeight = block.Height
});
}
_peerPool.TryAddPeer(peer);
}
