grenache-grape/test/mininet/horde.js

Granache Grape - DHT for micro-services

const tapenet = require('tapenet')
const bootstrap = require('./helpers/bootstrap')

const nodes = 50
const { h1, h2 } = tapenet.topologies.basic(nodes)

tapenet(nodes + ' grapes, worker + client, 1000 requests', function (t) {
  bootstrap(tapenet, t)
  horde(t)

  t.run(h1, function () {
    tapenet.on('horde', function (bootstrap) {
      const grape = require('./helpers/grape')
      const { PeerRPCServer } = require('grenache-nodejs-http')
      const Link = require('grenache-nodejs-link')

      t.pass('horde is ready')
      grape(bootstrap, () => {
        const link = new Link({ grape: 'http://127.0.0.1:40001' })
        link.start()

        const peer = new PeerRPCServer(link, {})
        peer.init()

        const service = peer.transport('server')
        service.listen(5000)

        link.startAnnouncing('rpc_test', service.port, { timeout: 20000 }, (err) => {
          t.error(err, 'no announce error')
          h1.emit('service', bootstrap)
        })

        service.on('request', (rid, key, payload, handler) => {
          handler.reply(null, payload + ': world')
        })
      })
    })
  })

  t.run(h2, function () {
    h1.on('service', function (bootstrap) {
      const grape = require('./helpers/grape')
      const { PeerRPCClient } = require('grenache-nodejs-http')
      const Link = require('grenache-nodejs-link')
      t.pass('bootstraping client')
      grape(bootstrap, () => {
        const link = new Link({ grape: 'http://127.0.0.1:40001' })
        link.start()

        const peer = new PeerRPCClient(link, {})
        const started = Date.now()
        const rts = 1000
        const expected = []
        const actual = []

        t.pass('client bootstrapped, running requests')
        peer.init()
        requestTimes(rts)

        function requestTimes (n) {
          if (n === 0) {
            t.same(actual, expected, 'correct data returned in correct order')
            t.pass(`${rts} round trips took ${Date.now() - started} ms`)
            return t.end()
          }

          const payload = 'hello-' + n
          expected.push(payload + ': world')

          peer.request('rpc_test', payload, { timeout: 10000 }, (err, data) => {
            if (err) {
              t.error(err, 'no error')
              t.end()
              return
            }
            actual.push(data)
            requestTimes(n - 1)
          })
        }
      })
    })
  })
})

function horde (t) {
  // first two hosts are service + client
  // next two are bootstrappers
  for (let i = 4; i < nodes; i++) {
    t.run(tapenet.hosts[i], `
      const grape = require('./helpers/grape')
      let missing = ${nodes} - 4
      let nodes = null

      tapenet.on('horde:grape', () => {
        missing--
        if (!missing && ${i} === 4) tapenet.emit('horde', nodes)
      })

      tapenet.on('bootstrap', bootstrap => {
        nodes = bootstrap
        grape(bootstrap, {ready: true}, () => {
          tapenet.emit('horde:grape')
        })
      })
    `)
  }
}