public void PeerCanBeReturnedAsPreferred_HasBeenConnectedTo_Scenario3()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var addressOne = new NetworkAddress(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.2");
var addressTwo = new NetworkAddress(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.3");
var addressThree = new NetworkAddress(ipAddress, 80);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var addressManager = new PeerAddressManager(peerFolder);
addressManager.AddPeer(addressOne, IPAddress.Loopback);
addressManager.AddPeer(addressTwo, IPAddress.Loopback);
addressManager.AddPeer(addressThree, IPAddress.Loopback);
addressManager.PeerConnected(addressOne.Endpoint, DateTime.UtcNow.AddDays(-5));
for (int i = 0; i < 11; i++)
{
addressManager.PeerAttempted(addressOne.Endpoint, DateTime.UtcNow);
}
var networkAddresses = addressManager.SelectPeersToConnectTo();
Assert.Equal(2, networkAddresses.Count());
Assert.Null(networkAddresses.FirstOrDefault(n => n.Endpoint.Address.ToString() == addressOne.Endpoint.Address.ToString()));
}
public void PeerConnectorConnect_FindPeerToConnectTo_Returns_ConnectNodePeers()
{
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerConnectorTests"));
var peerAddressManager = new PeerAddressManager(peerFolder, this.extendedLoggerFactory);
var ipAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
var networkAddressAddNode = new NetworkAddress(ipAddressOne, 80);
var ipAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
var networkAddressDiscoverNode = new NetworkAddress(ipAddressTwo, 80);
var ipAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var networkAddressConnectNode = new NetworkAddress(ipAddressThree, 80);
peerAddressManager.AddPeer(networkAddressAddNode, IPAddress.Loopback);
peerAddressManager.AddPeer(networkAddressConnectNode, IPAddress.Loopback);
peerAddressManager.AddPeer(networkAddressDiscoverNode, IPAddress.Loopback);
var nodeSettings = new NodeSettings
{
ConnectionManager = new Configuration.Settings.ConnectionManagerSettings()
};
nodeSettings.ConnectionManager.Connect.Add(networkAddressConnectNode.Endpoint);
var connector = this.CreatePeerConnectorConnectNode(nodeSettings, peerAddressManager);
// TODO: Once we have an interface on NetworkPeer we can test this properly.
//var connector = this.CreatePeerConnecterAddNode(nodeSettings, peerAddressManager);
//connector.OnConnectAsync().GetAwaiter().GetResult();
//Assert.Contains(networkAddressConnectNode, connector.ConnectedPeers.Select(p => p.PeerAddress));
}
public void PeerFile_CanSaveAndLoadPeers_PeerConnected()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endpoint = new IPEndPoint(ipAddress, 80);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var addressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.loggerFactory);
addressManager.AddPeer(endpoint, IPAddress.Loopback);
var applicableDate = DateTime.UtcNow.Date;
addressManager.PeerAttempted(endpoint, applicableDate);
addressManager.PeerConnected(endpoint, applicableDate);
addressManager.SavePeers();
addressManager.LoadPeers();
var savedPeer = addressManager.FindPeer(endpoint);
Assert.Equal("::ffff:192.168.0.1", savedPeer.Endpoint.Address.ToString());
Assert.Equal(80, savedPeer.Endpoint.Port);
Assert.Equal(0, savedPeer.ConnectionAttempts);
Assert.Equal(applicableDate, savedPeer.LastConnectionSuccess.Value.Date);
Assert.Null(savedPeer.LastConnectionHandshake);
Assert.Equal("127.0.0.1", savedPeer.Loopback.ToString());
}
public void PeerSelector_ReturnConnectedPeers_AfterHandshakeFailure_WithAttemptsRemaining()
{
IPAddress ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
DataFolder peerFolder = CreateDataFolder(this);
PeerAddressManager peerAddressManager = this.CreatePeerAddressManager(peerFolder);
peerAddressManager.AddPeer(new IPEndPoint(ipAddress, 80), IPAddress.Loopback);
peerAddressManager.PeerConnected(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddSeconds(-80));
DateTime handshakeAttempt = DateTime.UtcNow.AddSeconds(-80);
PeerAddress peer = peerAddressManager.Peers.First();
// Peer selected after one handshake failure.
peer.SetHandshakeAttempted(handshakeAttempt);
Assert.Equal(1, peer.HandshakedAttempts);
Assert.Contains(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
// Peer selected after two handshake failures.
peer.SetHandshakeAttempted(handshakeAttempt);
Assert.Equal(2, peer.HandshakedAttempts);
Assert.Contains(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
// Peer not selected after three handshake failures.
peer.SetHandshakeAttempted(handshakeAttempt);
Assert.Equal(3, peer.HandshakedAttempts);
Assert.DoesNotContain(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
}
public void PeerSelector_ReturnConnectedPeers_AfterThresholdExpired_ResetCounters()
{
IPAddress ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
DataFolder peerFolder = CreateDataFolder(this);
PeerAddressManager peerAddressManager = this.CreatePeerAddressManager(peerFolder);
peerAddressManager.AddPeer(new IPEndPoint(ipAddress, 80), IPAddress.Loopback);
peerAddressManager.PeerConnected(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddSeconds(-80));
DateTime firstHandshakeAttemptTime = DateTime.UtcNow.AddSeconds(-80);
PeerAddress peer = peerAddressManager.Peers.First();
// Peer selected after one handshake failure.
peer.SetHandshakeAttempted(firstHandshakeAttemptTime);
Assert.Equal(1, peer.HandshakedAttempts);
Assert.Contains(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
// Peer selected after two handshake failures.
peer.SetHandshakeAttempted(firstHandshakeAttemptTime);
Assert.Equal(2, peer.HandshakedAttempts);
Assert.Contains(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
// Peer attempt counter and last attempt reset when threshold time has elapsed.
peer.SetHandshakeAttempted(firstHandshakeAttemptTime.AddHours(-(PeerAddress.AttempThresholdHours + 2)));
Assert.Contains(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
Assert.Equal(0, peer.HandshakedAttempts);
}
public void PeerSelector_ReturnPeersForGetAddrPayload_Scenario4()
{
var peersToAdd = new List <IPEndPoint>();
for (int i = 1; i <= 15; i++)
{
IPAddress ipAddress = IPAddress.Parse(string.Format("::ffff:192.168.0.{0}", i));
peersToAdd.Add(new IPEndPoint(ipAddress, 80));
}
DataFolder peerFolder = CreateDataFolder(this);
PeerAddressManager peerAddressManager = this.CreatePeerAddressManager(peerFolder);
peerAddressManager.AddPeers(peersToAdd.ToArray(), IPAddress.Loopback);
for (int i = 1; i <= 2; i++)
{
IPAddress ipAddress = IPAddress.Parse(string.Format("::ffff:192.168.0.{0}", i));
peerAddressManager.PeerConnected(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddSeconds(-80));
}
IEnumerable <PeerAddress> peers = peerAddressManager.PeerSelector.SelectPeersForGetAddrPayload(15);
Assert.Equal(15, peers.Count());
Assert.Equal(2, peers.Count(p => p.Connected));
Assert.Equal(13, peers.Count(p => p.Fresh));
}
public void PeerSelector_ReturnPeersForDiscovery_IgnoringBannedPeer()
{
string discoveredpeer = "::ffff:192.168.0.2";
IPAddress ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endPointOne = new IPEndPoint(ipAddress, 80);
ipAddress = IPAddress.Parse(discoveredpeer);
var endPointTwo = new IPEndPoint(ipAddress, 80);
DataFolder peerFolder = CreateDataFolder(this);
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.extendedLoggerFactory,
new SelfEndpointTracker(this.extendedLoggerFactory, this.connectionManagerSettings));
peerAddressManager.AddPeer(endPointOne, IPAddress.Loopback);
peerAddressManager.AddPeer(endPointTwo, IPAddress.Loopback);
// Discovered peer.
ipAddress = IPAddress.Parse(discoveredpeer);
peerAddressManager.PeerDiscoveredFrom(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddHours(-25));
// Banned peer.
peerAddressManager.FindPeer(endPointOne).BanUntil = DateTime.UtcNow.AddMinutes(1);
IEnumerable <PeerAddress> peers = peerAddressManager.PeerSelector.SelectPeersForDiscovery(2);
Assert.Single(peers);
Assert.Contains(peers, p => p.Endpoint.Match(endPointTwo));
}
public void PeerSelector_ReturnPeersForGetAddrPayload_Scenario4()
{
var peersToAdd = new List <IPEndPoint>();
for (int i = 1; i <= 15; i++)
{
var ipAddress = IPAddress.Parse(string.Format("::ffff:192.168.0.{0}", i));
peersToAdd.Add(new IPEndPoint(ipAddress, 80));
}
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.extendedLoggerFactory);
peerAddressManager.AddPeers(peersToAdd.ToArray(), IPAddress.Loopback);
for (int i = 1; i <= 2; i++)
{
var ipAddress = IPAddress.Parse(string.Format("::ffff:192.168.0.{0}", i));
peerAddressManager.PeerConnected(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddSeconds(-80));
}
var peers = peerAddressManager.PeerSelector.SelectPeersForGetAddrPayload(15);
Assert.Equal(15, peers.Count());
Assert.Equal(2, peers.Count(p => p.Connected));
Assert.Equal(13, peers.Count(p => p.Fresh));
}
public void PeerSelector_ReturnPeersForDiscovery_Scenario1()
{
var peersToAdd = new List <IPEndPoint>();
for (int i = 1; i <= 5; i++)
{
var ipAddress = IPAddress.Parse(string.Format("::ffff:192.168.0.{0}", i));
peersToAdd.Add(new IPEndPoint(ipAddress, 80));
}
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.extendedLoggerFactory);
peerAddressManager.AddPeers(peersToAdd.ToArray(), IPAddress.Loopback);
//These peers were all discovered from in the last 24 hours
for (int i = 1; i <= 3; i++)
{
var ipAddress = IPAddress.Parse(string.Format("::ffff:192.168.0.{0}", i));
peerAddressManager.PeerDiscoveredFrom(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddHours(-5));
}
//These peers were all discovered from more than 24 hours ago
for (int i = 4; i <= 5; i++)
{
var ipAddress = IPAddress.Parse(string.Format("::ffff:192.168.0.{0}", i));
peerAddressManager.PeerDiscoveredFrom(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddHours(-25));
}
var peers = peerAddressManager.PeerSelector.SelectPeersForDiscovery(5);
Assert.Equal(2, peers.Count());
}
public void PeerState_TestReturnFromPeerAttemptedSet_Scenario2()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endPointOne = new IPEndPoint(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.2");
var endPointTwo = new IPEndPoint(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.3");
var endPointThree = new IPEndPoint(ipAddress, 80);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.extendedLoggerFactory);
peerAddressManager.AddPeer(endPointOne, IPAddress.Loopback);
peerAddressManager.AddPeer(endPointTwo, IPAddress.Loopback);
peerAddressManager.AddPeer(endPointThree, IPAddress.Loopback);
peerAddressManager.PeerAttempted(endPointOne, DateTime.UtcNow.AddHours(-2));
peerAddressManager.PeerAttempted(endPointTwo, DateTime.UtcNow.AddHours(-820));
for (int i = 0; i < 15; i++)
{
peerAddressManager.PeerAttempted(endPointThree, DateTime.UtcNow);
}
var peers = peerAddressManager.PeerSelector.Attempted();
Assert.Equal(2, peers.Count());
Assert.DoesNotContain(peers, p => p.Endpoint.Match(endPointThree));
}
public void PeerState_TestReturnFromPeerHandshakedSet()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endPointOne = new IPEndPoint(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.2");
var endPointTwo = new IPEndPoint(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.3");
var endPointThree = new IPEndPoint(ipAddress, 80);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.extendedLoggerFactory);
peerAddressManager.AddPeer(endPointOne, IPAddress.Loopback);
peerAddressManager.AddPeer(endPointTwo, IPAddress.Loopback);
peerAddressManager.AddPeer(endPointThree, IPAddress.Loopback);
peerAddressManager.PeerConnected(endPointOne, DateTime.UtcNow);
peerAddressManager.PeerHandshaked(endPointOne, DateTime.UtcNow);
peerAddressManager.PeerConnected(endPointTwo, DateTime.UtcNow.AddSeconds(-80));
peerAddressManager.PeerHandshaked(endPointTwo, DateTime.UtcNow.AddSeconds(-80));
peerAddressManager.PeerAttempted(endPointThree, DateTime.UtcNow);
var peers = peerAddressManager.PeerSelector.Handshaked();
Assert.Single(peers);
Assert.Contains(peers, p => p.Endpoint.Match(endPointTwo));
}
public void PeerConnectorConnect_FindPeerToConnectTo_Returns_ConnectNodePeers()
{
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerConnectorTests"));
var peerAddressManager = new PeerAddressManager(peerFolder, this.extendedLoggerFactory);
var ipAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
var networkAddressAddNode = new NetworkAddress(ipAddressOne, 80);
var ipAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
var networkAddressDiscoverNode = new NetworkAddress(ipAddressTwo, 80);
var ipAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var networkAddressConnectNode = new NetworkAddress(ipAddressThree, 80);
peerAddressManager.AddPeer(networkAddressAddNode, IPAddress.Loopback);
peerAddressManager.AddPeer(networkAddressConnectNode, IPAddress.Loopback);
peerAddressManager.AddPeer(networkAddressDiscoverNode, IPAddress.Loopback);
var nodeSettings = new NodeSettings
{
ConnectionManager = new Configuration.Settings.ConnectionManagerSettings()
};
nodeSettings.ConnectionManager.Connect.Add(networkAddressConnectNode.Endpoint);
var connector = this.CreatePeerConnectorConnectNode(nodeSettings, peerAddressManager);
var peer = connector.FindPeerToConnectTo();
Assert.Equal(networkAddressConnectNode.Endpoint, peer.NetworkAddress.Endpoint);
}
public void PeerAddressManager_AttemptThresholdTimeNotReached_DoNotReset()
{
IPAddress ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endpoint = new IPEndPoint(ipAddress, 80);
DataFolder peerFolder = CreateDataFolder(this);
var addressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.LoggerFactory.Object, new SelfEndpointTracker(this.LoggerFactory.Object));
addressManager.AddPeer(endpoint, IPAddress.Loopback);
DateTime applicableDate = DateTimeProvider.Default.GetUtcNow();
//Ensure that there was 10 failed attempts
for (int i = 0; i < 10; i++)
{
addressManager.PeerAttempted(endpoint, applicableDate.AddHours(-i));
}
//Capture the last attempt timestamp
DateTime lastAttempt = DateTimeProvider.Default.GetUtcNow();
addressManager.PeerAttempted(endpoint, lastAttempt);
PeerAddress savedPeer = addressManager.FindPeer(endpoint);
Assert.Equal(11, savedPeer.ConnectionAttempts);
Assert.Equal(lastAttempt, savedPeer.LastAttempt);
Assert.Null(savedPeer.LastConnectionSuccess);
Assert.Null(savedPeer.LastConnectionHandshake);
Assert.Null(savedPeer.LastSeen);
Assert.Equal("127.0.0.1", savedPeer.Loopback.ToString());
}
public void CanSaveAndLoadPeerAddressFile_PeerHandshaked()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var networkAddress = new NetworkAddress(ipAddress, 80);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var addressManager = new PeerAddressManager(peerFolder);
addressManager.AddPeer(networkAddress, IPAddress.Loopback);
var applicableDate = DateTime.UtcNow.Date;
addressManager.PeerAttempted(networkAddress.Endpoint, applicableDate);
addressManager.PeerConnected(networkAddress.Endpoint, applicableDate);
addressManager.PeerHandshaked(networkAddress.Endpoint, applicableDate);
addressManager.SavePeers();
addressManager.LoadPeers();
var savedPeer = addressManager.FindPeer(networkAddress.Endpoint);
Assert.Equal("::ffff:192.168.0.1", savedPeer.NetworkAddress.Endpoint.Address.ToString());
Assert.Equal(applicableDate, savedPeer.NetworkAddress.Time);
Assert.Equal(80, savedPeer.NetworkAddress.Endpoint.Port);
Assert.Equal(0, savedPeer.ConnectionAttempts);
Assert.Equal(applicableDate, savedPeer.LastConnectionSuccess.Value.Date);
Assert.Equal(applicableDate, savedPeer.LastConnectionHandshake.Value.Date);
Assert.Equal("127.0.0.1", savedPeer.Loopback.ToString());
}
public void PeerState_TestReturnFromPeerAttemptedSet_Scenario2()
{
IPAddress ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endPointOne = new IPEndPoint(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.2");
var endPointTwo = new IPEndPoint(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.3");
var endPointThree = new IPEndPoint(ipAddress, 80);
DataFolder peerFolder = CreateDataFolder(this);
PeerAddressManager peerAddressManager = this.CreatePeerAddressManager(peerFolder);
peerAddressManager.AddPeer(endPointOne, IPAddress.Loopback);
peerAddressManager.AddPeer(endPointTwo, IPAddress.Loopback);
peerAddressManager.AddPeer(endPointThree, IPAddress.Loopback);
peerAddressManager.PeerAttempted(endPointOne, DateTime.UtcNow.AddHours(-2));
peerAddressManager.PeerAttempted(endPointTwo, DateTime.UtcNow.AddHours(-820));
for (int i = 0; i < 15; i++)
{
peerAddressManager.PeerAttempted(endPointThree, DateTime.UtcNow);
}
IEnumerable <PeerAddress> peers = peerAddressManager.PeerSelector.Attempted();
Assert.Equal(2, peers.Count());
Assert.DoesNotContain(peers, p => p.Endpoint.Match(endPointThree));
}
public void PeerSelector_ReturnConnectedPeers_AfterHandshakeFailure_ThresholdExceeded()
{
IPAddress ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
DataFolder peerFolder = CreateDataFolder(this);
PeerAddressManager peerAddressManager = this.CreatePeerAddressManager(peerFolder);
peerAddressManager.AddPeer(new IPEndPoint(ipAddress, 80), IPAddress.Loopback);
peerAddressManager.PeerConnected(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddSeconds(-80));
DateTime handshakeAttempt = DateTime.UtcNow.AddSeconds(-80);
PeerAddress peer = peerAddressManager.Peers[0];
// Peer selected after one handshake failure.
peer.SetHandshakeAttempted(handshakeAttempt.AddHours(-(PeerAddress.AttempThresholdHours + 4)));
Assert.Equal(1, peer.HandshakedAttempts);
Assert.Contains(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
// Peer selected after two handshake failures.
peer.SetHandshakeAttempted(handshakeAttempt.AddHours(-(PeerAddress.AttempThresholdHours + 3)));
Assert.Equal(2, peer.HandshakedAttempts);
Assert.Contains(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
// Peer selected after two handshake failures when threshold time has elapsed.
peer.SetHandshakeAttempted(handshakeAttempt.AddHours(-(PeerAddress.AttempThresholdHours + 2)));
Assert.Equal(3, peer.HandshakedAttempts);
Assert.Contains(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
}
public void PeerState_TestReturnFromPeerHandshakedSet()
{
IPAddress ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endPointOne = new IPEndPoint(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.2");
var endPointTwo = new IPEndPoint(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.3");
var endPointThree = new IPEndPoint(ipAddress, 80);
DataFolder peerFolder = CreateDataFolder(this);
PeerAddressManager peerAddressManager = this.CreatePeerAddressManager(peerFolder);
peerAddressManager.AddPeer(endPointOne, IPAddress.Loopback);
peerAddressManager.AddPeer(endPointTwo, IPAddress.Loopback);
peerAddressManager.AddPeer(endPointThree, IPAddress.Loopback);
peerAddressManager.PeerConnected(endPointOne, DateTime.UtcNow);
peerAddressManager.PeerHandshaked(endPointOne, DateTime.UtcNow);
peerAddressManager.PeerConnected(endPointTwo, DateTime.UtcNow.AddSeconds(-80));
peerAddressManager.PeerHandshaked(endPointTwo, DateTime.UtcNow.AddSeconds(-80));
peerAddressManager.PeerAttempted(endPointThree, DateTime.UtcNow);
IEnumerable <PeerAddress> peers = peerAddressManager.PeerSelector.Handshaked();
Assert.Single(peers);
Assert.Contains(peers, p => p.Endpoint.Match(endPointTwo));
}
public void ConnectionManager_AddsExternalIpToSelfEndpointTracker()
{
const string externalIp = "8.8.8.8";
var nodeSettings = new NodeSettings(this.Network, args: new[] { $"-externalip={externalIp}" });
var connectionManagerSettings = new ConnectionManagerSettings(nodeSettings)
{
Bind = new List <NodeServerEndpoint>()
};
DataFolder peerFolder = CreateDataFolder(this);
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.extendedLoggerFactory,
new SelfEndpointTracker(this.extendedLoggerFactory, connectionManagerSettings));
var networkPeer = new Mock <INetworkPeer>();
var networkPeerFactory = new Mock <INetworkPeerFactory>();
var peerConnector = new Mock <IPeerConnector>();
var selfEndpointTracker = new Mock <ISelfEndpointTracker>();
IConnectionManager connectionManager = this.CreateConnectionManager(nodeSettings, connectionManagerSettings, peerAddressManager, peerConnector.Object, selfEndpointTracker.Object);
connectionManager.Initialize(new Mock <IConsensusManager>().Object);
selfEndpointTracker.Verify(x => x.Add(new IPEndPoint(IPAddress.Parse(externalIp), this.Network.DefaultPort)), Times.Once);
}
public void PeerSelector_ReturnPeersForDiscovery_Scenario1()
{
var peersToAdd = new List <IPEndPoint>();
for (int i = 1; i <= 5; i++)
{
IPAddress ipAddress = IPAddress.Parse(string.Format("::ffff:192.168.0.{0}", i));
peersToAdd.Add(new IPEndPoint(ipAddress, 80));
}
DataFolder peerFolder = CreateDataFolder(this);
PeerAddressManager peerAddressManager = this.CreatePeerAddressManager(peerFolder);
peerAddressManager.AddPeers(peersToAdd.ToArray(), IPAddress.Loopback);
//These peers were all discovered from in the last 24 hours
for (int i = 1; i <= 3; i++)
{
IPAddress ipAddress = IPAddress.Parse(string.Format("::ffff:192.168.0.{0}", i));
peerAddressManager.PeerDiscoveredFrom(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddHours(-5));
}
//These peers were all discovered from more than 24 hours ago
for (int i = 4; i <= 5; i++)
{
IPAddress ipAddress = IPAddress.Parse(string.Format("::ffff:192.168.0.{0}", i));
peerAddressManager.PeerDiscoveredFrom(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddHours(-25));
}
IEnumerable <PeerAddress> peers = peerAddressManager.PeerSelector.SelectPeersForDiscovery(5);
Assert.Equal(2, peers.Count());
}
private bool ConnectToPeer(PeerAddressManager peerAddressManager, Mock <INetworkPeerFactory> networkPeerFactoryExisting, ConnectionManagerSettings connectionManagerSettingsExisting, PeerConnector peerConnector, IPEndPoint endpointNode, Mock <IConnectionManager> mockConnectionManager)
{
peerAddressManager.AddPeer(endpointNode, IPAddress.Loopback);
var networkPeer = new Mock <INetworkPeer>();
networkPeer.SetupGet(np => np.PeerEndPoint).Returns(new IPEndPoint(endpointNode.Address, endpointNode.Port));
networkPeer.SetupGet(np => np.RemoteSocketAddress).Returns(endpointNode.Address);
networkPeer.SetupGet(np => np.RemoteSocketPort).Returns(endpointNode.Port);
networkPeer.SetupGet(np => np.State).Returns(NetworkPeerState.HandShaked);
networkPeerFactoryExisting.Setup(npf =>
npf.CreateConnectedNetworkPeerAsync(It.Is <IPEndPoint>(x => Equals(x, endpointNode)),
It.IsAny <NetworkPeerConnectionParameters>(), It.IsAny <NetworkPeerDisposer>())).Returns(Task.FromResult(networkPeer.Object));
var connectedPeers = (NetworkPeerCollection)mockConnectionManager.Object.ConnectedPeers;
foreach (INetworkPeer peer in peerConnector.ConnectorPeers)
{
if (!connectedPeers.Contains(peer))
{
connectedPeers.Add(peer);
}
}
mockConnectionManager.SetupGet(np => np.ConnectedPeers).Returns(connectedPeers);
peerConnector.Initialize(mockConnectionManager.Object);
peerConnector.OnConnectAsync().GetAwaiter().GetResult();
return(peerConnector.ConnectorPeers.Select(p => p.PeerEndPoint).Contains(endpointNode));
}
public void PeerState_TestReturnFromPeerHandshakedSet_IgnoringBanned()
{
IPAddress ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endPointOne = new IPEndPoint(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.2");
var endPointTwo = new IPEndPoint(ipAddress, 80);
DataFolder peerFolder = CreateDataFolder(this);
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.extendedLoggerFactory,
new SelfEndpointTracker(this.extendedLoggerFactory, this.connectionManagerSettings));
peerAddressManager.AddPeer(endPointOne, IPAddress.Loopback);
peerAddressManager.AddPeer(endPointTwo, IPAddress.Loopback);
peerAddressManager.FindPeer(endPointTwo).BanUntil = DateTime.UtcNow.AddMinutes(1);
peerAddressManager.PeerConnected(endPointOne, DateTime.UtcNow.AddSeconds(-80));
peerAddressManager.PeerHandshaked(endPointOne, DateTime.UtcNow.AddSeconds(-80));
peerAddressManager.PeerConnected(endPointTwo, DateTime.UtcNow.AddSeconds(-80));
peerAddressManager.PeerHandshaked(endPointTwo, DateTime.UtcNow.AddSeconds(-80));
IEnumerable <PeerAddress> peers = peerAddressManager.PeerSelector.Handshaked();
Assert.Single(peers);
Assert.Contains(peers, p => p.Endpoint.Match(endPointOne));
}
private IPeerAddressManager CreateTestPeerAddressManager(List <Tuple <IPEndPoint, DateTimeOffset> > testDataSet)
{
var peers = new ConcurrentDictionary <IPEndPoint, PeerAddress>();
string dataFolderDirectory = Path.Combine(AppContext.BaseDirectory, "WhitelistTests");
if (Directory.Exists(dataFolderDirectory))
{
Directory.Delete(dataFolderDirectory, true);
}
Directory.CreateDirectory(dataFolderDirectory);
var peerFolder = new DataFolder(new NodeSettings(args: new string[] { $"-datadir={dataFolderDirectory}" }).DataDir);
Mock <ILogger> mockLogger = new Mock <ILogger>();
Mock <ILoggerFactory> mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
IPeerAddressManager peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, loggerFactory);
foreach (Tuple <IPEndPoint, DateTimeOffset> testData in testDataSet)
{
peerAddressManager.AddPeer(testData.Item1, IPAddress.Loopback);
peerAddressManager.PeerSeen(testData.Item1, testData.Item2.DateTime);
}
return(peerAddressManager);
}
public void PeerSelector_ReturnConnectedPeers_AfterHandshakeFailure_HandshakeSucceeded_ResetsCounters()
{
IPAddress ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
DataFolder peerFolder = CreateDataFolder(this);
PeerAddressManager peerAddressManager = this.CreatePeerAddressManager(peerFolder);
peerAddressManager.AddPeer(new IPEndPoint(ipAddress, 80), IPAddress.Loopback);
peerAddressManager.PeerConnected(new IPEndPoint(ipAddress, 80), DateTime.UtcNow.AddSeconds(-80));
DateTime handshakeAttempt = DateTime.UtcNow.AddSeconds(-80);
PeerAddress peer = peerAddressManager.Peers.First();
// Peer selected after one handshake failure.
peer.SetHandshakeAttempted(handshakeAttempt);
Assert.Equal(1, peer.HandshakedAttempts);
Assert.Contains(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
// Peer selected after two handshake failures.
peer.SetHandshakeAttempted(handshakeAttempt);
Assert.Equal(2, peer.HandshakedAttempts);
Assert.Contains(peer, peerAddressManager.PeerSelector.FilterBadHandshakedPeers(peerAddressManager.Peers));
// Peer attempt counter and last attempt reset after successful handshake.
peer.SetHandshaked(handshakeAttempt);
Assert.Equal(0, peer.HandshakedAttempts);
Assert.Null(peer.LastHandshakeAttempt);
}
private IPeerAddressManager CreateTestPeerAddressManager(List <Tuple <NetworkAddress, DateTimeOffset> > testDataSet)
{
ConcurrentDictionary <IPEndPoint, PeerAddress> peers = new ConcurrentDictionary <IPEndPoint, PeerAddress>();
string dataFolderDirectory = Path.Combine(AppContext.BaseDirectory, "WhitelistTests");
if (Directory.Exists(dataFolderDirectory))
{
Directory.Delete(dataFolderDirectory, true);
}
Directory.CreateDirectory(dataFolderDirectory);
var peerFolder = new DataFolder(new NodeSettings {
DataDir = dataFolderDirectory
});
Mock <ILogger> mockLogger = new Mock <ILogger>();
Mock <ILoggerFactory> mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
IPeerAddressManager peerAddressManager = new PeerAddressManager(peerFolder, loggerFactory);
foreach (Tuple <NetworkAddress, DateTimeOffset> testData in testDataSet)
{
peerAddressManager.AddPeer(testData.Item1, IPAddress.Loopback);
peerAddressManager.PeerHandshaked(testData.Item1.Endpoint, testData.Item2);
}
return(peerAddressManager);
}
private PeerAddressManager CreatePeerAddressManager(DataFolder peerFolder)
{
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.extendedLoggerFactory,
new SelfEndpointTracker(this.extendedLoggerFactory, this.connectionManagerSettings));
return(peerAddressManager);
}
public void PeerFile_CanSaveAndLoadPeers_PeerSeen()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endpoint = new IPEndPoint(ipAddress, 80);
var peerFolder = CreateDataFolder(this);
var addressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.LoggerFactory.Object, new SelfEndpointTracker());
addressManager.AddPeer(endpoint, IPAddress.Loopback);
var applicableDate = DateTime.UtcNow.Date;
addressManager.PeerAttempted(endpoint, applicableDate);
addressManager.PeerConnected(endpoint, applicableDate);
addressManager.PeerHandshaked(endpoint, applicableDate);
addressManager.PeerSeen(endpoint, applicableDate);
addressManager.SavePeers();
addressManager.LoadPeers();
var savedPeer = addressManager.FindPeer(endpoint);
Assert.Equal("::ffff:192.168.0.1", savedPeer.Endpoint.Address.ToString());
Assert.Equal(80, savedPeer.Endpoint.Port);
Assert.Equal(0, savedPeer.ConnectionAttempts);
Assert.Equal(applicableDate, savedPeer.LastConnectionSuccess.Value.Date);
Assert.Equal(applicableDate, savedPeer.LastConnectionHandshake.Value.Date);
Assert.Equal(applicableDate, savedPeer.LastSeen.Value.Date);
Assert.Equal("127.0.0.1", savedPeer.Loopback.ToString());
}
public void PeerBanning_Add_Peer_To_Address_Manager_And_Ban()
{
var dataFolder = CreateDataFolder(this);
var loggerFactory = ExtendedLoggerFactory.Create();
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endpoint = new IPEndPoint(ipAddress, 80);
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, dataFolder, loggerFactory, new Mock <ISelfEndpointTracker>().Object);
peerAddressManager.AddPeer(endpoint, endpoint.Address.MapToIPv6());
var nodeSettings = new NodeSettings(new StratisRegTest());
var connectionManagerSettings = new ConnectionManagerSettings(nodeSettings);
var peerCollection = new Mock <IReadOnlyNetworkPeerCollection>();
peerCollection.Setup(p => p.FindByIp(It.IsAny <IPAddress>())).Returns(new List <INetworkPeer>());
var connectionManager = new Mock <IConnectionManager>();
connectionManager.Setup(c => c.ConnectionSettings).Returns(connectionManagerSettings);
connectionManager.Setup(c => c.ConnectedPeers).Returns(peerCollection.Object);
var peerBanning = new PeerBanning(connectionManager.Object, loggerFactory, DateTimeProvider.Default, peerAddressManager);
peerBanning.BanAndDisconnectPeer(endpoint, connectionManagerSettings.BanTimeSeconds, nameof(PeerBanningTest));
PeerAddress peer = peerAddressManager.FindPeer(endpoint);
Assert.True(peer.BanUntil.HasValue);
Assert.NotNull(peer.BanUntil);
Assert.NotEmpty(peer.BanReason);
}
public void PeerConnectorConnect_FindPeerToConnectTo_Returns_ConnectNodePeers()
{
var peerAddressManager = new PeerAddressManager();
var ipAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
var networkAddressAddNode = new NetworkAddress(ipAddressOne, 80);
var ipAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
var networkAddressDiscoverNode = new NetworkAddress(ipAddressTwo, 80);
var ipAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var networkAddressConnectNode = new NetworkAddress(ipAddressThree, 80);
peerAddressManager.AddPeer(networkAddressAddNode, IPAddress.Loopback);
peerAddressManager.AddPeer(networkAddressConnectNode, IPAddress.Loopback);
peerAddressManager.AddPeer(networkAddressDiscoverNode, IPAddress.Loopback);
var nodeSettings = new NodeSettings
{
ConnectionManager = new Configuration.Settings.ConnectionManagerSettings()
};
nodeSettings.ConnectionManager.Connect.Add(networkAddressConnectNode.Endpoint);
var connector = this.CreatePeerConnectorConnectNode(nodeSettings, peerAddressManager);
var peer = connector.FindPeerToConnectTo();
Assert.Equal(networkAddressConnectNode.Endpoint, peer.Endpoint);
}
public void PeerAddressManager_AttemptThresholdTimeNotReached_DoNotReset()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endpoint = new IPEndPoint(ipAddress, 80);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var addressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.loggerFactory);
addressManager.AddPeer(endpoint, IPAddress.Loopback);
var applicableDate = DateTimeProvider.Default.GetUtcNow();
//Ensure that there was 10 failed attempts
for (int i = 0; i < 10; i++)
{
addressManager.PeerAttempted(endpoint, applicableDate.AddHours(-i));
}
//Capture the last attempt timestamp
var lastAttempt = DateTimeProvider.Default.GetUtcNow();
addressManager.PeerAttempted(endpoint, lastAttempt);
var savedPeer = addressManager.FindPeer(endpoint);
Assert.Equal(11, savedPeer.ConnectionAttempts);
Assert.Equal(lastAttempt, savedPeer.LastAttempt);
Assert.Null(savedPeer.LastConnectionSuccess);
Assert.Null(savedPeer.LastConnectionHandshake);
Assert.Null(savedPeer.LastSeen);
Assert.Equal("127.0.0.1", savedPeer.Loopback.ToString());
}
public void CanSelectRandomPeerToConnectTo_AllPeersAreNew()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var addressOne = new NetworkAddress(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.2");
var addressTwo = new NetworkAddress(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.3");
var addressThree = new NetworkAddress(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.4");
var addressFour = new NetworkAddress(ipAddress, 80);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var addressManager = new PeerAddressManager(peerFolder);
addressManager.AddPeer(addressOne, IPAddress.Loopback);
addressManager.AddPeer(addressTwo, IPAddress.Loopback);
addressManager.AddPeer(addressThree, IPAddress.Loopback);
addressManager.AddPeer(addressFour, IPAddress.Loopback);
var randomPeer = addressManager.SelectPeerToConnectTo();
addressManager.PeerAttempted(randomPeer.Endpoint, DateTime.UtcNow);
var selected = addressManager.Peers.New().FirstOrDefault(p => p.NetworkAddress.Endpoint.Match(randomPeer.Endpoint));
Assert.Null(selected);
}
