public static GrpcPeer CreateNewPeer(string ipAddress = "127.0.0.1:2000", bool isValid = true, string publicKey = null)
{
var pubkey = publicKey ?? NetworkTestConstants.FakePubkey;
var channel = new Channel(ipAddress, ChannelCredentials.Insecure);
PeerService.PeerServiceClient client;
if (isValid)
{
client = new PeerService.PeerServiceClient(channel.Intercept(metadata =>
{
metadata.Add(GrpcConstants.PubkeyMetadataKey, pubkey);
return(metadata);
}));
}
else
{
client = new PeerService.PeerServiceClient(channel);
}
var connectionInfo = new PeerConnectionInfo
{
Pubkey = pubkey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow(),
SessionId = new byte[] { 0, 1, 2 },
IsInbound = true
};
var peer = new GrpcPeer(new GrpcClient(channel, client), IpEndPointHelper.Parse(ipAddress), connectionInfo);
peer.InboundSessionId = new byte[] { 0, 1, 2 };
return(peer);
}
public GrpcPeer(GrpcClient client, DnsEndPoint remoteEndpoint, PeerConnectionInfo peerConnectionInfo)
{
_channel = client.Channel;
_client = client.Client;
RemoteEndpoint = remoteEndpoint;
Info = peerConnectionInfo;
_knownTransactionCache = new BoundedExpirationCache(TransactionCacheMaxItems, QueuedItemTimeout);
_knownBlockCache = new BoundedExpirationCache(BlockCacheMaxItems, QueuedItemTimeout);
_recentRequestsRoundtripTimes = new ConcurrentDictionary <string, ConcurrentQueue <RequestMetric> >();
RecentRequestsRoundtripTimes =
new ReadOnlyDictionary <string, ConcurrentQueue <RequestMetric> >(_recentRequestsRoundtripTimes);
_recentRequestsRoundtripTimes.TryAdd(nameof(MetricNames.Announce), new ConcurrentQueue <RequestMetric>());
_recentRequestsRoundtripTimes.TryAdd(nameof(MetricNames.GetBlock), new ConcurrentQueue <RequestMetric>());
_recentRequestsRoundtripTimes.TryAdd(nameof(MetricNames.GetBlocks), new ConcurrentQueue <RequestMetric>());
_sendAnnouncementJobs = new ActionBlock <StreamJob>(SendStreamJobAsync,
new ExecutionDataflowBlockOptions
{
BoundedCapacity = NetworkConstants.DefaultMaxBufferedAnnouncementCount
});
_sendBlockJobs = new ActionBlock <StreamJob>(SendStreamJobAsync,
new ExecutionDataflowBlockOptions
{
BoundedCapacity = NetworkConstants.DefaultMaxBufferedBlockCount
});
_sendTransactionJobs = new ActionBlock <StreamJob>(SendStreamJobAsync,
new ExecutionDataflowBlockOptions
{
BoundedCapacity = NetworkConstants.DefaultMaxBufferedTransactionCount
});
}
private void AddPeer(string publicKey, int blockHeight)
{
var channel = new Channel(OSConsensusDPosTestConstants.FakeIpEndpoint, ChannelCredentials.Insecure);
var connectionInfo = new PeerConnectionInfo
{
Pubkey = publicKey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow(),
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);
}
public static GrpcPeer CreatePeerWithInfo(string ip, PeerConnectionInfo info)
{
var peer = new GrpcPeer(new GrpcClient(CreateMockChannel(), null), IpEndPointHelper.Parse(ip), info);
peer.InboundSessionId = new byte[] { 0, 1, 2 };
return(peer);
}
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 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 IPeer CreatePeer()
{
var peerMock = new Mock <IPeer>();
var pubkey = CryptoHelper.GenerateKeyPair().PublicKey.ToHex();
var peerInfo = new PeerConnectionInfo
{
Pubkey = pubkey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow(),
IsInbound = true
};
peerMock.Setup(p => p.Info).Returns(peerInfo);
return(peerMock.Object);
}
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 PeerConnectionInfo
{
Pubkey = publicKeys[i],
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow(),
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 GrpcPeer CreateNewPeer()
{
var pubkey = "048f5ced21f8d687cb9ade1c22dc0e183b05f87124c82073f5d82a09b139cc466efbfb6f28494d0a9d7366fcb769fe5436cfb7b5d322a2b0f69c4bcb1c33ac24ad";
var ipAddress = "127.0.0.1:888";
var remoteEndpoint = IpEndPointHelper.Parse(ipAddress);
var channel = new Channel(ipAddress, ChannelCredentials.Insecure);
var client = new PeerService.PeerServiceClient(channel);
var connectionInfo = new PeerConnectionInfo
{
Pubkey = pubkey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow(),
IsInbound = true
};
return(new GrpcPeer(new GrpcClient(channel, client), remoteEndpoint, connectionInfo));
}
public override void OnApplicationInitialization(ApplicationInitializationContext context)
{
var pool = context.ServiceProvider.GetRequiredService <IPeerPool>();
var channel = new Channel(NetworkTestConstants.FakeIpEndpoint, ChannelCredentials.Insecure);
var connectionInfo = new PeerConnectionInfo
{
Pubkey = NetworkTestConstants.FakePubkey2,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow(),
IsInbound = true
};
if (!IpEndPointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out var peerEndpoint))
{
throw new Exception($"Ip {NetworkTestConstants.FakeIpEndpoint} is invalid.");
}
pool.TryAddPeer(new GrpcPeer(new GrpcClient(channel, new PeerService.PeerServiceClient(channel)), peerEndpoint, connectionInfo));
}
private static IPeer CreatePeer(string ipEndpoint = NetworkTestConstants.FakeIpEndpoint, string pubKey = null)
{
var peerMock = new Mock <IPeer>();
var pubkey = pubKey ?? CryptoHelper.GenerateKeyPair().PublicKey.ToHex();
var peerInfo = new PeerConnectionInfo
{
Pubkey = pubkey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow(),
IsInbound = true
};
var endpoint = ParseEndPoint(ipEndpoint);
peerMock.Setup(p => p.RemoteEndpoint).Returns(endpoint);
peerMock.Setup(p => p.Info).Returns(peerInfo);
return(peerMock.Object);
}
