public HandshakeProcessor(ILogger <HandshakeProcessor> logger,
IEventBus eventBus,
IDateTimeProvider dateTimeProvider,
IRandomNumberGenerator randomNumberGenerator,
NodeImplementation nodeImplementation,
IPeerBehaviorManager peerBehaviorManager,
IInitialBlockDownloadTracker initialBlockDownloadState,
IUserAgentBuilder userAgentBuilder,
ILocalServiceProvider localServiceProvider,
IHeadersTree headersTree,
SelfConnectionTracker selfConnectionTracker) : base(logger,
eventBus,
peerBehaviorManager,
isHandshakeAware: true,
// we are performing handshake so we want to receive messages before handshake status
receiveMessagesOnlyIfHandshaked: false)
{
_dateTimeProvider = dateTimeProvider;
_randomNumberGenerator = randomNumberGenerator;
_nodeImplementation = nodeImplementation;
_initialBlockDownloadState = initialBlockDownloadState;
_userAgentBuilder = userAgentBuilder;
_localServiceProvider = localServiceProvider;
_headersTree = headersTree;
_selfConnectionTracker = selfConnectionTracker;
_status = new HandshakeProcessorStatus(this);
}
/// <summary>Initializes a new instance of the <see cref="BaseProcessor"/> class.</summary>
/// <param name="logger">The logger.</param>
/// <param name="eventBus">The event bus.</param>
/// <param name="peerBehaviorManager">The peer behavior manager.</param>
/// <param name="isHandshakeAware">If set to <c>true</c> register the instance to be handshake aware: when the peer is handshaked, OnPeerHandshaked method will be invoked.</param>
/// <param name="receiveMessagesOnlyIfHandshaked">if set to <c>true</c> receives messages only if handshaked.</param>
public BaseProcessor(ILogger <BaseProcessor> logger, IEventBus eventBus, IPeerBehaviorManager peerBehaviorManager, bool isHandshakeAware, bool receiveMessagesOnlyIfHandshaked)
{
this.logger = logger;
this.eventBus = eventBus;
_peerBehaviorManager = peerBehaviorManager;
_isHandshakeAware = isHandshakeAware;
_receiveMessagesOnlyIfHandshaked = receiveMessagesOnlyIfHandshaked;
}
public DateTimeAdjusterProcessor(ILogger <DateTimeAdjusterProcessor> logger,
IEventBus eventBus,
IPeerBehaviorManager peerBehaviorManager,
IDateTimeProvider dateTimeProvider
)
: base(logger, eventBus, peerBehaviorManager, isHandshakeAware: true, receiveMessagesOnlyIfHandshaked: true)
{
_dateTimeProvider = dateTimeProvider;
}
/// <summary>Initializes a new instance of the <see cref="BaseProcessor"/> class.</summary>
/// <param name="logger">The logger.</param>
/// <param name="eventBus">The event bus.</param>
/// <param name="peerBehaviorManager">The peer behavior manager.</param>
/// <param name="isHandshakeAware">If set to <c>true</c> register the instance to be handshake aware: when the peer is handshaked, OnPeerHandshaked method will be invoked.</param>
public BaseProcessor(ILogger <BaseProcessor> logger, IEventBus eventBus, IPeerBehaviorManager peerBehaviorManager, bool isHandshakeAware)
{
this.logger = logger;
this.eventBus = eventBus;
_peerBehaviorManager = peerBehaviorManager;
_isHandshakeAware = isHandshakeAware;
PeerContext = null !; //hack to not rising null warnings, these are initialized when calling AttachAsync
_messageWriter = null !; //hack to not rising null warnings, these are initialized when calling AttachAsync
}
public PingPongProcessor(ILogger <PingPongProcessor> logger,
IEventBus eventBus,
IPeerBehaviorManager peerBehaviorManager,
IRandomNumberGenerator randomNumberGenerator,
IDateTimeProvider dateTimeProvider,
IPeriodicWork periodicPing)
: base(logger, eventBus, peerBehaviorManager, isHandshakeAware: true, receiveMessagesOnlyIfHandshaked: true)
{
_randomNumberGenerator = randomNumberGenerator;
_dateTimeProvider = dateTimeProvider;
_periodicPing = periodicPing;
}
public HandshakeProcessor(ILogger <HandshakeProcessor> logger,
IEventBus eventBus,
IDateTimeProvider dateTimeProvider,
IRandomNumberGenerator randomNumberGenerator,
IPeerBehaviorManager peerBehaviorManager,
IUserAgentBuilder userAgentBuilder
) : base(logger, eventBus, peerBehaviorManager, isHandshakeAware: true)
{
_dateTimeProvider = dateTimeProvider;
_randomNumberGenerator = randomNumberGenerator;
_userAgentBuilder = userAgentBuilder;
}
public DataFeederProcessor(ILogger <DataFeederProcessor> logger,
IEventBus eventBus,
IDateTimeProvider dateTimeProvider,
IPeerBehaviorManager peerBehaviorManager,
IInitialBlockDownloadTracker ibdState,
IChainState chainState,
IOptions <BitcoinSettings> options)
: base(logger, eventBus, peerBehaviorManager, isHandshakeAware: true, receiveMessagesOnlyIfHandshaked: true)
{
_dateTimeProvider = dateTimeProvider;
_ibdState = ibdState;
_chainState = chainState;
_settings = options.Value;
}
public HandshakeProcessor(ILogger <HandshakeProcessor> logger,
IEventBus eventBus,
IDateTimeProvider dateTimeProvider,
IRandomNumberGenerator randomNumberGenerator,
NodeImplementation nodeImplementation,
IPeerBehaviorManager peerBehaviorManager,
IUserAgentBuilder userAgentBuilder
) : base(logger,
eventBus,
peerBehaviorManager,
isHandshakeAware: true,
// we are performing handshake so we want to receive messages before handshake status
receiveMessagesOnlyIfHandshaked: false)
{
_dateTimeProvider = dateTimeProvider;
_randomNumberGenerator = randomNumberGenerator;
_nodeImplementation = nodeImplementation;
_userAgentBuilder = userAgentBuilder;
_status = new HandshakeProcessorStatus(this);
}
public SynchronizationProcessor(ILogger <SynchronizationProcessor> logger,
IEventBus eventBus,
IDateTimeProvider dateTimeProvider,
IPeerBehaviorManager peerBehaviorManager,
IConsensusParameters consensusParameters,
IInitialBlockDownloadTracker ibdState,
IBlockHeaderHashCalculator blockHeaderHashCalculator,
ITransactionHashCalculator transactionHashCalculator,
IBlockFetcherManager blockFetcherManager,
ILocalServiceProvider localServiceProvider,
IChainState chainState,
IHeaderValidator headerValidator,
IBlockValidator blockValidator,
IPeriodicWork headerSyncLoop,
IOptions <BitcoinSettings> options)
: base(logger, eventBus, peerBehaviorManager, isHandshakeAware: true, receiveMessagesOnlyIfHandshaked: true)
{
_dateTimeProvider = dateTimeProvider;
_consensusParameters = consensusParameters;
_ibdState = ibdState;
_blockHeaderHashCalculator = blockHeaderHashCalculator;
_transactionHashCalculator = transactionHashCalculator;
_blockFetcherManager = blockFetcherManager;
_localServiceProvider = localServiceProvider;
_chainState = chainState;
_headerValidator = headerValidator;
_blockValidator = blockValidator;
_headerSyncLoop = headerSyncLoop;
_options = options.Value;
_minimumChainWork = _options.MinimumChainWork ?? _consensusParameters.MinimumChainWork;
if (_minimumChainWork < _consensusParameters.MinimumChainWork)
{
this.logger.LogWarning($"{nameof(_minimumChainWork)} set below default value of {_consensusParameters.MinimumChainWork}");
}
headerSyncLoop.Configure(stopOnException: false, this);
}
public AddressProcessor(ILogger <AddressProcessor> logger, IEventBus eventBus, IPeerBehaviorManager peerBehaviorManager)
: base(logger, eventBus, peerBehaviorManager, isHandshakeAware: true, receiveMessagesOnlyIfHandshaked: true)
{
}
public ErrorMessageProcessor(ILogger <BaseProcessor> logger, IEventBus eventBus,
IPeerBehaviorManager peerBehaviorManager)
: base(logger, eventBus, peerBehaviorManager, true)
{
}
