public WalletSyncManager(ILoggerFactory loggerFactory, IWalletManager walletManager, ChainIndexer chainIndexer,
Network network, IBlockStore blockStore, StoreSettings storeSettings, ISignals signals,
IAsyncProvider asyncProvider)
{
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(walletManager, nameof(walletManager));
Guard.NotNull(chainIndexer, nameof(chainIndexer));
Guard.NotNull(network, nameof(network));
Guard.NotNull(blockStore, nameof(blockStore));
Guard.NotNull(storeSettings, nameof(storeSettings));
Guard.NotNull(signals, nameof(signals));
Guard.NotNull(asyncProvider, nameof(asyncProvider));
this.walletManager = walletManager;
this.chainIndexer = chainIndexer;
this.blockStore = blockStore;
this.storeSettings = storeSettings;
this.signals = signals;
this.asyncProvider = asyncProvider;
this.logger = loggerFactory.CreateLogger(GetType().FullName);
this.blocksQueue =
this.asyncProvider.CreateAndRunAsyncDelegateDequeuer <Block>(
$"{nameof(WalletSyncManager)}-{nameof(this.blocksQueue)}", OnProcessBlockAsync);
this.blocksQueueSize = 0;
}
/// <summary>
/// Initializes the instance of the object.
/// </summary>
/// <param name="processMessageAsync">
/// User defined callback routine to be executed when a new message arrives to the
/// listener.
/// </param>
public CallbackMessageListener(IAsyncProvider asyncProvider, ProcessMessageAsync <T> processMessageAsync,
INetworkPeer peer)
{
var queuerName = $"{nameof(CallbackMessageListener<T>)}-{typeof(T).Name}-{peer.PeerEndPoint}";
this.asyncQueue = asyncProvider.CreateAndRunAsyncDelegateDequeuer(queuerName,
new Func <T, CancellationToken, Task>(processMessageAsync));
}
public PartialValidator(IAsyncProvider asyncProvider, IConsensusRuleEngine consensusRules, ILoggerFactory loggerFactory)
{
this.asyncProvider = Guard.NotNull(asyncProvider, nameof(asyncProvider));
this.consensusRules = consensusRules;
this.logger = loggerFactory.CreateLogger("Impleum.Bitcoin.Fullnode");
this.asyncQueue = asyncProvider.CreateAndRunAsyncDelegateDequeuer <PartialValidationItem>(this.GetType().Name, this.OnEnqueueAsync);
}
public CoinviewPrefetcher(ICoinView coinview, ChainIndexer chainIndexer, ILoggerFactory loggerFactory, IAsyncProvider asyncProvider)
{
this.coinview = coinview;
this.chainIndexer = chainIndexer;
this.asyncProvider = asyncProvider;
this.headersQueue = asyncProvider.CreateAndRunAsyncDelegateDequeuer <ChainedHeader>($"{nameof(CoinviewPrefetcher)}-{nameof(this.headersQueue)}", this.OnHeaderEnqueuedAsync);
this.coinviewHelper = new CoinviewHelper();
this.logger = loggerFactory.CreateLogger("Impleum.Bitcoin.Fullnode");
}
public CoinviewPrefetcher(ICoinView coinview, ChainIndexer chainIndexer, ILoggerFactory loggerFactory, IAsyncProvider asyncProvider, ICheckpoints checkpoints)
{
this.coinview = coinview;
this.chainIndexer = chainIndexer;
this.asyncProvider = asyncProvider;
this.checkpoints = checkpoints;
this.headersQueue = asyncProvider.CreateAndRunAsyncDelegateDequeuer <ChainedHeader>($"{nameof(CoinviewPrefetcher)}-{nameof(this.headersQueue)}", this.OnHeaderEnqueued);
this.coinviewHelper = new CoinviewHelper();
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
}
/// <summary>
/// Initializes a new instance of the <see cref="NetworkPeerDisposer" /> class.
/// </summary>
/// <param name="loggerFactory">Factory for creating loggers.</param>
/// <param name="onPeerDisposed">Callback that is called before the peer is disposed.</param>
public NetworkPeerDisposer(ILoggerFactory loggerFactory, IAsyncProvider asyncProvider, Action <INetworkPeer> onPeerDisposed = null)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.asyncProvider = asyncProvider;
this.onPeerDisposed = onPeerDisposed;
this.connectedPeers = new ConcurrentDictionary <int, INetworkPeer>();
string dequeuerName = $"{nameof(NetworkPeerDisposer)}-{nameof(this.peersToDispose)}";
this.peersToDispose = asyncProvider.CreateAndRunAsyncDelegateDequeuer <INetworkPeer>(dequeuerName, this.OnEnqueueAsync);
}
public BlockQueueProcessor(ILogger logger, IAsyncProvider asyncProvider, Func <Block, CancellationToken, Task> callback, int maxQueueSize = 100 * 1024 * 1024, string friendlyName = null)
{
this.logger = logger;
this.MaxQueueSize = maxQueueSize;
this.callback = callback;
if (friendlyName == null)
{
friendlyName = nameof(BlockQueueProcessor);
}
this.blocksQueue = asyncProvider.CreateAndRunAsyncDelegateDequeuer <Block>($"{friendlyName}-{nameof(this.blocksQueue)}", this.OnProcessBlockAsync);
}
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)
{
this.connectedPeers = new NetworkPeerCollection();
this.dateTimeProvider = dateTimeProvider;
this.loggerFactory = loggerFactory;
this.logger = loggerFactory.CreateLogger(GetType().FullName);
this.Network = network;
this.NetworkPeerFactory = networkPeerFactory;
this.NodeSettings = nodeSettings;
this.nodeLifetime = nodeLifetime;
this.asyncProvider = asyncProvider;
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)}", 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(AddComponentStats, StatsType.Component, GetType().Name, 1100);
}
// TODO: Could put a dictionary by OutPoint.
public InputConsolidator(IFederationWalletTransactionHandler transactionHandler,
IFederationWalletManager walletManager,
IBroadcasterManager broadcasterManager,
IFederatedPegSettings settings,
ISignals signals,
IAsyncProvider asyncProvider,
Network network)
{
this.transactionHandler = transactionHandler;
this.walletManager = walletManager;
this.broadcasterManager = broadcasterManager;
this.network = network;
this.settings = settings;
this.logger = LogManager.GetCurrentClassLogger();
this.asyncProvider = asyncProvider;
this.blockQueue = asyncProvider.CreateAndRunAsyncDelegateDequeuer <ChainedHeaderBlock>($"{nameof(InputConsolidator)}-{nameof(this.blockQueue)}", this.ProcessBlockInternal);
signals.Subscribe <WalletNeedsConsolidation>(this.StartConsolidation);
}
public void StartCollecting()
{
lock (this.lockStartStopCollecting)
{
this.peersStatistics.Clear();
this.peersEventsQueue = this.asyncProvider.CreateAndRunAsyncDelegateDequeuer <Event.PeerEventBase>(nameof(this.peersEventsQueue), UpdatePeerStatistics);
this.eventSubscriptions.Add(this.signals.Subscribe <Event.PeerConnected>(this.EnqueuePeerEvent));
this.eventSubscriptions.Add(this.signals.Subscribe <Event.PeerConnectionAttempt>(this.EnqueuePeerEvent));
this.eventSubscriptions.Add(this.signals.Subscribe <Event.PeerConnectionAttemptFailed>(this.EnqueuePeerEvent));
this.eventSubscriptions.Add(this.signals.Subscribe <Event.PeerDisconnected>(this.EnqueuePeerEvent));
this.eventSubscriptions.Add(this.signals.Subscribe <Event.PeerMessageReceived>(this.EnqueuePeerEvent));
this.eventSubscriptions.Add(this.signals.Subscribe <Event.PeerMessageSent>(this.EnqueuePeerEvent));
this.eventSubscriptions.Add(this.signals.Subscribe <Event.PeerMessageSendFailure>(this.EnqueuePeerEvent));
this.Enabled = true;
}
}
/// <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>
/// <param name="selfEndpointTracker">Tracker for endpoints known to be self.</param>
/// <param name="onDisconnected">Callback that is invoked when peer has finished disconnecting, or <c>null</c> when no notification after the disconnection is required.</param>
private NetworkPeer(bool inbound,
IPEndPoint peerEndPoint,
Network network,
NetworkPeerConnectionParameters parameters,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
ISelfEndpointTracker selfEndpointTracker,
IAsyncProvider asyncProvider,
Action <INetworkPeer> onDisconnected = null,
Action <IPEndPoint, Payload> onSendingMessage = null)
{
this.dateTimeProvider = dateTimeProvider;
this.preferredTransactionOptions = parameters.PreferredTransactionOptions;
this.SupportedTransactionOptions = parameters.PreferredTransactionOptions & ~TransactionOptions.All;
this.State = inbound ? NetworkPeerState.Connected : NetworkPeerState.Created;
this.Inbound = inbound;
this.PeerEndPoint = peerEndPoint;
this.RemoteSocketEndpoint = this.PeerEndPoint;
this.RemoteSocketAddress = this.RemoteSocketEndpoint.Address;
this.RemoteSocketPort = this.RemoteSocketEndpoint.Port;
this.Network = network;
this.Behaviors = new List <INetworkPeerBehavior>();
this.selfEndpointTracker = selfEndpointTracker;
this.asyncProvider = asyncProvider;
this.onDisconnectedAsyncContext = new AsyncLocal <DisconnectedExecutionAsyncContext>();
this.ConnectionParameters = parameters ?? new NetworkPeerConnectionParameters();
this.MyVersion = this.ConnectionParameters.CreateVersion(this.selfEndpointTracker.MyExternalAddress, this.PeerEndPoint, network, this.dateTimeProvider.GetTimeOffset());
this.MessageReceived = new AsyncExecutionEvent <INetworkPeer, IncomingMessage>();
this.StateChanged = new AsyncExecutionEvent <INetworkPeer, NetworkPeerState>();
this.onDisconnected = onDisconnected;
this.onSendingMessage = onSendingMessage;
string dequeuerName = $"{nameof(NetworkPeer)}-{nameof(this.asyncPayloadsQueue)}-{this.PeerEndPoint.ToString()}";
this.asyncPayloadsQueue = asyncProvider.CreateAndRunAsyncDelegateDequeuer <Payload>(dequeuerName, this.SendMessageHandledAsync);
}
public FederationWalletSyncManager(ILoggerFactory loggerFactory, IFederationWalletManager walletManager, ChainIndexer chain,
Network network, IBlockStore blockStore, StoreSettings storeSettings, INodeLifetime nodeLifetime, IAsyncProvider asyncProvider)
{
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(walletManager, nameof(walletManager));
Guard.NotNull(chain, nameof(chain));
Guard.NotNull(network, nameof(network));
Guard.NotNull(blockStore, nameof(blockStore));
Guard.NotNull(storeSettings, nameof(storeSettings));
Guard.NotNull(nodeLifetime, nameof(nodeLifetime));
Guard.NotNull(asyncProvider, nameof(asyncProvider));
this.walletManager = walletManager;
this.chain = chain;
this.blockStore = blockStore;
this.coinType = (CoinType)network.Consensus.CoinType;
this.storeSettings = storeSettings;
this.nodeLifetime = nodeLifetime;
this.asyncProvider = asyncProvider;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.blocksQueue = asyncProvider.CreateAndRunAsyncDelegateDequeuer <Block>($"{nameof(FederationWalletSyncManager)}-{nameof(this.blocksQueue)}", this.OnProcessBlockAsync);
this.blocksQueueSize = 0;
}
