public ConnectionService(IPeerPool peerPool, IPeerDialer peerDialer,
IHandshakeProvider handshakeProvider)
{
_peerPool = peerPool;
_peerDialer = peerDialer;
_handshakeProvider = handshakeProvider;
Logger = NullLogger <ConnectionService> .Instance;
EventBus = NullLocalEventBus.Instance;
}
public SyncStateService(INodeSyncStateProvider syncStateProvider, IBlockchainService blockchainService,
IBlockchainNodeContextService blockchainNodeContextService, IPeerPool peerPool,
IHandshakeProvider handshakeProvider)
{
_syncStateProvider = syncStateProvider;
_blockchainService = blockchainService;
_blockchainNodeContextService = blockchainNodeContextService;
_peerPool = peerPool;
_handshakeProvider = handshakeProvider;
}
public GrpcServerService(IOptionsSnapshot <NetworkOptions> netOpts, IPeerPool peerPool, IBlockchainService blockChainService, IAccountService accountService)
{
_netOpts = netOpts.Value;
_peerPool = peerPool;
_blockChainService = blockChainService;
_accountService = accountService;
EventBus = NullLocalEventBus.Instance;
Logger = NullLogger <GrpcServerService> .Instance;
}
public NetworkService(IPeerPool peerPool, ITaskQueueManager taskQueueManager, IAElfNetworkServer networkServer,
IKnownBlockCacheProvider knownBlockCacheProvider)
{
_peerPool = peerPool;
_taskQueueManager = taskQueueManager;
_networkServer = networkServer;
_knownBlockCacheProvider = knownBlockCacheProvider;
Logger = NullLogger <NetworkService> .Instance;
}
public GrpcPeerTests()
{
_blockchainService = GetRequiredService <IBlockchainService>();
_networkServer = GetRequiredService <IAElfNetworkServer>();
_eventBus = GetRequiredService <ILocalEventBus>();
_osTestHelper = GetRequiredService <OSTestHelper>();
_pool = GetRequiredService <IPeerPool>();
_grpcPeer = GrpcTestPeerHelpers.CreateNewPeer();
_pool.TryAddPeer(_grpcPeer);
}
public AEDPoSLastLastIrreversibleBlockDiscoveryService(IPeerPool peerPool,
IAEDPoSInformationProvider dpoSInformationProvider, IBlockchainService blockchainService,
IAccountService accountService, IKnownBlockCacheProvider knownBlockCacheProvider)
{
_peerPool = peerPool;
_dpoSInformationProvider = dpoSInformationProvider;
_blockchainService = blockchainService;
_accountService = accountService;
_knownBlockCacheProvider = knownBlockCacheProvider;
//LocalEventBus = NullLocalEventBus.Instance;
}
public PeerDiscoveryWorker(AbpTimer timer, IPeerDiscoveryService peerDiscoveryService, IPeerPool peerPool,
INetworkService networkService) : base(timer)
{
_peerDiscoveryService = peerDiscoveryService;
Timer.Period = NetworkConstants.DefaultDiscoveryPeriodInMilliSeconds;
_peerPool = peerPool;
_networkService = networkService;
Logger = NullLogger <PeerDiscoveryWorker> .Instance;
}
public PeerReconnectionWorker(AbpTimer timer, IOptionsSnapshot <NetworkOptions> networkOptions,
INetworkService networkService, IPeerPool peerPool, IReconnectionService reconnectionService)
: base(timer)
{
_peerPool = peerPool;
_reconnectionService = reconnectionService;
_networkService = networkService;
_networkOptions = networkOptions.Value;
timer.Period = _networkOptions.PeerReconnectionPeriod;
}
public ConnectionService(IPeerPool peerPool, IPeerDialer peerDialer,
IHandshakeProvider handshakeProvider, IConnectionInfoProvider connectionInfoProvider)
{
_peerPool = peerPool;
_peerDialer = peerDialer;
_handshakeProvider = handshakeProvider;
_connectionInfoProvider = connectionInfoProvider;
Logger = NullLogger <GrpcNetworkServer> .Instance;
EventBus = NullLocalEventBus.Instance;
}
public GrpcPeerTests()
{
_osTestHelper = GetRequiredService <OSTestHelper>();
_pool = GetRequiredService <IPeerPool>();
_grpcPeer = GrpcTestPeerHelper.CreateNewPeer();
_grpcPeer.IsConnected = true;
_nonInterceptedPeer = MockServiceClient("127.0.0.1:2000");
_pool.TryAddPeer(_grpcPeer);
}
public GrpcNetworkServer(IOptionsSnapshot <NetworkOptions> options, PeerService.PeerServiceBase serverService,
IPeerPool peerPool, AuthInterceptor authInterceptor)
{
_serverService = serverService;
_authInterceptor = authInterceptor;
_peerPool = peerPool;
_networkOptions = options.Value;
Logger = NullLogger <GrpcNetworkServer> .Instance;
EventBus = NullLocalEventBus.Instance;
}
public GrpcServerServiceTests()
{
_networkServer = GetRequiredService <IAElfNetworkServer>();
_serverService = GetRequiredService <GrpcServerService>();
_blockchainService = GetRequiredService <IBlockchainService>();
_peerPool = GetRequiredService <IPeerPool>();
_eventBus = GetRequiredService <ILocalEventBus>();
_nodeManager = GetRequiredService <INodeManager>();
_osTestHelper = GetRequiredService <OSTestHelper>();
_handshakeProvider = GetRequiredService <IHandshakeProvider>();
}
public PeerDiscoveryService(IPeerPool peerPool, INodeManager nodeManager,
IDiscoveredNodeCacheProvider discoveredNodeCacheProvider, IAElfNetworkServer aelfNetworkServer,
IPeerDiscoveryJobProcessor peerDiscoveryJobProcessor)
{
_peerPool = peerPool;
_nodeManager = nodeManager;
_discoveredNodeCacheProvider = discoveredNodeCacheProvider;
_aelfNetworkServer = aelfNetworkServer;
_peerDiscoveryJobProcessor = peerDiscoveryJobProcessor;
Logger = NullLogger <PeerDiscoveryService> .Instance;
}
public NetworkService(IPeerPool peerPool, ITaskQueueManager taskQueueManager, IAElfNetworkServer networkServer,
IBlackListedPeerProvider blackListedPeerProvider,
IBroadcastPrivilegedPubkeyListProvider broadcastPrivilegedPubkeyListProvider)
{
_peerPool = peerPool;
_taskQueueManager = taskQueueManager;
_networkServer = networkServer;
_broadcastPrivilegedPubkeyListProvider = broadcastPrivilegedPubkeyListProvider;
_blackListedPeerProvider = blackListedPeerProvider;
Logger = NullLogger <NetworkService> .Instance;
}
public GrpcPeerTests()
{
_blockchainService = GetRequiredService<IBlockchainService>();
_networkServer = GetRequiredService<IAElfNetworkServer>();
_pool = GetRequiredService<IPeerPool>();
_grpcPeer = GrpcTestPeerHelpers.CreateNewPeer();
_grpcPeer.IsConnected = true;
//_nonInterceptedPeer = GrpcTestPeerHelpers.CreateNewPeer("127.0.0.1:2000", false);
//_nonInterceptedPeer.IsConnected = true;
_nonInterceptedPeer = MockServiceClient("127.0.0.1:2000");
_pool.TryAddPeer(_grpcPeer);
}
public LocalFileSystemStorageAdapter(IDataMasterClient dataMaster,
IConfiguration configuration,
ILogger <LocalFileSystemStorageAdapter> logger,
IPeerPool peerPool,
IDictionary <string, int> localFiles,
ActivitySource activitySource)
{
this._dataMaster = dataMaster;
_configuration = configuration;
_logger = logger;
_peerPool = peerPool;
_permanentStorageBasePath = configuration["StorageAdapter:PermStoragePath"];
_localFiles = localFiles;
_useHardLinking = bool.Parse(configuration["UseHardLinking"]);
_activitySource = activitySource;
_localization = ExtractLocalization(configuration);
}
protected void Page_Load(object sender, EventArgs e)
{
IServerResponse res = ServerResponseBase.GetServerResponseInstance();
try
{
IPeerRequest rq = PeerRequestBase.GetRequestInstance(Request.RawUrl);
Trace.Write("Request Object = " + rq);
IPeer peer = PeerBase.GetPeer();
peer.IP = (string.IsNullOrEmpty(rq.IP)) ? Request.UserHostAddress : rq.IP;
peer.Port = rq.Port;
peer.PeerID = rq.PeerID;
IPeerPoolManager manager = PeerPoolManagerBase.GetPeerPoolManager();
IPeerPool pool = manager.GetPeerPoolByInfoHash(rq.InfoHash);
pool.AddPeer(peer);
res.Interval = Convert.ToInt32(ConfigurationManager.AppSettings["Interval"]);
res.MinInterval = Convert.ToInt32(ConfigurationManager.AppSettings["MinInterval"]);
foreach (IPeer p in pool.GetPeerList())
{
if (p.IP == peer.IP && p.Port == peer.Port)
{
continue; // skip the request peer itself
}
res.Peers.Add(p);
}
Response.Clear();
byte[] binRes = res.GetBinaryResponse();
Trace.Write("binRes=" + HexEncoding.ToString(binRes));
Response.BinaryWrite(binRes);
}
catch (Exception Ex)
{
Trace.Write("ERROR: " + Ex);
res.FailureReason = Ex.ToString();
Response.Clear();
Response.Write(res);
}
Response.End();
}
public AdminRpcModule(
IBlockTree blockTree,
INetworkConfig networkConfig,
IPeerPool peerPool,
IStaticNodesManager staticNodesManager,
IEnode enode,
string dataDir,
ManualPruningTrigger pruningTrigger)
{
_enode = enode ?? throw new ArgumentNullException(nameof(enode));
_dataDir = dataDir ?? throw new ArgumentNullException(nameof(dataDir));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_peerPool = peerPool ?? throw new ArgumentNullException(nameof(peerPool));
_networkConfig = networkConfig ?? throw new ArgumentNullException(nameof(networkConfig));
_staticNodesManager = staticNodesManager ?? throw new ArgumentNullException(nameof(staticNodesManager));
_pruningTrigger = pruningTrigger;
BuildNodeInfo();
}
/// <summary>
/// Get the existing peer pool by torrent MD5 info_hash,
/// or create a new peer pool and return if the info_hash is not existing.
/// </summary>
/// <param name="infoHash">Torrent MD5 info_hash</param>
/// <returns>The existing peer pool or new peer pool</returns>
public virtual IPeerPool GetPeerPoolByInfoHash(IInfoHash infoHash)
{
IPeerPool peerPool = null;
lock (this)
{
if (_peerPoolDict.ContainsKey(infoHash.Hex))
{
peerPool = _peerPoolDict[infoHash.Hex].Key;
_peerPoolDict[infoHash.Hex] = new KeyValuePair <IPeerPool, DateTime>(peerPool, DateTime.Now);
}
else
{
peerPool = new PeerPoolBase();
_peerPoolDict.Add(infoHash.Hex, new KeyValuePair <IPeerPool, DateTime>(peerPool, DateTime.Now));
}
Debug.WriteLine(string.Format("[{0}] : _peerPoolDict.Count={1}", this.GetType().FullName, _peerPoolDict.Count));
}
return(peerPool);
}
public void Setup()
{
_blockTree = Build.A.BlockTree().OfChainLength(5).TestObject;
_networkConfig = new NetworkConfig();
IPeerPool peerPool = Substitute.For <IPeerPool>();
ConcurrentDictionary <PublicKey, Peer> dict = new();
dict.TryAdd(TestItem.PublicKeyA, new Peer(new Node(TestItem.PublicKeyA, "127.0.0.1", 30303, true)));
peerPool.ActivePeers.Returns(dict);
IStaticNodesManager staticNodesManager = Substitute.For <IStaticNodesManager>();
Enode enode = new(_enodeString);
_adminRpcModule = new AdminRpcModule(
_blockTree,
_networkConfig,
peerPool,
staticNodesManager,
enode,
_exampleDataDir,
new ManualPruningTrigger());
_serializer = new EthereumJsonSerializer();
}
public NetAppServiceTest(ITestOutputHelper outputHelper) : base(outputHelper)
{
_peerPool = GetRequiredService <IPeerPool>();
_reconnectionService = GetRequiredService <IReconnectionService>();
}
public AuthInterceptor(IPeerPool peerPool)
{
_peerPool = peerPool;
}
public PeerConnectionServiceTests()
{
_connectionService = GetRequiredService <IConnectionService>();
_peerPool = GetRequiredService <IPeerPool>();
}
public PeerPoolTests()
{
_peerPool = GetRequiredService <IPeerPool>();
_blackListProvider = GetRequiredService <IBlackListedPeerProvider>();
}
public SyncStateService(INodeSyncStateProvider syncStateProvider, IBlockchainService blockchainService,
IBlockchainNodeContextService blockchainNodeContextService, IPeerPool peerPool)
{
_syncStateProvider = syncStateProvider;
_blockchainService = blockchainService;
_blockchainNodeContextService = blockchainNodeContextService;
_peerPool = peerPool;
}
public PeerPoolTests()
{
_peerPool = GetRequiredService <IPeerPool>();
}
public PeerInvalidTransactionProcessingService(INetworkService networkService, IPeerPool peerPool,
IPeerInvalidTransactionProvider peerInvalidTransactionProvider)
{
_networkService = networkService;
_peerPool = peerPool;
_peerInvalidTransactionProvider = peerInvalidTransactionProvider;
}
public NetAppServiceTest(ITestOutputHelper outputHelper) : base(outputHelper)
{
_peerPool = GetRequiredService <IPeerPool>();
}
public NetworkServicePropagationTest()
{
_testContext = GetRequiredService <NetworkServicePropagationTestContext>();
_networkService = GetRequiredService <INetworkService>();
_peerPool = GetRequiredService <IPeerPool>();
}
public PeerPoolNotLimitMaxPeerTests()
{
_peerPool = GetRequiredService <IPeerPool>();
}
