Merge pull request #139 from ethereumjs/admin-rpc

Add admin_* RPC

Author: holgerd77

lib/net/server/rlpxserver.ts

@@ -42,6 +42,7 @@ export class RlpxServer extends Server {
 
   public rlpx: Devp2pRLPx | null = null
   public dpt: Devp2pDPT | null = null
+  public ip: string = '::'
 
   /**
    * Create new DevP2P/RLPx server
@@ -59,6 +60,8 @@ export class RlpxServer extends Server {
     super(options)
     options = { ...defaultOptions, ...options }
 
+    // TODO: get the external ip from the upnp service
+    this.ip = '::'
     this.port = options.port
     this.key = options.key
     this.clientFilter = options.clientFilter
@@ -83,6 +86,30 @@ export class RlpxServer extends Server {
     }
   }
 
+  /**
+   * Return Rlpx info
+   */
+  getRlpxInfo() {
+    // TODO: return undefined? note that this.rlpx might be undefined if called before initRlpx
+    if (!this.rlpx) {
+      return {
+        enode: undefined,
+        id: undefined,
+        ip: this.ip,
+        listenAddr: `[${this.ip}]:${this.port}`,
+        ports: { discovery: this.port, listener: this.port },
+      }
+    }
+    const id = this.rlpx._id.toString('hex')
+    return {
+      enode: `enode://${id}@[${this.ip}]:${this.port}`,
+      id: id,
+      ip: this.ip,
+      listenAddr: `[${this.ip}]:${this.port}`,
+      ports: { discovery: this.port, listener: this.port },
+    }
+  }
+
   /**
    * Start Devp2p/RLPx server. Returns a promise that resolves once server has been started.
    * @return Resolves with true if server successfully started
@@ -239,7 +266,7 @@ export class RlpxServer extends Server {
     this.rlpx.on('listening', () => {
       this.emit('listening', {
         transport: this.name,
-        url: `enode://${(this.rlpx as Devp2pRLPx)._id.toString('hex')}@[::]:${this.port}`,
+        url: this.getRlpxInfo().enode,
       })
     })
 

lib/rpc/modules/admin.ts

@@ -0,0 +1,72 @@
+import { bufferToHex } from 'ethereumjs-util'
+import { Chain } from '../../blockchain'
+import { EthProtocol, Protocol } from '../../net/protocol'
+import Node from '../../node'
+import { Service } from '../../service'
+import { getClientVersion } from '../../util'
+import { middleware } from '../validation'
+
+/**
+ * admin_* RPC module
+ * @memberof module:rpc/modules
+ */
+export class Admin {
+  readonly _chain: Chain
+  readonly _node: Node
+  readonly _ethProtocol: EthProtocol
+
+  /**
+   * Create admin_* RPC module
+   * @param {Node} Node to which the module binds
+   */
+  constructor(node: Node) {
+    const service = node.services.find((s: Service) => s.name === 'eth')
+    this._chain = service.chain
+    this._node = node
+    this._ethProtocol = service.protocols.find((p: Protocol) => p.name === 'eth')
+
+    this.nodeInfo = middleware(this.nodeInfo.bind(this), 0, [])
+  }
+
+  /**
+   * Returns information about the currently running node.
+   * see for reference: https://geth.ethereum.org/docs/rpc/ns-admin#admin_nodeinfo
+   * @param {*} [params] An empty array
+   * @param {*} [cb] A function with an error object as the first argument and the result as the second
+   */
+  async nodeInfo(params: any, cb: Function) {
+    const rlpxInfo = this._node.server('rlpx').getRlpxInfo()
+    const { enode, id, ip, listenAddr, ports } = rlpxInfo
+    const { discovery, listener } = ports
+    const clientName = getClientVersion()
+
+    // TODO version not present in reference..
+    // const ethVersion = Math.max.apply(Math, this._ethProtocol.versions)
+    const latestHeader = (this._chain as any)._headers.latest
+    const difficulty = latestHeader?.difficulty || 0 // should be number
+    const genesis = bufferToHex(this._chain.genesis.hash)
+    const head = bufferToHex(latestHeader?.mixHash || null)
+    const network = this._chain.networkId
+
+    const nodeInfo = {
+      name: clientName,
+      enode,
+      id,
+      ip,
+      listenAddr,
+      ports: {
+        discovery,
+        listener,
+      },
+      protocols: {
+        eth: {
+          difficulty,
+          genesis,
+          head,
+          network,
+        },
+      },
+    }
+    return cb(null, nodeInfo)
+  }
+}

lib/rpc/modules/index.ts

@@ -1,4 +1,6 @@
-export const list = ['Eth', 'Web3', 'Net']
+export const list = ['Eth', 'Web3', 'Net', 'Admin']
+
 export * from './eth'
 export * from './web3'
 export * from './net'
+export * from './admin'

lib/rpc/modules/web3.ts

@@ -1,6 +1,6 @@
 import { middleware, validators } from '../validation'
 import { addHexPrefix, keccak, toBuffer } from 'ethereumjs-util'
-import { platform } from 'os'
+import { getClientVersion } from '../../util'
 
 /**
  * web3_* RPC module
@@ -29,9 +29,7 @@ export class Web3 {
    * client version as the second argument
    */
   clientVersion(_params = [], cb: (err: null, version: string) => void) {
-    const packageVersion = require('../../../package.json').version
-    const { version } = process
-    const ethJsVersion = `EthereumJS/${packageVersion}/${platform()}/node${version.substring(1)}`
+    const ethJsVersion = getClientVersion()
     cb(null, ethJsVersion)
   }
 

lib/util/index.ts

@@ -1,9 +1,16 @@
 /**
  * @module util
  */
+import { platform } from 'os'
+import { version as packageVersion } from '../../package.json'
 
 export * from './parse'
 
 export function short(buffer: Buffer): string {
   return buffer.toString('hex').slice(0, 8) + '...'
 }
+
+export function getClientVersion() {
+  const { version } = process
+  return `EthereumJS/${packageVersion}/${platform()}/node${version.substring(1)}`
+}

test/net/server/rlpxserver.ts

@@ -72,6 +72,42 @@ tape('[RlpxServer]', (t) => {
     t.end()
   })
 
+  t.test('should return rlpx server info', async (t) => {
+    const mockId = '123'
+    const server = new RlpxServer({
+      bootnodes: '10.0.0.1:1234,10.0.0.2:1234',
+    })
+    server.initDpt = td.func()
+    server.initRlpx = td.func()
+    server.dpt = td.object()
+    server.rlpx = td.object({
+      _id: mockId,
+      destroy: td.func(),
+    })
+    td.when(
+      server.dpt?.bootstrap({ address: '10.0.0.1', udpPort: '1234', tcpPort: '1234' })
+    ).thenResolve()
+    td.when(
+      server.dpt?.bootstrap({ address: '10.0.0.2', udpPort: '1234', tcpPort: '1234' })
+    ).thenReject('err0')
+    server.on('error', (err) => t.equals(err, 'err0', 'got error'))
+    await server.start()
+    const nodeInfo = server.getRlpxInfo()
+    t.deepEqual(
+      nodeInfo,
+      {
+        enode: `enode://${mockId}@[::]:30303`,
+        id: mockId,
+        ip: '::',
+        listenAddr: '[::]:30303',
+        ports: { discovery: 30303, listener: 30303 },
+      },
+      'get nodeInfo'
+    )
+    await server.stop()
+    t.end()
+  })
+
   t.test('should handle errors', (t) => {
     t.plan(3)
     let count = 0

test/rpc/admin/nodeInfo.ts

@@ -0,0 +1,21 @@
+import tape from 'tape'
+import { startRPC, createManager, createNode, params, baseRequest } from '../helpers'
+
+const method = 'admin_nodeInfo'
+
+tape(method, (t) => {
+  const manager = createManager(createNode({ opened: true }))
+  const server = startRPC(manager.getMethods())
+
+  const req = params(method, [])
+
+  const expectRes = (res: any) => {
+    const { result } = res.body
+    if (result) {
+      t.pass('admin_nodeInfo returns a value')
+    } else {
+      throw new Error('no return value')
+    }
+  }
+  baseRequest(t, server, req, 200, expectRes)
+})

test/rpc/helpers.ts

@@ -6,6 +6,7 @@ import { RPCManager as Manager } from '../../lib/rpc'
 import * as Logger from '../../lib/logging'
 import { blockChain } from './blockChainStub'
 import { Chain } from '../../lib/blockchain/chain'
+import { RlpxServer } from '../../lib/net/server/rlpxserver'
 import Blockchain from '@ethereumjs/blockchain'
 
 const config: any = { loglevel: 'error' }
@@ -36,6 +37,11 @@ export function createNode(nodeConfig?: any) {
     ethProtocolVersions: [63],
   }
   const trueNodeConfig = { ...defaultNodeConfig, ...nodeConfig }
+  const servers = [
+    new RlpxServer({
+      bootnodes: '10.0.0.1:1234,10.0.0.2:1234',
+    }),
+  ]
   return {
     services: [
       {
@@ -50,8 +56,12 @@ export function createNode(nodeConfig?: any) {
         ],
       },
     ],
+    servers,
     common: trueNodeConfig.commonChain,
     opened: trueNodeConfig.opened,
+    server: (name: string) => {
+      return servers.find((s) => s.name === name)
+    },
   }
 }