Maciej Krüger 8ad4c15562 refactor: use async await (#108)
* chore: upgrade deps

* feat: first iteration of the idea

* feat: iterate a layer deeper

* feat: rewrite handshake

* feat: rewrite propose

* feat: rewrite finish

* feat: rewrite exchange

* feat: rewrite low-level stuff

* feat: work on rewriting tests

* refactor: browser tests

* refactor: .aegir.js

* feat: refactor benchmarks

* fix: try to make it work

* fix: lint

* refactor: move tests

* refactor: switch deps

* refactor: entry file

* refactor: a bit more

* fix: tests

* feat: inital iterables refactor

* refactor: streaming

* refactor: cleanup

* fix: turn bufferlist into buffer

* fix: use errors from interfaces

* refactor: etm

* fix: typo

* fix: .read error

* fix: satisfy output expectations

* fix: it works - WARNING: using varint instead of fixed lp, tests lie

* fix: use errors

* refactor: benchmarks

* fix: add suggestions from review

Co-Authored-By: Jacob Heun <jacobheun@gmail.com>

* fix: upgrade deps and use correct lp-encoder

* refactor: apply changes from review

* refactor: apply changes from review

* refactor: apply changes from review

* chore: remove old tests

test: add support tests back

* test: fix async benchmarks

* chore: clean up deps

* fix: use fixed encoding/decoding everywhere

fix: exchange final nonce handshake over encryption

* test: add verify inbound and outbound secio

* test: verify nonces are boxed

* chore: add node 12 to ci
2019-11-22 14:18:17 -06:00

115 lines
2.3 KiB
JavaScript

'use strict'
/* eslint-disable no-console */
const Benchmark = require('benchmark')
const PeerId = require('peer-id')
const pipe = require('it-pipe')
const { reduce } = require('streaming-iterables')
const DuplexPair = require('it-pair/duplex')
const secio = require('..')
const suite = new Benchmark.Suite('secio')
let peers
async function sendData (a, b, opts) {
opts = Object.assign({ times: 1, size: 100 }, opts)
let i = opts.times
pipe(
function * () {
while (i--) {
yield Buffer.allocUnsafe(opts.size)
}
},
a
)
const res = await pipe(
b,
reduce((acc, val) => acc + val.length, 0)
)
if (res !== opts.times * opts.size) {
throw new Error('Did not receive enough chunks')
}
}
suite.add('create peers for test', {
defer: true,
fn: async (deferred) => {
peers = await Promise.all([
PeerId.createFromJSON(require('./peer-a')),
PeerId.createFromJSON(require('./peer-b'))
])
deferred.resolve()
}
})
suite.add('establish an encrypted channel', {
defer: true,
fn: async (deferred) => {
const p = DuplexPair()
const peerA = peers[0]
const peerB = peers[1]
const [aToB, bToA] = await Promise.all([
secio.secureInbound(peerA, p[0], peerB),
secio.secureOutbound(peerB, p[1], peerA)
])
await sendData(aToB.conn, bToA.conn, {})
deferred.resolve()
}
})
const cases = [
[10, 262144],
[100, 262144],
[1000, 262144]
// [10000, 262144],
// [100000, 262144],
// [1000000, 262144]
]
cases.forEach((el) => {
const times = el[0]
const size = el[1]
suite.add(`send plaintext ${times} x ${size} bytes`, {
defer: true,
fn: async (deferred) => {
const p = DuplexPair()
await sendData(p[0], p[1], { times: times, size: size })
deferred.resolve()
}
})
suite.add(`send encrypted ${times} x ${size} bytes`, {
defer: true,
fn: async (deferred) => {
const p = DuplexPair()
const peerA = peers[0]
const peerB = peers[1]
const [aToB, bToA] = await Promise.all([
secio.secureInbound(peerA, p[0], peerB),
secio.secureOutbound(peerB, p[1], peerA)
])
await sendData(aToB.conn, bToA.conn, { times: times, size: size })
deferred.resolve()
}
})
})
suite.on('cycle', (event) => {
console.log(String(event.target))
})
// run async
suite.run({ async: true })