Config -> syncmode, minPeers, maxPeers: horizontal integration

Author: holgerd77

lib/net/peerpool.ts

@@ -4,7 +4,6 @@ import { Peer } from './peer/peer'
 
 const defaultOptions = {
   servers: [],
-  maxPeers: 25,
 }
 
 /**
@@ -27,8 +26,6 @@ export class PeerPool extends EventEmitter {
   public config: Config
 
   private servers: any[]
-  private logger: any
-  private maxPeers: number
   private pool: Map<string, Peer>
   private noPeerPeriods: number
   private opened: boolean
@@ -38,7 +35,6 @@ export class PeerPool extends EventEmitter {
    * Create new peer pool
    * @param {Object}   options constructor parameters
    * @param {Server[]} options.servers servers to aggregate peers from
-   * @param {number}   [options.maxPeers=25] maximum peers allowed
    */
   constructor(options: any) {
     super()
@@ -48,7 +44,6 @@ export class PeerPool extends EventEmitter {
     options = { ...defaultOptions, ...options }
 
     this.servers = options.servers
-    this.maxPeers = options.maxPeers
     this.pool = new Map<string, Peer>()
     this.noPeerPeriods = 0
     this.opened = false
@@ -136,7 +131,7 @@ export class PeerPool extends EventEmitter {
    * @param  {Peer} peer
    */
   connected(peer: Peer) {
-    if (this.size >= this.maxPeers) return
+    if (this.size >= this.config.maxPeers) return
     peer.on('message', (message: any, protocol: string) => {
       if (this.pool.get(peer.id)) {
         this.emit('message', message, protocol, peer)

lib/net/server/libp2pserver.ts

@@ -28,7 +28,6 @@ export class Libp2pServer extends Server {
    * @param {Object}   options constructor parameters
    * @param {Object[]} [options.bootnodes] list of bootnodes to use for discovery (can be
    * a comma separated string or list)
-   * @param {number}   [options.maxPeers=25] maximum peers allowed
    * @param {multiaddr[]}   [options.multiaddrs] multiaddrs to listen on (can be
    * a comma separated string or list)
    * @param {Buffer}   [options.key] private key to use for server

lib/net/server/rlpxserver.ts

@@ -49,7 +49,6 @@ export class RlpxServer extends Server {
    * @param {Object}   options constructor parameters
    * @param {Object[]} [options.bootnodes] list of bootnodes to use for discovery (can be
    * a comma separated string or list)
-   * @param {number}   [options.maxPeers=25] maximum peers allowed
    * @param {number}   [options.port=null] local port to listen on
    * @param {Buffer}   [options.key] private key to use for server
    * @param {string[]} [options.clientFilter] list of supported clients
@@ -214,7 +213,7 @@ export class RlpxServer extends Server {
   initRlpx() {
     this.rlpx = new Devp2pRLPx(this.key as Buffer, {
       dpt: this.dpt as Devp2pDPT,
-      maxPeers: this.maxPeers,
+      maxPeers: this.config.maxPeers,
       capabilities: RlpxPeer.capabilities(Array.from(this.protocols)),
       remoteClientIdFilter: this.clientFilter,
       listenPort: this.port,

lib/net/server/server.ts

@@ -1,11 +1,8 @@
 import { EventEmitter } from 'events'
 import { Protocol } from '../protocol/protocol'
-import { defaultLogger } from '../../logging'
 import { Config } from '../../config'
 
 const defaultOptions = {
-  logger: defaultLogger,
-  maxPeers: 25,
   refreshInterval: 30000,
 }
 
@@ -19,7 +16,6 @@ export class Server extends EventEmitter {
   public key: Buffer | string = ''
   public bootnodes: any | string = ''
 
-  protected maxPeers: number
   protected refreshInterval: number
   protected protocols: Set<Protocol>
 
@@ -32,7 +28,6 @@ export class Server extends EventEmitter {
 
     options = { ...defaultOptions, ...options }
 
-    this.maxPeers = options.maxPeers
     this.refreshInterval = options.refreshInterval
     this.protocols = new Set()
     this.started = false

lib/service/ethereumservice.ts

@@ -21,6 +21,7 @@ export class EthereumService extends Service {
   public synchronizer: any
 
   /**
+<<<<<<< HEAD
  * Create new ETH service
  * @param {Object}   options constructor parameters
  * @param {Config}   [options.config] Client configuration
@@ -29,12 +30,26 @@ export class EthereumService extends Service {
  * @param {number}   [options.timeout] protocol timeout
  * @param {number}   [options.interval] sync retry interval
  */
+=======
+   * Create new ETH service
+   * @param {Object}   options constructor parameters
+   * @param {Server[]} options.servers servers to run service on
+   * @param {Chain}    [options.chain] blockchain
+   * @param {LevelDB}  [options.db=null] blockchain database
+   * @param {number}   [options.timeout] protocol timeout
+   * @param {number}   [options.interval] sync retry interval
+   */
+>>>>>>> Config -> syncmode, minPeers, maxPeers: horizontal integration
   constructor(options?: any) {
     options = { ...defaultOptions, ...options }
     super(options)
 
     this.flow = new FlowControl(options)
+<<<<<<< HEAD
     this.chain = options.chain ?? new Chain(options)
+=======
+    this.chain = options.chain || new Chain(options)
+>>>>>>> Config -> syncmode, minPeers, maxPeers: horizontal integration
     this.interval = options.interval
     this.timeout = options.timeout
     this.synchronizer = null

lib/service/fastethereumservice.ts

@@ -21,8 +21,6 @@ export class FastEthereumService extends EthereumService {
    * @param {Server[]} options.servers servers to run service on
    * @param {boolean}  [options.lightserv=false] serve LES requests
    * @param {Chain}    [options.chain] blockchain
-   * @param {number}   [options.minPeers=3] number of peers needed before syncing
-   * @param {number}   [options.maxPeers=25] maximum peers allowed
    * @param {number}   [options.interval] sync retry interval
    */
   constructor(options?: any) {
@@ -37,8 +35,6 @@ export class FastEthereumService extends EthereumService {
     this.synchronizer = new FastSynchronizer({
       pool: this.pool,
       chain: this.chain,
-      common: this.config.common,
-      minPeers: this.minPeers,
       interval: this.interval,
     })
   }

lib/service/lightethereumservice.ts

@@ -13,8 +13,6 @@ export class LightEthereumService extends EthereumService {
    * @param {Object}   options constructor parameters
    * @param {Server[]} options.servers servers to run service on
    * @param {Chain}    [options.chain] blockchain
-   * @param {number}   [options.minPeers=3] number of peers needed before syncing
-   * @param {number}   [options.maxPeers=25] maximum peers allowed
    * @param {number}   [options.interval] sync retry interval
    */
   constructor(options?: any) {
@@ -27,8 +25,6 @@ export class LightEthereumService extends EthereumService {
     this.synchronizer = new LightSynchronizer({
       pool: this.pool,
       chain: this.chain,
-      common: this.config.common,
-      minPeers: this.minPeers,
       flow: this.flow,
       interval: this.interval,
     })

lib/service/service.ts

@@ -4,7 +4,6 @@ import { Peer } from '../net/peer/peer'
 import { Config } from '../config'
 
 const defaultOptions = {
-  maxPeers: 25,
   servers: [],
 }
 
@@ -24,7 +23,6 @@ export class Service extends events.EventEmitter {
    * Create new service and associated peer pool
    * @param {Object}     options constructor parameters
    * @param {Server[]}   [options.servers=[]] servers to run service on
-   * @param {number}     [options.maxPeers=25] maximum peers allowed
    */
   constructor(options?: any) {
     super()
@@ -37,7 +35,6 @@ export class Service extends events.EventEmitter {
     this.servers = options.servers
     this.pool = new PeerPool({
       servers: this.servers,
-      maxPeers: options.maxPeers,
     })
     this.pool.on('message', async (message: any, protocol: string, peer: Peer) => {
       if (this.running) {

lib/sync/fastsync.ts

@@ -42,7 +42,7 @@ export class FastSynchronizer extends Synchronizer {
   best(): Peer | undefined {
     let best
     const peers = this.pool.peers.filter(this.syncable.bind(this))
-    if (peers.length < this.minPeers && !this.forceSync) return
+    if (peers.length < this.config.minPeers && !this.forceSync) return
     for (const peer of peers) {
       if (peer.eth && peer.eth.status) {
         const td = peer.eth.status.td

lib/sync/lightsync.ts

@@ -40,7 +40,7 @@ export class LightSynchronizer extends Synchronizer {
   best(): Peer | undefined {
     let best
     const peers = this.pool.peers.filter(this.syncable.bind(this))
-    if (peers.length < this.minPeers && !this.forceSync) return
+    if (peers.length < this.config.minPeers && !this.forceSync) return
     for (const peer of peers) {
       if (peer.les) {
         const td = peer.les.status.headTd