Added default members to Config, use defaults for CLI, lightserv -> horizontal integration

Author: holgerd77

bin/cli.ts

@@ -30,12 +30,12 @@ const args = require('yargs')
     syncmode: {
       describe: 'Blockchain sync mode',
       choices: ['light', 'fast'],
-      default: 'fast',
+      default: Config.SYNCMODE_DEFAULT,
     },
     lightserv: {
       describe: 'Serve light peer requests',
       boolean: true,
-      default: false,
+      default: Config.LIGHTSERV_DEFAULT,
     },
     datadir: {
       describe: 'Data directory for the blockchain',
@@ -68,12 +68,12 @@ const args = require('yargs')
     minPeers: {
       describe: 'Peers needed before syncing',
       number: true,
-      default: 2,
+      default: Config.MINPEERS_DEFAULT,
     },
     maxPeers: {
       describe: 'Maximum peers to sync with',
       number: true,
-      default: 25,
+      default: Config.MINPEERS_DEFAULT,
     },
     params: {
       describe: 'Path to chain parameters json file',
@@ -85,7 +85,7 @@ const logger = getLogger({ loglevel: args.loglevel })
 
 async function runNode(options: any) {
   logger.info('Initializing Ethereumjs client...')
-  if (options.lightserv) {
+  if (options.config.lightserv) {
     logger.info(`Serving light peer requests`)
   }
   const node = new Node(options)
@@ -130,6 +130,7 @@ async function run() {
     common,
     logger,
     syncmode: args.syncmode,
+    lightserv: args.lightserv,
     minPeers: args.minPeers,
     maxPeers: args.maxPeers,
   })
@@ -153,7 +154,6 @@ async function run() {
   const options = {
     config,
     servers,
-    lightserv: args.lightserv,
     db: level(dataDir),
     rpcport: args.rpcport,
     rpcaddr: args.rpcaddr,

lib/config.ts

@@ -6,23 +6,37 @@ export interface Options {
   /**
    * Specify the chain and hardfork by passing a Common instance.
    *
-   * If not provided this defaults to chain `mainnet` and hardfork `chainstart`
+   * Default: chain `mainnet` and hardfork `chainstart`
    */
   common?: Common
   /**
    * The logger instance with the log level set (winston)
+   * 
+   * Default: Logger with loglevel 'debug'
    */
   logger?: Logger
   /**
    * Synchronization mode ('fast' or 'light')
+   * 
+   * Default: 'fast'
    */
   syncmode?: string
+  /**
+   * Serve light peer requests
+   * 
+   * Default: false
+   */
+  lightserv?: boolean
   /**
    * Number of peers needed before syncing
+   * 
+   * Default: 2
    */
   minPeers?: number
   /**
    * Maximum peers allowed
+   * 
+   * Default: 25
    */
   maxPeers?: number
 }
@@ -31,21 +45,29 @@ export class Config {
   public common: Common
   public logger: Logger
   public syncmode: string
+  public lightserv: boolean
   public minPeers: number
   public maxPeers: number
 
+  public static readonly COMMON_DEFAULT = new Common({ chain: 'mainnet', hardfork: 'chainstart' })
+  public static readonly LOGGER_DEFAULT = defaultLogger
+  public static readonly SYNCMODE_DEFAULT = 'fast'
+  public static readonly LIGHTSERV_DEFAULT = false
+  public static readonly MINPEERS_DEFAULT = 2
+  public static readonly MAXPEERS_DEFAULT = 25
+
+
   constructor(options: Options = {}) {
     // Initialize Common with an explicit 'chainstart' HF set until
     // hardfork awareness is implemented within the library
     // Also a fix for https://github.com/ethereumjs/ethereumjs-vm/issues/757
 
     // TODO: map chainParams (and lib/util.parseParams) to new Common format
-    this.common = options.common
-      ? options.common
-      : new Common({ chain: 'mainnet', hardfork: 'chainstart' })
-    this.logger = options.logger ? options.logger : defaultLogger
-    this.syncmode = options.syncmode ? options.syncmode : 'fast'
-    this.minPeers = options.minPeers ? options.minPeers : 3
-    this.maxPeers = options.maxPeers ? options.maxPeers : 25
+    this.common = options.common ? options.common : Config.COMMON_DEFAULT
+    this.logger = options.logger ? options.logger : Config.LOGGER_DEFAULT
+    this.syncmode = options.syncmode ? options.syncmode : Config.SYNCMODE_DEFAULT
+    this.lightserv = options.lightserv ? options.lightserv : Config.LIGHTSERV_DEFAULT
+    this.minPeers = options.minPeers ? options.minPeers : Config.MINPEERS_DEFAULT
+    this.maxPeers = options.maxPeers ? options.maxPeers : Config.MAXPEERS_DEFAULT
   }
 }

lib/node.ts

@@ -21,6 +21,10 @@ export default class Node extends events.EventEmitter {
    * @param {Object}   options constructor parameters
    * @param {Config}   [options.config] Client configuration
    * @param {LevelDB}  [options.db=null] blockchain database
+<<<<<<< HEAD
+=======
+   * @param {Server[]} [options.servers=[]] list of servers to use
+>>>>>>> Added default members to Config, use defaults for CLI, lightserv -> horizontal integration
    * @param {Object[]} [options.bootnodes] list of bootnodes to use for discovery
    * @param {string[]} [options.clientFilter] list of supported clients
    * @param {number}   [options.refreshInterval] how often to discover new peers

lib/service/fastethereumservice.ts

@@ -5,29 +5,22 @@ import { LesProtocol } from '../net/protocol/lesprotocol'
 import { Peer } from '../net/peer/peer'
 import { BoundProtocol } from '../net/protocol'
 
-const defaultOptions = {
-  lightserv: false,
-}
-
 /**
  * Ethereum service
  * @memberof module:service
  */
 export class FastEthereumService extends EthereumService {
-  public lightserv: any
+
   /**
    * Create new ETH service
    * @param {Object}   options constructor parameters
    * @param {Config}   [options.config] Client configuration
    * @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.interval] sync retry interval
    */
   constructor(options?: any) {
     super(options)
-    options = { ...defaultOptions, ...options }
-    this.lightserv = options.lightserv
     this.init()
   }
 
@@ -53,7 +46,7 @@ export class FastEthereumService extends EthereumService {
         timeout: this.timeout,
       }),
     ]
-    if (this.lightserv) {
+    if (this.config.lightserv) {
       protocols.push(
         new LesProtocol({
           config: this.config,
@@ -106,7 +99,7 @@ export class FastEthereumService extends EthereumService {
    * @param  peer peer
    */
   async handleLes(message: any, peer: Peer): Promise<void> {
-    if (message.name === 'GetBlockHeaders' && this.lightserv) {
+    if (message.name === 'GetBlockHeaders' && this.config.lightserv) {
       const { reqId, block, max, skip, reverse } = message.data
       const bv = this.flow.handleRequest(peer, message.name, max)
       if (bv < 0) {

test/integration/fastethereumservice.ts

@@ -12,9 +12,8 @@ tape('[Integration:FastEthereumService]', async (t) => {
     const server = new MockServer()
     const chain = new MockChain()
     const service = new FastEthereumService({
-      config: new Config(),
+      config: new Config({ lightserv: true }),
       servers: [server],
-      lightserv: true,
       chain,
     })
     await service.open()

test/integration/lightsync.ts

@@ -22,9 +22,8 @@ tape('[Integration:LightSync]', async (t) => {
     const service =
       options.syncmode === 'fast'
         ? new FastEthereumService({
-            config: new Config({ minPeers: 1 }),
+            config: new Config({ lightserv: true, minPeers: 1 }),
             servers: [server],
-            lightserv: true,
             interval: options.interval || 10,
             chain,
           })

test/service/fastethereumservice.ts

@@ -38,7 +38,7 @@ tape.skip('[FastEthereumService]', (t) => {
     let service = new FastEthereumService({ config: new Config() })
     t.ok(service.protocols[0] instanceof EthProtocol, 'fast protocols')
     t.notOk(service.protocols[1], 'no light protocol')
-    service = new FastEthereumService({ lightserv: true })
+    service = new FastEthereumService({ config: new Config({ lightserv: true }) })
     t.ok(service.protocols[0] instanceof EthProtocol, 'fast protocols')
     t.ok(service.protocols[1] instanceof LesProtocol, 'lightserv protocols')
     t.end()