public NodeServerTester(Network network = null)
{
int retry = 0;
network = network ?? Network.TestNet;
while(true)
{
try
{
var a = _Rand.Next(4000, 60000);
var b = _Rand.Next(4000, 60000);
_Server1 = new NodeServer(network, internalPort: a);
_Server1.AllowLocalPeers = true;
_Server1.ExternalEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1").MapToIPv6Ex(), a);
_Server1.Listen();
_Server2 = new NodeServer(network, internalPort: b);
_Server2.AllowLocalPeers = true;
_Server2.ExternalEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1").MapToIPv6Ex(), b);
_Server2.Listen();
break;
}
catch(Exception)
{
if(_Server1 != null)
_Server1.Dispose();
if(_Server2 != null)
_Server2.Dispose();
retry++;
if(retry == 5)
throw;
}
}
}
public NodeServerTester()
{
_Server1 = new NodeServer(Network.Main, internalPort: 3390);
_Server1.AllowLocalPeers = true;
_Server1.ExternalEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1").MapToIPv6(), 3390);
_Server1.NATRuleName = NATRuleName;
_Server1.Listen();
_Server2 = new NodeServer(Network.Main, internalPort: 3391);
_Server2.AllowLocalPeers = true;
_Server2.NATRuleName = NATRuleName;
_Server2.ExternalEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1").MapToIPv6(), 3391);
_Server2.Listen();
}
public NodeServerTester(Network network = null)
{
network = network ?? Network.TestNet;
var a = _Rand.Next(4000, 60000);
var b = _Rand.Next(4000, 60000);
_Server1 = new NodeServer(network, internalPort: a);
_Server1.AllowLocalPeers = true;
_Server1.ExternalEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1").MapToIPv6(), a);
_Server1.Listen();
_Server2 = new NodeServer(network, internalPort: b);
_Server2.AllowLocalPeers = true;
_Server2.ExternalEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1").MapToIPv6(), b);
_Server2.Listen();
}
public void VersionHandshake(CancellationToken cancellationToken = default(CancellationToken))
{
var listener = new PollMessageListener <IncomingMessage>();
using (MessageProducer.AddMessageListener(listener))
{
using (TraceCorrelation.Open())
{
var myVersion = CreateVersionPayload();
SendMessage(myVersion);
var version = listener.RecieveMessage(cancellationToken).AssertPayload <VersionPayload>();
_FullVersion = version;
Version = version.Version;
if (version.Nonce == NodeServer.Nonce)
{
NodeServerTrace.ConnectionToSelfDetected();
Disconnect();
throw new InvalidOperationException("Impossible to connect to self");
}
if (!version.AddressReciever.Address.Equals(ExternalEndpoint.Address))
{
NodeServerTrace.Warning("Different external address detected by the node " + version.AddressReciever.Address + " instead of " + ExternalEndpoint.Address);
}
NodeServer.ExternalAddressDetected(version.AddressReciever.Address);
if (version.Version < ProtocolVersion.MIN_PEER_PROTO_VERSION)
{
NodeServerTrace.Warning("Outdated version " + version.Version + " disconnecting");
Disconnect();
return;
}
SendMessage(new VerAckPayload());
listener.RecieveMessage(cancellationToken).AssertPayload <VerAckPayload>();
State = NodeState.HandShaked;
if (NodeServer.AdvertizeMyself)
{
AdvertiseMyself();
}
}
}
}
internal Node(Peer peer, NodeServer nodeServer, CancellationToken cancellation)
{
Version = nodeServer.Version;
_NodeServer = nodeServer;
_Peer = peer;
LastSeen = peer.NetworkAddress.Time;
var socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
_Connection = new NodeConnection(this, socket);
using (TraceCorrelation.Open())
{
try
{
var ar = socket.BeginConnect(Peer.NetworkAddress.Endpoint, null, null);
WaitHandle.WaitAny(new WaitHandle[] { ar.AsyncWaitHandle, cancellation.WaitHandle });
cancellation.ThrowIfCancellationRequested();
socket.EndConnect(ar);
State = NodeState.Connected;
NodeServerTrace.Information("Outbound connection successfull");
}
catch (OperationCanceledException)
{
Utils.SafeCloseSocket(socket);
NodeServerTrace.Information("Connection to node cancelled");
State = NodeState.Offline;
return;
}
catch (Exception ex)
{
Utils.SafeCloseSocket(socket);
NodeServerTrace.Error("Error connecting to the remote endpoint ", ex);
State = NodeState.Failed;
throw;
}
_Connection.BeginListen();
}
}
private VersionPayload CreateVersionPayload()
{
return(NodeServer.CreateVersionPayload(Peer, ExternalEndpoint, Version));
}
public void CanGetMyIp()
{
var client = new NodeServer(Network.Main, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(client.GetMyExternalIP() != null);
}
internal MiniNode CreateLocalNode()
{
NodeServer nodeServer = new NodeServer(Client.Configuration.Network, internalPort: (ushort)RandomUtils.GetInt32());
nodeServer.Listen();
_NodeServer = nodeServer;
Indexer.Configuration.Node = "127.0.0.1:" + nodeServer.LocalEndpoint.Port;
return new MiniNode(this, nodeServer);
}
public void CanUseUPNP()
{
UPnPLease lease = null;
UPnPLease.ReleaseAll(NodeServerTester.NATRuleName); //Clean the gateway of previous tests attempt
using(var server = new NodeServer(Network.Main))
{
server.NATRuleName = NodeServerTester.NATRuleName;
Assert.False(server.ExternalEndpoint.Address.IsRoutable(false));
lease = server.DetectExternalEndpoint();
Assert.True(server.ExternalEndpoint.Address.IsRoutable(false));
Assert.NotNull(lease);
Assert.True(lease.IsOpen());
lease.Dispose();
Assert.False(lease.IsOpen());
lease = server.DetectExternalEndpoint();
Assert.NotNull(lease);
Assert.True(lease.IsOpen());
}
Assert.False(lease.IsOpen());
}
public void CanHandshake()
{
using(var server = new NodeServer(Network.Main, ProtocolVersion.PROTOCOL_VERSION))
{
var seed = server.GetNodeByHostName("seed.bitcoin.sipa.be");
Assert.True(seed.State == NodeState.Connected);
seed.VersionHandshake();
Assert.True(seed.State == NodeState.HandShaked);
seed.Disconnect();
Assert.True(seed.State == NodeState.Offline);
}
}
public void CanDownloadChain()
{
using(var server = new NodeServer(Network.Main))
{
server.RegisterPeerTableRepository(PeerCache);
CancellationTokenSource cancel = new CancellationTokenSource();
StreamObjectStream<ChainChange> changes = new StreamObjectStream<ChainChange>(new MemoryStream());
var chain = new Chain(changes);
server.BuildChain(changes, cancel.Token);
}
}
public void CanDiscoverPeers()
{
using(var server = new NodeServer(Network.Main, ProtocolVersion.PROTOCOL_VERSION))
{
Assert.True(server.PeerTable.CountUsed(true) < 50);
server.DiscoverPeers(100);
Assert.True(server.PeerTable.CountUsed(true) > 50);
}
}
public void CanConnectToNodeSet()
{
using(var server = new NodeServer(Network.Main))
{
server.RegisterPeerTableRepository(PeerCache);
var set = server.CreateNodeSet(5);
Assert.Equal(5, set.GetNodes().Length);
foreach(var node in set.GetNodes())
{
Assert.Equal(NodeState.HandShaked, node.State);
}
}
}
