private async Task <bool> StartConnecting()
{
return(await Task <bool> .Factory.StartNew(() =>
{
try
{
NodeConnectionParameters parameters = new NodeConnectionParameters();
//So we find nodes faster
parameters.TemplateBehaviors.Add(new AddressManagerBehavior(GetAddressManager()));
//So we don't have to load the chain each time we start
parameters.TemplateBehaviors.Add(new ChainBehavior(GetChain()));
//Tracker knows which scriptPubKey and outpoints to track
parameters.TemplateBehaviors.Add(new TrackerBehavior(GetTracker()));
var nodeReq = new NodeRequirement()
{
RequiredServices = NodeServices.Network
};
_group = new NodesGroup(_wallet.NetworkChoice, parameters, nodeReq);
_group.MaximumNodeConnection = MAX_NUM_CONNECTIONS;
_group.Connect();
_connectionparameters = parameters;
return true;
}
catch (Exception e)
{
throw e;
}
}));
}
public KnoledgeNodesGroup(
Network network,
NodeConnectionParameters connectionParameters = null,
NodeRequirement requirements = null)
: base(network, connectionParameters, requirements)
{
}
private async void StartConnecting()
{
await Task.Factory.StartNew(() =>
{
NodeConnectionParameters parameters = new NodeConnectionParameters();
//So we find nodes faster
parameters.TemplateBehaviors.Add(new AddressManagerBehavior(this.GetAddressManager()));
//So we don't have to load the chain each time we start
parameters.TemplateBehaviors.Add(new ChainBehavior(this.GetChain()));
//Tracker knows which scriptPubKey and outpoints to track
parameters.TemplateBehaviors.Add(new TrackerBehavior(this.GetTracker()));
var nodeReq = new NodeRequirement()
{
RequiredServices = NodeServices.Network
};
_group = new NodesGroup(_wallet.NetworkChoice, parameters, nodeReq);
_group.MaximumNodeConnection = MAX_NUM_CONNECTIONS;
_group.Connect();
_connectionparameters = parameters;
});
_wallet.Configure(_group);
_wallet.Connect();
_wallet.Connected = true;
PeriodicKick();
PeriodicSave();
}
protected BlockPuller(ConcurrentChain chain, IReadOnlyNodesCollection nodes, ProtocolVersion protocolVersion)
{
this.Chain = chain;
this.Nodes = nodes;
this.DownloadedBlocks = new ConcurrentDictionary <uint256, DownloadedBlock>();
this.pendingInventoryVectors = new ConcurrentBag <uint256>();
this.map = new ConcurrentDictionary <uint256, BlockPullerBehavior>();
// set the default requirements
this.requirements = new NodeRequirement
{
MinVersion = protocolVersion,
RequiredServices = NodeServices.Network
};
}
public NodesGroup(
Network network,
NodeConnectionParameters connectionParameters = null,
NodeRequirement requirements = null)
{
AllowSameGroup = false;
MaximumNodeConnection = 8;
_Network = network;
cs = new object();
_ConnectedNodes = new NodesCollection();
_ConnectionParameters = connectionParameters ?? new NodeConnectionParameters();
_ConnectionParameters = _ConnectionParameters.Clone();
_Requirements = requirements ?? new NodeRequirement();
_Disconnect = new CancellationTokenSource();
}
public NodesGroup(
Network network,
NodeConnectionParameters connectionParameters = null,
NodeRequirement requirements = null)
{
AllowSameGroup = false;
MaximumNodeConnection = 8;
_network = network;
_cs = new object();
ConnectedNodes = new NodesCollection();
NodeConnectionParameters = connectionParameters ?? new NodeConnectionParameters();
NodeConnectionParameters = NodeConnectionParameters.Clone();
Requirements = requirements ?? new NodeRequirement();
_disconnect = new CancellationTokenSource();
}
public void VersionHandshake(NodeRequirement requirements, CancellationToken cancellationToken = default(CancellationToken))
{
requirements = requirements ?? new NodeRequirement();
using (var listener = CreateListener()
.Where(p => p.Message.Payload is Version ||
p.Message.Payload is RejectPayload ||
p.Message.Payload is VerAckPayload))
{
SendMessageAsync(MyVersion);
var payload = listener.ReceivePayload <Payload>(cancellationToken);
if (payload is RejectPayload)
{
throw new ProtocolException("Handshake rejected : " + ((RejectPayload)payload).Reason);
}
var version = (VersionPayload)payload;
_PeerVersion = version;
SetVersion(Math.Min(MyVersion.Version, version.Version));
if (!version.AddressReceiver.Address.Equals(MyVersion.AddressFrom.Address))
{
Logs.NodeServer.LogWarning("Different external address detected by the node {addressReceiver} instead of {addressFrom}", version.AddressReceiver.Address, MyVersion.AddressFrom.Address);
}
if (ProtocolCapabilities.PeerTooOld)
{
Logs.NodeServer.LogWarning("Outdated version {version} disconnecting", version.Version);
Disconnect("Outdated version");
return;
}
if (!requirements.Check(version, ProtocolCapabilities))
{
Disconnect("The peer does not support the required services requirement");
return;
}
SendMessageAsync(new VerAckPayload());
listener.ReceivePayload <VerAckPayload>(cancellationToken);
State = NodeState.HandShaked;
if (Advertize && MyVersion.AddressFrom.Address.IsRoutable(true))
{
SendMessageAsync(new AddrPayload(new NetworkAddress(MyVersion.AddressFrom)
{
Time = DateTimeOffset.UtcNow
}));
}
}
}
/// <summary>
/// Initializes a new instance of the object having a chain of block headers and a list of available nodes.
/// </summary>
/// <param name="chain">Chain of block headers.</param>
/// <param name="nodes">Network peers of the node.</param>
/// <param name="protocolVersion">Version of the protocol that the node supports.</param>
/// <param name="loggerFactory">Factory to be used to create logger for the puller.</param>
protected BlockPuller(ConcurrentChain chain, IReadOnlyNodesCollection nodes, ProtocolVersion protocolVersion, ILoggerFactory loggerFactory)
{
this.Chain = chain;
this.Nodes = nodes;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.downloadedBlocks = new Dictionary <uint256, DownloadedBlock>();
this.pendingInventoryVectors = new Queue <uint256>();
this.assignedBlockTasks = new Dictionary <uint256, BlockPullerBehavior>();
this.peerQuality = new QualityScore(QualityScoreHistoryLength, loggerFactory);
// Set the default requirements.
this.requirements = new NodeRequirement
{
MinVersion = protocolVersion,
RequiredServices = NodeServices.Network
};
}
private IPeerConnector CreatePeerConnector(
NodeConnectionParameters parameters,
NodeServices requiredServices,
Func <IPEndPoint, byte[]> peerSelector,
PeerIntroductionType peerIntroductionType,
int?maximumNodeConnections = 8)
{
this.logger.LogTrace("({0}:{1})", nameof(requiredServices), requiredServices);
var nodeRequirement = new NodeRequirement
{
MinVersion = this.NodeSettings.ProtocolVersion,
RequiredServices = requiredServices,
};
var peerConnector = new PeerConnector(this.Network, this.nodeLifetime, parameters, nodeRequirement, peerSelector, this.asyncLoopFactory, this.peerAddressManager, peerIntroductionType)
{
MaximumNodeConnections = maximumNodeConnections.Value
};
this.logger.LogTrace("(-)");
return(peerConnector);
}
/// <summary>Constructor used by dependency injection.</summary>
internal PeerConnector(Network network,
INodeLifetime nodeLifeTime,
NodeConnectionParameters parameters,
NodeRequirement nodeRequirements,
Func <IPEndPoint, byte[]> groupSelector,
IAsyncLoopFactory asyncLoopFactory,
IPeerAddressManager peerAddressManager,
PeerIntroductionType peerIntroductionType)
{
this.asyncLoopFactory = asyncLoopFactory;
this.ConnectedPeers = new NodesCollection();
this.groupSelector = groupSelector;
this.MaximumNodeConnections = 8;
this.network = network;
this.nodeLifetime = nodeLifeTime;
this.parentParameters = parameters;
this.peerAddressManager = peerAddressManager;
this.peerIntroductionType = peerIntroductionType;
this.Requirements = nodeRequirements;
this.currentParameters = this.parentParameters.Clone();
this.currentParameters.TemplateBehaviors.Add(new PeerConnectorBehaviour(this));
this.currentParameters.ConnectCancellation = this.nodeLifetime.ApplicationStopping;
}
public void CanHandshakeRestrictNodes()
{
using (var builder = NodeBuilderEx.Create())
{
var node = builder.CreateNode(true);
var manager = new AddressManager();
manager.Add(new NetworkAddress(node.NodeEndpoint), IPAddress.Loopback);
var nodesRequirement = new NodeRequirement()
{
MinStartHeight = 100
};
var nodeConnectionParameters = new NodeConnectionParameters()
{
TemplateBehaviors =
{
new AddressManagerBehavior(manager)
{
PeersToDiscover = 1,
Mode = AddressManagerBehaviorMode.None
}
}
};
var group = new NodesGroup(builder.Network, nodeConnectionParameters, nodesRequirement);
group.AllowSameGroup = true;
var connecting = WaitConnected(group);
try
{
group.Connect();
connecting.GetAwaiter().GetResult();
}
catch (TaskCanceledException)
{
// It is expected because no node should connect.
Assert.Empty(group.ConnectedNodes); // but we chack it anyway.
}
finally
{
group.Disconnect();
}
node.Generate(101);
group = new NodesGroup(builder.Network, nodeConnectionParameters, nodesRequirement);
group.AllowSameGroup = true;
connecting = WaitConnected(group);
try
{
group.Connect();
connecting.GetAwaiter().GetResult();
Eventually(() =>
{
Assert.NotEmpty(group.ConnectedNodes);
Assert.All(group.ConnectedNodes, connectedNode =>
Assert.True(connectedNode.RemoteSocketEndpoint.IsEqualTo(node.NodeEndpoint)));
});
}
finally
{
group.Disconnect();
}
}
}
