/// <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="processMessageAsync">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>
/// <param name="payloadProvider">A provider of network payload messages.</param>
public NetworkPeerConnection(Network network, INetworkPeer peer, TcpClient client, int clientId,
ProcessMessageAsync <IncomingMessage> processMessageAsync, IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory, PayloadProvider payloadProvider, IAsyncProvider asyncProvider)
{
this.loggerFactory = loggerFactory;
this.payloadProvider = payloadProvider;
this.asyncProvider = Guard.NotNull(asyncProvider, nameof(asyncProvider));
this.logger = this.loggerFactory.CreateLogger(GetType().FullName, $"[{clientId}-{peer.PeerEndPoint}] ");
this.network = network;
this.dateTimeProvider = dateTimeProvider;
this.peer = peer;
this.tcpClient = client;
this.Id = clientId;
this.stream = this.tcpClient.Connected ? this.tcpClient.GetStream() : null;
this.writeLock = new AsyncLock();
this.CancellationSource = new CancellationTokenSource();
this.MessageProducer = new MessageProducer <IncomingMessage>();
this.messageListener =
new CallbackMessageListener <IncomingMessage>(asyncProvider, processMessageAsync, peer);
this.messageProducerRegistration = this.MessageProducer.AddMessageListener(this.messageListener);
}
/// <summary>
/// Initializes a new instance of the factory.
/// </summary>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
/// <param name="payloadProvider">A provider of network payload messages.</param>
/// <param name="selfEndpointTracker">Tracker for endpoints known to be self.</param>
/// <param name="initialBlockDownloadState">Provider of IBD state.</param>
/// <param name="connectionManagerSettings">Configuration related to incoming and outgoing connections.</param>
public NetworkPeerFactory(Network network,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
PayloadProvider payloadProvider,
ISelfEndpointTracker selfEndpointTracker,
IInitialBlockDownloadState initialBlockDownloadState,
ConnectionManagerSettings connectionManagerSettings,
IAsyncProvider asyncProvider,
IPeerAddressManager peerAddressManager)
{
Guard.NotNull(network, nameof(network));
Guard.NotNull(dateTimeProvider, nameof(dateTimeProvider));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
this.network = network;
this.dateTimeProvider = dateTimeProvider;
this.loggerFactory = loggerFactory;
this.payloadProvider = payloadProvider;
this.selfEndpointTracker = selfEndpointTracker;
this.lastClientId = 0;
this.initialBlockDownloadState = initialBlockDownloadState;
this.connectionManagerSettings = connectionManagerSettings;
this.asyncProvider = Guard.NotNull(asyncProvider, nameof(asyncProvider));
this.peerAddressManager = peerAddressManager;
}
/// <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="processMessageAsync">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>
/// <param name="payloadProvider">A provider of network payload messages.</param>
public NetworkPeerConnection(Network network, INetworkPeer peer, TcpClient client, int clientId, ProcessMessageAsync <IncomingMessage> processMessageAsync, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory, PayloadProvider payloadProvider)
{
this.loggerFactory = loggerFactory;
this.payloadProvider = payloadProvider;
this.logger = this.loggerFactory.CreateLogger(this.GetType().FullName, $"[{clientId}-{peer.PeerEndPoint}] ");
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.DisposeComplete = new TaskCompletionSource <bool>();
this.shutdownLock = new object();
this.writeLock = new AsyncLock();
this.CancellationSource = new CancellationTokenSource();
this.MessageProducer = new MessageProducer <IncomingMessage>();
this.messageListener = new CallbackMessageListener <IncomingMessage>(processMessageAsync);
this.messageProducerRegistration = this.MessageProducer.AddMessageListener(this.messageListener);
}
/// <summary>
/// Initializes a new instance of the factory.
/// </summary>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
/// <param name="payloadProvider">A provider of network payload messages.</param>
public NetworkPeerFactory(Network network, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory, PayloadProvider payloadProvider)
{
Guard.NotNull(network, nameof(network));
Guard.NotNull(dateTimeProvider, nameof(dateTimeProvider));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
this.network = network;
this.dateTimeProvider = dateTimeProvider;
this.loggerFactory = loggerFactory;
this.payloadProvider = payloadProvider;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.lastClientId = 0;
}
internal void Add(int docId, Hubble.Core.Data.Payload payLoad, PayloadProvider payloadProvider)
{
HBMonitor.Enter(_LockObj);
try
{
_PayloadEntities.Add(new PayloadEntity(docId, payLoad, payloadProvider));
}
finally
{
HBMonitor.Exit(_LockObj);
}
//ASendMessage((int)Event.Add, new PayloadEntity(docId, payLoad, payloadProvider));
}
public void PayloadProvider_SetsCorrectExpirationTime()
{
var claims = new Dictionary <string, object>();
claims.Add("iss", "issuerClaim");
var expirationTime = new DateTime(2018, 04, 14);
var provider = new PayloadProvider();
var payload = provider.GetPayload(expirationTime, claims);
Assert.True(payload.ContainsKey("exp"));
Assert.Equal(1523656800, payload.Exp);
}
public PoAFeature(FederationManager federationManager, PayloadProvider payloadProvider, IConnectionManager connectionManager, ConcurrentChain chain,
IInitialBlockDownloadState initialBlockDownloadState, IConsensusManager consensusManager, IPeerBanning peerBanning, ILoggerFactory loggerFactory,
IPoAMiner miner)
{
this.federationManager = federationManager;
this.connectionManager = connectionManager;
this.chain = chain;
this.initialBlockDownloadState = initialBlockDownloadState;
this.consensusManager = consensusManager;
this.peerBanning = peerBanning;
this.loggerFactory = loggerFactory;
this.miner = miner;
payloadProvider.DiscoverPayloads(this.GetType().Assembly);
}
public ConnectionManager(IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
Network network,
INetworkPeerFactory networkPeerFactory,
NodeSettings nodeSettings,
INodeLifetime nodeLifetime,
NetworkPeerConnectionParameters parameters,
IPeerAddressManager peerAddressManager,
IEnumerable <IPeerConnector> peerConnectors,
IPeerDiscovery peerDiscovery,
ISelfEndpointTracker selfEndpointTracker,
ConnectionManagerSettings connectionSettings,
IVersionProvider versionProvider,
INodeStats nodeStats,
IAsyncProvider asyncProvider,
PayloadProvider payloadProvider)
{
this.connectedPeers = new NetworkPeerCollection();
this.dateTimeProvider = dateTimeProvider;
this.loggerFactory = loggerFactory;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.Network = network;
this.NetworkPeerFactory = networkPeerFactory;
this.NodeSettings = nodeSettings;
this.nodeLifetime = nodeLifetime;
this.asyncProvider = asyncProvider;
this.payloadProvider = payloadProvider;
this.peerAddressManager = peerAddressManager;
this.PeerConnectors = peerConnectors;
this.peerDiscovery = peerDiscovery;
this.ConnectionSettings = connectionSettings;
this.networkPeerDisposer = new NetworkPeerDisposer(this.loggerFactory, this.asyncProvider);
this.Servers = new List <NetworkPeerServer>();
this.Parameters = parameters;
this.Parameters.ConnectCancellation = this.nodeLifetime.ApplicationStopping;
this.selfEndpointTracker = selfEndpointTracker;
this.versionProvider = versionProvider;
this.ipRangeFilteringEndpointExclusions = new List <IPEndPoint>();
this.connectedPeersQueue = asyncProvider.CreateAndRunAsyncDelegateDequeuer <INetworkPeer>($"{nameof(ConnectionManager)}-{nameof(this.connectedPeersQueue)}", this.OnPeerAdded);
this.disconnectedPerfCounter = new PerformanceCounter();
this.Parameters.UserAgent = $"{this.ConnectionSettings.Agent}:{versionProvider.GetVersion()} ({(int)this.NodeSettings.ProtocolVersion})";
this.Parameters.Version = this.NodeSettings.ProtocolVersion;
nodeStats.RegisterStats(this.AddComponentStats, StatsType.Component, this.GetType().Name, 1100);
}
public PoAFeature(FederationManager federationManager, PayloadProvider payloadProvider, IConnectionManager connectionManager, ConcurrentChain chain,
IInitialBlockDownloadState initialBlockDownloadState, IConsensusManager consensusManager, IPeerBanning peerBanning, ILoggerFactory loggerFactory,
IPoAMiner miner, VotingManager votingManager, Network network, WhitelistedHashesRepository whitelistedHashesRepository)
{
this.federationManager = federationManager;
this.connectionManager = connectionManager;
this.chain = chain;
this.initialBlockDownloadState = initialBlockDownloadState;
this.consensusManager = consensusManager;
this.peerBanning = peerBanning;
this.loggerFactory = loggerFactory;
this.miner = miner;
this.votingManager = votingManager;
this.whitelistedHashesRepository = whitelistedHashesRepository;
this.network = network;
payloadProvider.DiscoverPayloads(this.GetType().Assembly);
}
public PoAFeature(
IFederationManager federationManager,
PayloadProvider payloadProvider,
IConnectionManager connectionManager,
ChainIndexer chainIndexer,
IInitialBlockDownloadState initialBlockDownloadState,
IConsensusManager consensusManager,
IPeerBanning peerBanning,
ILoggerFactory loggerFactory,
VotingManager votingManager,
IFederationHistory federationHistory,
Network network,
IWhitelistedHashesRepository whitelistedHashesRepository,
IIdleFederationMembersKicker idleFederationMembersKicker,
IChainState chainState,
IBlockStoreQueue blockStoreQueue,
NodeSettings nodeSettings,
ReconstructFederationService reconstructFederationService,
IPoAMiner miner = null
)
{
this.federationManager = federationManager;
this.connectionManager = connectionManager;
this.chainIndexer = chainIndexer;
this.initialBlockDownloadState = initialBlockDownloadState;
this.consensusManager = consensusManager;
this.peerBanning = peerBanning;
this.loggerFactory = loggerFactory;
this.miner = miner;
this.votingManager = votingManager;
this.federationHistory = federationHistory;
this.whitelistedHashesRepository = whitelistedHashesRepository;
this.network = network;
this.idleFederationMembersKicker = idleFederationMembersKicker;
this.chainState = chainState;
this.blockStoreQueue = blockStoreQueue;
this.nodeSettings = nodeSettings;
this.reconstructFederationService = reconstructFederationService;
payloadProvider.DiscoverPayloads(this.GetType().Assembly);
}
/// <summary>
/// Initializes a new instance of the factory.
/// </summary>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
/// <param name="payloadProvider">A provider of network payload messages.</param>
/// <param name="selfEndpointTracker">Tracker for endpoints known to be self.</param>
/// <param name="initialBlockDownloadState">Provider of IBD state.</param>
/// <param name="connectionManagerSettings">Configuration related to incoming and outgoing connections.</param>
public NetworkPeerFactory(Network network,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
PayloadProvider payloadProvider,
ISelfEndpointTracker selfEndpointTracker,
IInitialBlockDownloadState initialBlockDownloadState,
ConnectionManagerSettings connectionManagerSettings)
{
Guard.NotNull(network, nameof(network));
Guard.NotNull(dateTimeProvider, nameof(dateTimeProvider));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
this.network = network;
this.dateTimeProvider = dateTimeProvider;
this.loggerFactory = loggerFactory;
this.payloadProvider = payloadProvider;
this.selfEndpointTracker = selfEndpointTracker;
this.logger = loggerFactory.CreateLogger("Impleum.Bitcoin.FullNode");
this.lastClientId = 0;
this.initialBlockDownloadState = initialBlockDownloadState;
this.connectionManagerSettings = connectionManagerSettings;
}
internal void Update(IList <int> docIds, IList <Data.Payload> payloads, PayloadProvider payloadProvider)
{
List <PayloadEntity> peList = new List <PayloadEntity>();
for (int i = 0; i < docIds.Count; i++)
{
peList.Add(new PayloadEntity(docIds[i], payloads[i], payloadProvider));
}
HBMonitor.Enter(_LockObj);
try
{
UpdateToFile(peList);
}
finally
{
HBMonitor.Exit(_LockObj);
}
//SSendMessage((int)Event.Update, peList, int.MaxValue);
}
public MempoolFeature(
IConnectionManager connectionManager,
MempoolSignaled mempoolSignaled,
BlocksDisconnectedSignaled blocksDisconnectedSignaled,
MempoolBehavior mempoolBehavior,
MempoolManager mempoolManager,
ILoggerFactory loggerFactory,
INodeStats nodeStats,
IBroadcasterManager broadcasterManager,
PayloadProvider payloadProvider,
FeeFilterBehavior feeFilterBehavior)
{
this.connectionManager = connectionManager;
this.mempoolSignaled = mempoolSignaled;
this.blocksDisconnectedSignaled = blocksDisconnectedSignaled;
this.mempoolBehavior = mempoolBehavior;
this.mempoolManager = mempoolManager;
this.broadcasterManager = broadcasterManager;
this.payloadProvider = payloadProvider;
this.feeFilterBehavior = feeFilterBehavior;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
nodeStats.RegisterStats(this.AddComponentStats, StatsType.Component, this.GetType().Name);
}
public void PayloadProvider_AddsAllClaims()
{
var claims = new Dictionary <string, object>();
claims.Add("iss", "issuerClaim");
claims.Add("role", "roleClaim");
claims.Add("userId", 1);
claims.Add("customClaim", "customClaimValue");
var expirationTime = new DateTime(2018, 04, 14);
var provider = new PayloadProvider();
var payload = provider.GetPayload(expirationTime, claims);
Assert.True(payload.ContainsKey("iss"));
Assert.True(payload.ContainsKey("role"));
Assert.True(payload.ContainsKey("userId"));
Assert.True(payload.ContainsKey("customClaim"));
Assert.True(payload.ContainsValue("issuerClaim"));
Assert.True(payload.ContainsValue("roleClaim"));
Assert.True(payload.ContainsValue(1));
Assert.True(payload.ContainsValue("customClaimValue"));
}
public PayloadEntity(int docId, Hubble.Core.Data.Payload payload, PayloadProvider payloadProvider)
{
DocId = docId;
Payload = payload;
PayloadProvider = payloadProvider;
}
public Message(PayloadProvider payloadProvider)
{
this.payloadProvider = payloadProvider;
}
public static Message ReadNext(Stream stream, Network network, ProtocolVersion version, CancellationToken cancellationToken, PayloadProvider payloadProvider, out PerformanceCounter counter)
{
var bitStream = new BitcoinStream(stream, false)
{
ProtocolVersion = version,
ReadCancellationToken = cancellationToken,
ConsensusFactory = network.Consensus.ConsensusFactory,
};
if (!network.ReadMagic(stream, cancellationToken, true))
{
throw new FormatException("Magic incorrect, the message comes from another network");
}
var message = new Message(payloadProvider);
using (message.SkipMagicScope(true))
{
message.Magic = network.Magic;
message.ReadWrite(bitStream);
}
counter = bitStream.Counter;
return(message);
}
public PoAFeature(FederationManager federationManager, PayloadProvider payloadProvider)
{
this.federationManager = federationManager;
payloadProvider.DiscoverPayloads(this.GetType().Assembly);
}
/// <summary>
/// Fast load
/// </summary>
/// <param name="payloadProvider">payload provider</param>
/// <param name="fs">file stream has been point to end of header</param>
/// <returns>last store docid</returns>
private int FastLoad(PayloadProvider payloadProvider, System.IO.FileStream fs, int rankTab)
{
return(payloadProvider.LoadFromFile(fs, _StoreLength, rankTab));
}
internal PayloadProvider Open(Field docIdReplaceField, List <Data.Field> fields, int payloadLength, out int lastDocId)
{
lastDocId = -1;
List <Data.Field> tmpFields = new List <Hubble.Core.Data.Field>();
PayloadProvider docPayload = new PayloadProvider(docIdReplaceField);
long truncateLength = 0;
int rankTab = -1;
foreach (Data.Field field in fields)
{
if (field.IndexType != Hubble.Core.Data.Field.Index.None)
{
tmpFields.Add(field);
}
if (field.Name.Equals("Rank", StringComparison.CurrentCultureIgnoreCase))
{
if (field.IndexType == Field.Index.Untokenized && field.DataType == DataType.Int)
{
rankTab = field.TabIndex;
}
}
}
tmpFields.Sort(new TabCompare());
PayloadFileHead head = new PayloadFileHead();
head.Build(tmpFields);
if (_StoreLength <= 0)
{
_StoreLength = payloadLength * 4 + sizeof(int);
}
using (System.IO.FileStream fs = new System.IO.FileStream(_FileName, System.IO.FileMode.Open, System.IO.FileAccess.Read))
{
object obj;
Hubble.Framework.Serialization.BinSerialization.DeserializeBinary(fs, out obj);
PayloadFileHead fileHead = (PayloadFileHead)obj;
if (fileHead.IsBigEndian != head.IsBigEndian)
{
throw new Data.DataException(string.Format("Index file IsBigEndian = {0} but current system IsBigEndian = {1}. Can't load payload file",
fileHead.IsBigEndian, head.IsBigEndian));
}
if ((fileHead.Version[0] <= 0 && fileHead.Version[1] < 8) || (fileHead.Version[0] <= 0 && fileHead.Version[1] == 8 && fileHead.Version[2] == 0 && fileHead.Version[3] < 4))
{
throw new Data.DataException("Index file version is less than V0.8.0.4, you have to rebuild the index");
}
for (int i = 0; i < head.FieldMD5.Length; i++)
{
if (head.FieldMD5[i] != fileHead.FieldMD5[i])
{
throw new Data.DataException(string.Format("Payload file name: {0} does not match with the table",
_FileName));
}
}
fs.Seek(HeadLength, System.IO.SeekOrigin.Begin);
if (payloadLength > 0 && InsertProtect.InsertProtectInfo == null)
{
lastDocId = FastLoad(docPayload, fs, rankTab);
_LastStoredId = lastDocId;
_DocumentsCount = (int)((fs.Length - HeadLength) / _StoreLength);
GC.Collect();
return(docPayload);
}
bool breakForProctect = false;
while (fs.Position < fs.Length)
{
if (payloadLength == 0 && InsertProtect.InsertProtectInfo != null)
{
//Exit exception last time
lastDocId = InsertProtect.InsertProtectInfo.LastDocId;
_LastStoredId = lastDocId;
_DocumentsCount = InsertProtect.InsertProtectInfo.DocumentsCount;
break;
}
int fileIndex = (int)((fs.Position - HeadLength) / _StoreLength);
byte[] buf = new byte[sizeof(int)];
fs.Read(buf, 0, buf.Length);
int docidInFile = (int)BitConverter.ToInt32(buf, 0);
if (docidInFile < lastDocId)
{
throw new Data.DataException(string.Format("docid = {0} < last docid ={1}", docidInFile, lastDocId));
}
lastDocId = docidInFile;
_LastStoredId = lastDocId;
if (InsertProtect.InsertProtectInfo != null)
{
if (lastDocId == InsertProtect.InsertProtectInfo.LastDocId)
{
breakForProctect = true;
}
//Exit exception last time
if (lastDocId > InsertProtect.InsertProtectInfo.LastDocId)
{
lastDocId = InsertProtect.InsertProtectInfo.LastDocId;
_LastStoredId = lastDocId;
truncateLength = fs.Position - sizeof(int);
break;
}
}
if (payloadLength == 0)
{
buf = new byte[sizeof(int)];
fs.Read(buf, 0, buf.Length);
_DocumentsCount = (int)BitConverter.ToInt32(buf, 0);
return(docPayload);
}
byte[] byteData = new byte[payloadLength * 4];
fs.Read(byteData, 0, byteData.Length);
Data.Payload payload = new Hubble.Core.Data.Payload(payloadLength);
payload.CopyFrom(byteData);
payload.FileIndex = fileIndex;
if (payloadLength > 0)
{
docPayload.Add(lastDocId, payload);
_DocumentsCount++;
}
if (breakForProctect)
{
truncateLength = fs.Position;
break;
}
}
GC.Collect();
}
if (InsertProtect.InsertProtectInfo != null)
{
//Exit exception last time
if (InsertProtect.InsertProtectInfo.LastDocId < 0)
{
//No Data
lastDocId = -1;
_LastStoredId = lastDocId;
using (System.IO.FileStream fs = new System.IO.FileStream(_FileName, System.IO.FileMode.Open, System.IO.FileAccess.Write))
{
fs.SetLength(HeadLength);
}
}
else
{
//Have data
if (payloadLength == 0)
{
using (System.IO.FileStream fs = new System.IO.FileStream(_FileName, System.IO.FileMode.Open, System.IO.FileAccess.Write))
{
//Seek to end of head
fs.Seek(HeadLength, System.IO.SeekOrigin.Begin);
//Write last doc id
byte[] buf = BitConverter.GetBytes(InsertProtect.InsertProtectInfo.LastDocId);
fs.Write(buf, 0, buf.Length);
//Write documents count
buf = BitConverter.GetBytes(InsertProtect.InsertProtectInfo.DocumentsCount);
fs.Write(buf, 0, buf.Length);
}
}
else
{
using (System.IO.FileStream fs = new System.IO.FileStream(_FileName, System.IO.FileMode.Open, System.IO.FileAccess.Write))
{
if (truncateLength > 0 && truncateLength < fs.Length)
{
fs.SetLength(truncateLength);
}
}
}
}
}
return(docPayload);
}
