public ListenerTester(ServerTester tester, bool nodeOnly)
{
_Network = tester.Configuration.Indexer.Network;
Random rand = new Random();
_Server = tester;
_Server._disposables.Add(this);
_Listener = new QBitNinjaNodeListener(_Server.Configuration);
_NodeServer = new NodeServer(_Server.Configuration.Indexer.Network, internalPort: rand.Next(20000, 50000));
_NodeListener = new EventLoopMessageListener <IncomingMessage>(NewNodeMessage);
_NodeServer.ExternalEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), _NodeServer.LocalEndpoint.Port);
_NodeServer.AllowLocalPeers = true;
_NodeServer.InboundNodeConnectionParameters.IsRelay = true;
_NodeServer.AllMessages.AddMessageListener(_NodeListener);
_NodeServer.Listen();
_Listener.Configuration.Indexer.Node = "127.0.0.1:" + _NodeServer.LocalEndpoint.Port;
if (!nodeOnly)
{
_Listener.Listen();
}
_Server.Configuration.Indexer.CreateIndexer().Index(_Server.Configuration.Indexer.Network.GetGenesis());
_Server.ChainBuilder.SkipIndexer = true;
_Server.ChainBuilder.NewBlock += ChainBuilder_NewBlock;
_Server.ChainBuilder.NewTransaction += ChainBuilder_NewTransaction;
var genesis = _Server.Configuration.Indexer.Network.GetGenesis();
_Blocks.AddOrReplace(genesis.Header.GetHash(), genesis);
}
/// <summary>
/// Initializes instance of a network peer server.
/// </summary>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="version">Version of the network protocol that the server should run.</param>
/// <param name="internalPort">Port on which the server will listen, or -1 to use the default port for the selected network.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
/// <param name="networkPeerFactory">Factory for creating P2P network peers.</param>
public NetworkPeerServer(Network network, ProtocolVersion version, int internalPort, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory, INetworkPeerFactory networkPeerFactory)
{
internalPort = internalPort == -1 ? network.DefaultPort : internalPort;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName, $"[{internalPort}] ");
this.dateTimeProvider = dateTimeProvider;
this.networkPeerFactory = networkPeerFactory;
this.AllowLocalPeers = true;
this.InboundNetworkPeerConnectionParameters = new NetworkPeerConnectionParameters();
this.localEndpoint = new IPEndPoint(IPAddress.Parse("0.0.0.0").MapToIPv6Ex(), internalPort);
this.MaxConnections = 125;
this.Network = network;
this.externalEndpoint = new IPEndPoint(this.localEndpoint.Address, this.Network.DefaultPort);
this.Version = version;
var listener = new EventLoopMessageListener <IncomingMessage>(ProcessMessage);
this.messageProducer.AddMessageListener(listener);
this.OwnResource(listener);
this.ConnectedNetworkPeers = new NetworkPeerCollection();
this.ConnectedNetworkPeers.Added += Peers_PeerAdded;
this.ConnectedNetworkPeers.Removed += Peers_PeerRemoved;
this.ConnectedNetworkPeers.MessageProducer.AddMessageListener(listener);
this.AllMessages = new MessageProducer <IncomingMessage>();
this.trace = new TraceCorrelation(NodeServerTrace.Trace, "Network peer server listening on " + this.LocalEndpoint);
}
public NodeServer(Network network, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION, int internalPort = -1)
{
this.AllowLocalPeers = true;
this.InboundNodeConnectionParameters = new NodeConnectionParameters();
internalPort = internalPort == -1 ? network.DefaultPort : internalPort;
this.localEndpoint = new IPEndPoint(IPAddress.Parse("0.0.0.0").MapToIPv6Ex(), internalPort);
this.MaxConnections = 125;
this.Network = network;
this.externalEndpoint = new IPEndPoint(this.localEndpoint.Address, this.Network.DefaultPort);
this.Version = version;
var listener = new EventLoopMessageListener <IncomingMessage>(ProcessMessage);
this.messageProducer.AddMessageListener(listener);
this.OwnResource(listener);
this.ConnectedNodes = new NodesCollection();
this.ConnectedNodes.Added += Nodes_NodeAdded;
this.ConnectedNodes.Removed += Nodes_NodeRemoved;
this.ConnectedNodes.MessageProducer.AddMessageListener(listener);
this.AllMessages = new MessageProducer <IncomingMessage>();
this.trace = new TraceCorrelation(NodeServerTrace.Trace, "Node server listening on " + this.LocalEndpoint);
}
/// <summary>
/// Initializes instance of a network peer server.
/// </summary>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="version">Version of the network protocol that the server should run.</param>
/// <param name="internalPort">Port on which the server will listen, or -1 to use the default port for the selected network.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
/// <param name="networkPeerFactory">Factory for creating P2P network peers.</param>
public NetworkPeerServer(Network network, ProtocolVersion version, int internalPort, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory, INetworkPeerFactory networkPeerFactory)
{
internalPort = internalPort == -1 ? network.DefaultPort : internalPort;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName, $"[{internalPort}] ");
this.logger.LogTrace("({0}:{1},{2}:{3},{4}:{5})", nameof(network), network, nameof(version), version, nameof(internalPort), internalPort);
this.dateTimeProvider = dateTimeProvider;
this.networkPeerFactory = networkPeerFactory;
this.AllowLocalPeers = true;
this.InboundNetworkPeerConnectionParameters = new NetworkPeerConnectionParameters();
this.localEndpoint = new IPEndPoint(IPAddress.Parse("0.0.0.0").MapToIPv6Ex(), internalPort);
this.MaxConnections = 125;
this.Network = network;
this.externalEndpoint = new IPEndPoint(this.localEndpoint.Address, this.Network.DefaultPort);
this.Version = version;
this.listener = new EventLoopMessageListener <IncomingMessage>(ProcessMessage);
this.messageProducer = new MessageProducer <IncomingMessage>();
this.messageProducer.AddMessageListener(this.listener);
this.ConnectedNetworkPeers = new NetworkPeerCollection();
this.ConnectedNetworkPeers.MessageProducer.AddMessageListener(this.listener);
this.logger.LogTrace("Network peer server ready to listen on '{0}'.", this.LocalEndpoint);
this.logger.LogTrace("(-)");
}
public MinerManager(BlockChain.BlockChain blockChain, Address address)
{
TxsPerBlockLimit = 100; //TODO
Difficulty = 12; //TODO: when set to 10, becomes apparent a issue of 'tx race condition' (i.e. when using a secure contract to send token, two subsequent txs are dispatched) in which the miner is reset after mining a block with 1st tx and 2nd is never gets mined
_Address = address;
_BlockChain = blockChain;
_Hasher.OnMined += DispatchBlock;
OwnResource(_Hasher);
_BlockChainListener = new EventLoopMessageListener <BlockChainMessage>(OnBlockChainMessage, "Miner Consumer");
OwnResource(MessageProducer <BlockChainMessage> .Instance.AddMessageListener(_BlockChainListener));
Reset();
}
public NodeServer(Network network, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION,
int internalPort = -1)
{
AdvertizeMyself = true;
internalPort = internalPort == -1 ? network.DefaultPort : internalPort;
_LocalEndpoint = new IPEndPoint(IPAddress.Parse("0.0.0.0").MapToIPv6(), internalPort);
_Network = network;
_ExternalEndpoint = new IPEndPoint(_LocalEndpoint.Address, Network.DefaultPort);
_Version = version;
var listener = new EventLoopMessageListener<IncomingMessage>(ProcessMessage);
_MessageProducer.AddMessageListener(listener);
OwnResource(listener);
RegisterPeerTableRepository(_PeerTable);
_Nodes = new NodeSet();
_Nodes.MessageProducer.AddMessageListener(listener);
_Trace = new TraceCorrelation(NodeServerTrace.Trace, "Node server listening on " + LocalEndpoint);
}
public NodeServer(Network network, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION,
int internalPort = -1)
{
AllowLocalPeers = true;
InboundNodeConnectionParameters = new NodeConnectionParameters();
internalPort = internalPort == -1 ? network.DefaultPort : internalPort;
_LocalEndpoint = new IPEndPoint(IPAddress.Parse("0.0.0.0").MapToIPv6Ex(), internalPort);
_Network = network;
_ExternalEndpoint = new IPEndPoint(_LocalEndpoint.Address, Network.DefaultPort);
_Version = version;
var listener = new EventLoopMessageListener<IncomingMessage>(ProcessMessage);
_MessageProducer.AddMessageListener(listener);
OwnResource(listener);
_ConnectedNodes = new NodesCollection();
_ConnectedNodes.Added += _Nodes_NodeAdded;
_ConnectedNodes.Removed += _Nodes_NodeRemoved;
_ConnectedNodes.MessageProducer.AddMessageListener(listener);
_Trace = new TraceCorrelation(NodeServerTrace.Trace, "Node server listening on " + LocalEndpoint);
}
public WalletManager(BlockChain.BlockChain blockChain, string dbName)
{
_BlockChain = blockChain;
_DBContext = new DBContext(dbName);
_KeyStore = new KeyStore();
_TxStore = new TxStore();
TxDeltaList = new List <TxDelta>();
_BlockChainListener = new EventLoopMessageListener <BlockChainMessage>(OnBlockChainMessage, "Wallet Consumer");
OwnResource(MessageProducer <BlockChainMessage> .Instance.AddMessageListener(_BlockChainListener));
OwnResource(_DBContext);
using (var dbTx = _DBContext.GetTransactionContext())
{
_Keys = _KeyStore.List(dbTx);
var purgeList = new List <ulong>();
_TxStore.All(dbTx).ToList().ForEach(item =>
{
switch (item.Item2.TxState)
{
case TxStateEnum.Confirmed:
TxDeltaList.Add(new TxDelta(item.Item2.TxState, item.Item2.TxHash, item.Item2.Tx, item.Item2.AssetDeltas, item.Item2.DateTime));
break;
case TxStateEnum.Unconfirmed:
purgeList.Add(item.Item1);
//TODO: implement 'smarter' mode: only after the node has been synced and is up-to-date, try to revalidate
//_BlockChain.HandleTransaction(txData.Tx);
break;
}
foreach (var key in purgeList)
{
_TxStore.Remove(dbTx, key);
}
});
}
}
public NodeServer(Network network, uint?version = null,
int internalPort = -1)
{
AllowLocalPeers = true;
InboundNodeConnectionParameters = new NodeConnectionParameters();
internalPort = internalPort == -1 ? network.DefaultPort : internalPort;
_LocalEndpoint = new IPEndPoint(IPAddress.Parse("0.0.0.0").MapToIPv6Ex(), internalPort);
MaxConnections = 125;
_Network = network;
_ExternalEndpoint = new IPEndPoint(_LocalEndpoint.Address, Network.DefaultPort);
_Version = version == null ? network.MaxP2PVersion : version.Value;
var listener = new EventLoopMessageListener <IncomingMessage>(ProcessMessage);
_MessageProducer.AddMessageListener(listener);
OwnResource(listener);
_ConnectedNodes = new NodesCollection();
_ConnectedNodes.Added += _Nodes_NodeAdded;
_ConnectedNodes.Removed += _Nodes_NodeRemoved;
_ConnectedNodes.MessageProducer.AddMessageListener(listener);
}
/// <summary>
/// Initializes instance of a network peer server.
/// </summary>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="ipAddress">Address of the local interface to listen on, or <c>null</c> to listen on all available interfaces.</param>
/// <param name="internalPort">Port on which the server will listen, or -1 to use the default port for the selected network.</param>
/// <param name="version">Version of the network protocol that the server should run.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
/// <param name="networkPeerFactory">Factory for creating P2P network peers.</param>
public NetworkPeerServer(Network network, IPEndPoint localEndpoint, IPEndPoint externalEndpoint, ProtocolVersion version, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory, INetworkPeerFactory networkPeerFactory)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName, $"[{localEndpoint}] ");
this.logger.LogTrace("({0}:{1},{2}:{3},{4}:{5})", nameof(network), network, nameof(localEndpoint), localEndpoint, nameof(externalEndpoint), externalEndpoint, nameof(version), version);
this.dateTimeProvider = dateTimeProvider;
this.networkPeerFactory = networkPeerFactory;
this.AllowLocalPeers = true;
this.InboundNetworkPeerConnectionParameters = new NetworkPeerConnectionParameters();
this.LocalEndpoint = Utils.EnsureIPv6(localEndpoint);
this.ExternalEndpoint = Utils.EnsureIPv6(externalEndpoint);
this.MaxConnections = 125;
this.Network = network;
this.Version = version;
this.listener = new EventLoopMessageListener <IncomingMessage>(this.ProcessMessageAsync);
this.messageProducer = new MessageProducer <IncomingMessage>();
this.messageProducer.AddMessageListener(this.listener);
this.ConnectedNetworkPeers = new NetworkPeerCollection();
this.ConnectedNetworkPeers.MessageProducer.AddMessageListener(this.listener);
this.serverCancel = new CancellationTokenSource();
this.tcpListener = new TcpListener(this.LocalEndpoint);
this.tcpListener.Server.LingerState = new LingerOption(true, 0);
this.tcpListener.Server.NoDelay = true;
this.tcpListener.Server.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, false);
this.clientsById = new ConcurrentDictionary <int, NetworkPeerClient>();
this.acceptTask = Task.CompletedTask;
this.logger.LogTrace("Network peer server ready to listen on '{0}'.", this.LocalEndpoint);
this.logger.LogTrace("(-)");
}
public ListenerTester(ServerTester tester)
{
_Network = tester.Configuration.Indexer.Network;
Random rand = new Random();
_Server = tester;
_Server._disposables.Add(this);
_Listener = new QBitNinjaListener(_Server.Configuration);
_NodeServer = new NodeServer(_Server.Configuration.Indexer.Network, internalPort: rand.Next(20000, 50000));
_NodeListener = new EventLoopMessageListener <IncomingMessage>(NewNodeMessage);
_NodeServer.ExternalEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), _NodeServer.LocalEndpoint.Port);
_NodeServer.AllowLocalPeers = true;
_NodeServer.IsRelay = true;
_NodeServer.AllMessages.AddMessageListener(_NodeListener);
_NodeServer.Listen();
_Listener.Configuration.Indexer.Node = "127.0.0.1:" + _NodeServer.LocalEndpoint.Port;
_Listener.Listen();
_Server.ChainBuilder.SkipIndexer = true;
_Server.ChainBuilder.NewBlock += ChainBuilder_NewBlock;
_Server.ChainBuilder.NewTransaction += ChainBuilder_NewTransaction;
}
/// <summary>
/// Initializes an instance of the object.
/// </summary>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="peer">Network peer the node is connected to, or will connect to.</param>
/// <param name="client">Initialized TCP client, which may or may not be already connected.</param>
/// <param name="clientId">Unique identifier of the connection.</param>
/// <param name="messageReceivedCallback">Callback to be called when a new message arrives from the peer.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
public NetworkPeerConnection(Network network, NetworkPeer peer, TcpClient client, int clientId, Func <IncomingMessage, Task> messageReceivedCallback, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory)
{
this.loggerFactory = loggerFactory;
this.logger = this.loggerFactory.CreateLogger(this.GetType().FullName, $"[{clientId}-{peer.PeerAddress.Endpoint}] ");
this.network = network;
this.dateTimeProvider = dateTimeProvider;
this.peer = peer;
this.setPeerStateOnShutdown = NetworkPeerState.Offline;
this.tcpClient = client;
this.Id = clientId;
this.stream = this.tcpClient.Connected ? this.tcpClient.GetStream() : null;
this.ShutdownComplete = new TaskCompletionSource <bool>();
this.writeLock = new AsyncLock();
this.CancellationSource = new CancellationTokenSource();
this.MessageProducer = new MessageProducer <IncomingMessage>();
this.messageListener = new EventLoopMessageListener <IncomingMessage>(messageReceivedCallback);
this.MessageProducer.AddMessageListener(this.messageListener);
}
public IDisposable RegisterPeerTableRepository(PeerTableRepository peerTableRepository)
{
var poll = new EventLoopMessageListener<object>(o =>
{
var message = o as IncomingMessage;
if(message != null)
{
if(message.Message.Payload is AddrPayload)
{
peerTableRepository.WritePeers(((AddrPayload)message.Message.Payload).Addresses
.Where(a => a.Endpoint.Address.IsRoutable(AllowLocalPeers))
.Select(a => new Peer(PeerOrigin.Addr, a)));
}
}
var peer = o as Peer;
if(peer != null)
{
if(peer.NetworkAddress.Endpoint.Address.IsRoutable(AllowLocalPeers))
peerTableRepository.WritePeer(peer);
}
});
if(peerTableRepository != _PeerTable)
{
_InternalMessageProducer.PushMessages(peerTableRepository.GetPeers());
}
return new CompositeDisposable(AllMessages.AddMessageListener(poll), _InternalMessageProducer.AddMessageListener(poll), OwnResource(poll));
}
public IDisposable RegisterBlockRepository(BlockRepository repository)
{
var listener = new EventLoopMessageListener<IncomingMessage>((m) =>
{
if(m.Node != null)
{
if(m.Message.Payload is HeadersPayload)
{
foreach(var header in ((HeadersPayload)m.Message.Payload).Headers)
{
repository.WriteBlockHeader(header);
}
}
if(m.Message.Payload is BlockPayload)
{
repository.WriteBlock(((BlockPayload)m.Message.Payload).Object);
}
}
});
return new CompositeDisposable(AllMessages.AddMessageListener(listener), OwnResource(listener));
}
