public void PeerAddressManagerBehaviour_InboundConnectionIsLoopBack_Add_PeerEndPoint_ToAddressBook()
{
var addressFromEndpoint = new IPEndPoint(IPAddress.Loopback, this.Network.DefaultPort);
IPAddress peerEndPointAddress = IPAddress.Parse("::ffff:192.168.0.1");
var peerEndPoint = new IPEndPoint(peerEndPointAddress, 80);
DataFolder peerFolder = CreateDataFolder(this);
var addressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.LoggerFactory.Object, new SelfEndpointTracker(this.extendedLoggerFactory));
var networkPeer = new Mock <INetworkPeer>();
networkPeer.SetupGet(n => n.Inbound).Returns(true);
networkPeer.SetupGet(n => n.Network).Returns(this.Network);
networkPeer.SetupGet(n => n.PeerEndPoint).Returns(peerEndPoint);
networkPeer.SetupGet(n => n.PeerVersion).Returns(new VersionPayload()
{
AddressFrom = addressFromEndpoint
});
networkPeer.SetupGet(n => n.State).Returns(NetworkPeerState.HandShaked);
var messageReceived = new AsyncExecutionEvent <INetworkPeer, IncomingMessage>();
networkPeer.SetupGet(n => n.MessageReceived).Returns(messageReceived);
var stateChanged = new AsyncExecutionEvent <INetworkPeer, NetworkPeerState>();
networkPeer.SetupGet(n => n.StateChanged).Returns(stateChanged);
var behaviour = new PeerAddressManagerBehaviour(DateTimeProvider.Default, addressManager, new Mock <IPeerBanning>().Object, this.extendedLoggerFactory)
{
Mode = PeerAddressManagerBehaviourMode.AdvertiseDiscover
};
behaviour.Attach(networkPeer.Object);
// Trigger the event handler that signals that the peer has handshaked.
networkPeer.Object.StateChanged.ExecuteCallbacksAsync(networkPeer.Object, NetworkPeerState.HandShaked).GetAwaiter().GetResult();
// The address manager should contain the inbound peer's address.
var endpointToFind = new IPEndPoint(peerEndPoint.Address, this.Network.DefaultPort);
Assert.NotNull(addressManager.FindPeer(endpointToFind));
}
public void PeerAddressManagerBehaviour_DoesntSendAddress_Outbound()
{
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.extendedLoggerFactory, this.connectionManagerSettings));
addressManager.AddPeer(endpoint, IPAddress.Loopback);
var networkPeer = new Mock <INetworkPeer>();
networkPeer.SetupGet(n => n.PeerEndPoint).Returns(endpoint);
networkPeer.SetupGet(n => n.State).Returns(NetworkPeerState.HandShaked);
networkPeer.SetupGet(n => n.Inbound).Returns(false); // Outbound
var messageReceived = new AsyncExecutionEvent <INetworkPeer, IncomingMessage>();
networkPeer.SetupGet(n => n.MessageReceived).Returns(messageReceived);
var stateChanged = new AsyncExecutionEvent <INetworkPeer, NetworkPeerState>();
networkPeer.SetupGet(n => n.StateChanged).Returns(stateChanged);
var behaviour = new PeerAddressManagerBehaviour(DateTimeProvider.Default, addressManager, new Mock <IPeerBanning>().Object, this.extendedLoggerFactory)
{
Mode = PeerAddressManagerBehaviourMode.AdvertiseDiscover
};
behaviour.Attach(networkPeer.Object);
var incomingMessage = new IncomingMessage();
incomingMessage.Message = new Message(new PayloadProvider().DiscoverPayloads())
{
Magic = this.Network.Magic,
Payload = new GetAddrPayload(),
};
// Event handler triggered, but SendMessage shouldn't be called as the node is Outbound.
networkPeer.Object.MessageReceived.ExecuteCallbacksAsync(networkPeer.Object, incomingMessage).GetAwaiter().GetResult();
networkPeer.Verify(x => x.SendMessageAsync(It.IsAny <Payload>(), It.IsAny <CancellationToken>()), Times.Never);
}
/// <summary>
/// Initializes parts of the object that are common for both inbound and outbound peers.
/// </summary>
/// <param name="inbound"><c>true</c> for inbound peers, <c>false</c> for outbound peers.</param>
/// <param name="peerEndPoint">IP address and port on the side of the peer.</param>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="parameters">Various settings and requirements related to how the connections with peers are going to be established, or <c>null</c> to use default parameters.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
private NetworkPeer(bool inbound, IPEndPoint peerEndPoint, Network network, NetworkPeerConnectionParameters parameters, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory)
{
this.loggerFactory = loggerFactory;
this.dateTimeProvider = dateTimeProvider;
this.preferredTransactionOptions = network.NetworkOptions;
this.SupportedTransactionOptions = network.NetworkOptions & ~NetworkOptions.All;
this.State = NetworkPeerState.Offline;
this.Inbound = inbound;
this.PeerEndPoint = peerEndPoint;
this.Network = network;
this.Behaviors = new NetworkPeerBehaviorsCollection(this);
this.Parameters = parameters ?? new NetworkPeerConnectionParameters();
this.MyVersion = this.Parameters.CreateVersion(this.PeerEndPoint, network, this.dateTimeProvider.GetTimeOffset());
this.MessageReceived = new AsyncExecutionEvent <NetworkPeer, IncomingMessage>();
this.StateChanged = new AsyncExecutionEvent <NetworkPeer, NetworkPeerState>();
}
public void PeerAddressManagerBehaviour_ReceivedPong_UpdateLastSeen()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var endpoint = new IPEndPoint(ipAddress, 80);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManagerBehaviourTests"));
var addressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.loggerFactory);
addressManager.AddPeer(endpoint, IPAddress.Loopback);
var networkPeer = new Mock <INetworkPeer>();
networkPeer.SetupGet(n => n.PeerEndPoint).Returns(endpoint);
networkPeer.SetupGet(n => n.State).Returns(NetworkPeerState.HandShaked);
var messageReceived = new AsyncExecutionEvent <INetworkPeer, IncomingMessage>();
networkPeer.SetupGet(n => n.MessageReceived).Returns(messageReceived);
var stateChanged = new AsyncExecutionEvent <INetworkPeer, NetworkPeerState>();
networkPeer.SetupGet(n => n.StateChanged).Returns(stateChanged);
var behaviour = new PeerAddressManagerBehaviour(DateTimeProvider.Default, addressManager)
{
Mode = PeerAddressManagerBehaviourMode.AdvertiseDiscover
};
behaviour.Attach(networkPeer.Object);
var message = new IncomingMessage(new PongPayload(), this.network);
//Trigger the event handler
networkPeer.Object.MessageReceived.ExecuteCallbacksAsync(networkPeer.Object, message).GetAwaiter().GetResult();
var peer = addressManager.FindPeer(endpoint);
Assert.Equal(DateTimeProvider.Default.GetUtcNow().Date, peer.LastSeen.Value.Date);
}
public async Task AsyncExecutionEvent_CanUnregisterFromCallback_Async()
{
using (var executionEvent = new AsyncExecutionEvent <object, object>())
{
int value = 0;
Task callback1Async(object sender, object arg)
{
value++;
// Try to unregister itself.
executionEvent.Unregister(callback1Async);
return(Task.CompletedTask);
}
async Task callback2Async(object sender, object arg)
{
value++;
// Try to unregister itself, but first await a bit.
await Task.Delay(20);
executionEvent.Unregister(callback2Async);
}
executionEvent.Register(callback1Async);
executionEvent.Register(callback2Async);
// First execution should increment the value twice and unregister the callbacks.
await executionEvent.ExecuteCallbacksAsync(null, null);
Assert.Equal(2, value);
// Second execution should do nothing as there should be no registered callbacks.
await executionEvent.ExecuteCallbacksAsync(null, null);
Assert.Equal(2, value);
}
}
private Mock <INetworkPeer> CreatePeerMock()
{
var peer = new Mock <INetworkPeer>();
var signals = new Bitcoin.Signals.Signals(this.loggerFactory, null);
var asyncProvider = new AsyncProvider(this.loggerFactory, signals, new NodeLifetime());
var connection = new NetworkPeerConnection(KnownNetworks.StraxMain, peer.Object, new TcpClient(), 0, (message, token) => Task.CompletedTask,
new DateTimeProvider(), this.loggerFactory, new PayloadProvider(), asyncProvider);
peer.SetupGet(networkPeer => networkPeer.Connection).Returns(connection);
var connectionParameters = new NetworkPeerConnectionParameters();
VersionPayload version = connectionParameters.CreateVersion(new IPEndPoint(1, 1), new IPEndPoint(1, 1), KnownNetworks.StraxMain, new DateTimeProvider().GetTimeOffset());
version.Services = NetworkPeerServices.Network;
peer.SetupGet(x => x.PeerVersion).Returns(version);
peer.SetupGet(x => x.State).Returns(NetworkPeerState.HandShaked);
this.StateChanged = new AsyncExecutionEvent <INetworkPeer, NetworkPeerState>();
this.MessageReceived = new AsyncExecutionEvent <INetworkPeer, IncomingMessage>();
peer.Setup(x => x.StateChanged).Returns(() => this.StateChanged);
peer.Setup(x => x.MessageReceived).Returns(() => this.MessageReceived);
var connectionManagerBehaviorMock = new Mock <IConnectionManagerBehavior>();
connectionManagerBehaviorMock.Setup(x => x.Whitelisted).Returns(this.IsPeerWhitelisted);
peer.Setup(x => x.Behavior <IConnectionManagerBehavior>()).Returns(() => connectionManagerBehaviorMock.Object);
peer.SetupGet(x => x.PeerEndPoint).Returns(new IPEndPoint(1, 1));
return(peer);
}
