move to sessions
This commit is contained in:
Mathias Buus
parent
717dbd0e50
commit
576e08180f
|
|
@ -1,4 +1,5 @@
|
|||
node_modules
|
||||
sandbox.js
|
||||
sandbox.mjs
|
||||
sandbox
|
||||
coverage
|
||||
|
|
|
|||
820
index.js
820
index.js
|
|
@ -1,410 +1,626 @@
|
|||
const c = require('compact-encoding')
|
||||
const b4a = require('b4a')
|
||||
const c = require('compact-encoding')
|
||||
const queueTick = require('queue-tick')
|
||||
const safetyCatch = require('safety-catch')
|
||||
const { addProtocol } = require('./messages')
|
||||
|
||||
const EMPTY = []
|
||||
const MAX_BUFFERED = 32768
|
||||
const MAX_BACKLOG = 256
|
||||
|
||||
class Protocol {
|
||||
constructor (mux) {
|
||||
this.mux = mux
|
||||
|
||||
this.name = null
|
||||
this.version = null
|
||||
this.messages = EMPTY
|
||||
this.context = null
|
||||
this.offset = 0
|
||||
this.length = 0
|
||||
this.opened = false
|
||||
this.corked = false
|
||||
|
||||
this.remoteVersion = null
|
||||
this.remoteOffset = 0
|
||||
this.remoteEnd = 0
|
||||
this.remoteOpened = false
|
||||
this.remoteClosed = false
|
||||
|
||||
this.onremoteopen = noop
|
||||
this.onremoteclose = noop
|
||||
}
|
||||
|
||||
_attach ({ name, version = { major: 0, minor: 0 }, messages = 0, context = null, onremoteopen = noop, onremoteclose = noop }) {
|
||||
const opened = this.opened
|
||||
|
||||
this.name = name
|
||||
this.version = version
|
||||
this.messages = new Array(messages)
|
||||
class Session {
|
||||
constructor (mux, info, protocol, id, context, messages, onopen, onclose, ondestroy) {
|
||||
this.protocol = protocol
|
||||
this.id = id
|
||||
this.context = context
|
||||
this.offset = this.mux.offset
|
||||
this.length = messages
|
||||
this.messages = []
|
||||
this.remoteMessages = this.messages
|
||||
|
||||
this.opened = false
|
||||
this.closed = false
|
||||
this.destroyed = false
|
||||
|
||||
this.onopen = onopen
|
||||
this.onclose = onclose
|
||||
this.ondestroy = ondestroy
|
||||
|
||||
this._mux = mux
|
||||
this._info = info
|
||||
this._localId = 0
|
||||
this._remoteId = 0
|
||||
this._active = 0
|
||||
this._extensions = null
|
||||
|
||||
this._decBound = this._dec.bind(this)
|
||||
this._decAndDestroyBound = this._decAndDestroy.bind(this)
|
||||
|
||||
for (const m of messages) this.addMessage(m)
|
||||
}
|
||||
|
||||
_open () {
|
||||
const id = this._mux._free.length > 0
|
||||
? this._mux._free.pop()
|
||||
: this._mux._local.push(null) - 1
|
||||
|
||||
this._info.opened++
|
||||
this._localId = id + 1
|
||||
this._mux._local[id] = this
|
||||
|
||||
const state = { buffer: null, start: 2, end: 2 }
|
||||
|
||||
c.string.preencode(state, this.protocol)
|
||||
c.buffer.preencode(state, this.id)
|
||||
c.uint.preencode(state, this._localId)
|
||||
|
||||
state.buffer = this._mux._alloc(state.end)
|
||||
|
||||
state.buffer[0] = 0
|
||||
state.buffer[1] = 1
|
||||
c.string.encode(state, this.protocol)
|
||||
c.buffer.encode(state, this.id)
|
||||
c.uint.encode(state, this._localId)
|
||||
|
||||
this._mux._write0(state.buffer)
|
||||
}
|
||||
|
||||
_dec () {
|
||||
if (--this._active === 0 && this.closed === true) this._destroy()
|
||||
}
|
||||
|
||||
_decAndDestroy (err) {
|
||||
this._dec()
|
||||
this._mux._safeDestroy(err)
|
||||
}
|
||||
|
||||
_fullyOpenSoon () {
|
||||
this._mux._remote[this._remoteId - 1].session = this
|
||||
queueTick(this._fullyOpen.bind(this))
|
||||
}
|
||||
|
||||
_fullyOpen () {
|
||||
if (this.opened === true || this.closed === true) return
|
||||
|
||||
const remote = this._mux._remote[this._remoteId - 1]
|
||||
|
||||
this.opened = true
|
||||
this.corked = false
|
||||
this._track(this.onopen())
|
||||
|
||||
this.onremoteopen = onremoteopen
|
||||
this.onremoteclose = onremoteclose
|
||||
|
||||
return !opened
|
||||
remote.session = this
|
||||
if (remote.pending !== null) this._drain(remote)
|
||||
}
|
||||
|
||||
_nextMessage () {
|
||||
for (let i = this.messages.length - 1; i >= 0; i--) {
|
||||
if (this.messages[i] === undefined && (i === 0 || this.messages[i - 1] !== undefined)) {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1
|
||||
_drain (remote) {
|
||||
for (let i = 0; i < remote.pending.length; i++) {
|
||||
const p = remote.pending[i]
|
||||
this._mux._buffered -= byteSize(p.state)
|
||||
this._recv(p.type, p.state)
|
||||
}
|
||||
|
||||
addMessage ({ type = this._nextMessage(), encoding = c.binary, onmessage = noop } = {}) {
|
||||
if (type < 0 || type >= this.messages.length) {
|
||||
throw new Error('Invalid type, must be <= ' + this.messages.length)
|
||||
remote.pending = null
|
||||
this._mux._resumeMaybe()
|
||||
}
|
||||
|
||||
const t = this.offset + type
|
||||
const send = (message) => this.opened && this.mux._push(t, m.encoding, message)
|
||||
const m = this.messages[type] = { encoding, onmessage, send }
|
||||
_track (p) {
|
||||
if (isPromise(p) === true) {
|
||||
this._active++
|
||||
p.then(this._decBound, this._decAndDestroyBound)
|
||||
}
|
||||
}
|
||||
|
||||
_close (isRemote) {
|
||||
if (this.closed === true) return
|
||||
this.closed = true
|
||||
|
||||
this._info.opened--
|
||||
|
||||
if (this._remoteId > 0) {
|
||||
this._mux._remote[this._remoteId - 1] = null
|
||||
this._remoteId = 0
|
||||
// If remote has acked, we can reuse the local id now
|
||||
// otherwise, we need to wait for the "ack" to arrive
|
||||
this._mux._free.push(this._localId - 1)
|
||||
}
|
||||
|
||||
this._mux._local[this._localId - 1] = null
|
||||
this._localId = 0
|
||||
|
||||
this._mux._gc(this._info)
|
||||
this._track(this.onclose(isRemote))
|
||||
|
||||
if (this._active === 0) this._destroy()
|
||||
}
|
||||
|
||||
_destroy () {
|
||||
if (this.destroyed === true) return
|
||||
this.destroyed = true
|
||||
this._track(this.ondestroy())
|
||||
}
|
||||
|
||||
_recv (type, state) {
|
||||
if (type < this.remoteMessages.length) {
|
||||
this.remoteMessages[type].recv(state, this)
|
||||
}
|
||||
}
|
||||
|
||||
cork () {
|
||||
this._mux.cork()
|
||||
}
|
||||
|
||||
uncork () {
|
||||
this._mux.uncork()
|
||||
}
|
||||
|
||||
close () {
|
||||
if (this.closed === true) return
|
||||
|
||||
const state = { buffer: null, start: 2, end: 2 }
|
||||
|
||||
c.uint.preencode(state, this._localId)
|
||||
|
||||
state.buffer = this._mux._alloc(state.end)
|
||||
|
||||
state.buffer[0] = 0
|
||||
state.buffer[1] = 3
|
||||
c.uint.encode(state, this._localId)
|
||||
|
||||
this._close(false)
|
||||
this._mux._write0(state.buffer)
|
||||
}
|
||||
|
||||
addMessage (opts) {
|
||||
if (!opts) return this._skipMessage()
|
||||
|
||||
const type = this.messages.length
|
||||
const encoding = opts.encoding || c.raw
|
||||
const onmessage = opts.onmessage || noop
|
||||
|
||||
const s = this
|
||||
const typeLen = encodingLength(c.uint, type)
|
||||
|
||||
const m = {
|
||||
type,
|
||||
encoding,
|
||||
onmessage,
|
||||
recv (state, session) {
|
||||
session._track(m.onmessage(encoding.decode(state), session))
|
||||
},
|
||||
send (m, session = s) {
|
||||
if (session.closed === true) return false
|
||||
|
||||
const mux = session._mux
|
||||
const state = { buffer: null, start: 0, end: typeLen }
|
||||
|
||||
if (mux._batch !== null) {
|
||||
encoding.preencode(state, m)
|
||||
state.buffer = mux._alloc(state.end)
|
||||
|
||||
c.uint.encode(state, type)
|
||||
encoding.encode(state, m)
|
||||
|
||||
mux._pushBatch(session._localId, state.buffer)
|
||||
return true
|
||||
}
|
||||
|
||||
c.uint.preencode(state, session._localId)
|
||||
encoding.preencode(state, m)
|
||||
|
||||
state.buffer = mux._alloc(state.end)
|
||||
|
||||
c.uint.encode(state, session._localId)
|
||||
c.uint.encode(state, type)
|
||||
encoding.encode(state, m)
|
||||
|
||||
return mux.stream.write(state.buffer)
|
||||
}
|
||||
}
|
||||
|
||||
this.messages.push(m)
|
||||
|
||||
return m
|
||||
}
|
||||
|
||||
cork () {
|
||||
if (this.corked) return
|
||||
this.corked = true
|
||||
this.mux.cork()
|
||||
_skipMessage () {
|
||||
const type = this.messages.length
|
||||
const m = {
|
||||
type,
|
||||
encoding: c.raw,
|
||||
onmessage: noop,
|
||||
recv (state, session) {},
|
||||
send (m, session) {}
|
||||
}
|
||||
|
||||
uncork () {
|
||||
if (!this.corked) return
|
||||
this.corked = false
|
||||
this.mux.uncork()
|
||||
}
|
||||
|
||||
close () {
|
||||
if (this.opened === false) return
|
||||
this.opened = false
|
||||
this.mux._unopened++
|
||||
|
||||
const offset = this.offset
|
||||
|
||||
this.version = null
|
||||
this.messages = EMPTY
|
||||
this.offset = 0
|
||||
this.length = 0
|
||||
this.onremoteopen = this.onremoteclose = noop
|
||||
this.mux._push(2, c.uint, offset)
|
||||
this._gc()
|
||||
|
||||
if (this.corked) this.uncork()
|
||||
}
|
||||
|
||||
_gc () {
|
||||
if (this.opened || this.remoteOpened) return
|
||||
this.mux._removeProtocol(this)
|
||||
}
|
||||
|
||||
_recv (type, state) {
|
||||
if (type >= this.messages.length) return
|
||||
|
||||
const m = this.messages[type]
|
||||
if (m !== undefined) this.mux._catch(m.onmessage(m.encoding.decode(state), this.context))
|
||||
this.messages.push(m)
|
||||
return m
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = class Protomux {
|
||||
constructor (stream, { backlog = 128, alloc, onacceptprotocol } = {}) {
|
||||
this.stream = stream
|
||||
this.protocols = []
|
||||
this.remoteProtocols = []
|
||||
this.offset = 4 // 4 messages reserved
|
||||
this.corked = 0
|
||||
this.backlog = backlog
|
||||
this.onacceptprotocol = onacceptprotocol || (() => this._unopened < this.backlog)
|
||||
constructor (stream, { alloc } = {}) {
|
||||
this.isProtomux = true
|
||||
this.stream = stream
|
||||
this.corked = 0
|
||||
|
||||
this._unopened = 0
|
||||
this._batch = null
|
||||
this._alloc = alloc || (typeof stream.alloc === 'function' ? stream.alloc.bind(stream) : b4a.allocUnsafe)
|
||||
this._safeDestroyBound = this._safeDestroy.bind(this)
|
||||
|
||||
this._remoteBacklog = 0
|
||||
this._buffered = 0
|
||||
this._paused = false
|
||||
this._remote = []
|
||||
this._local = []
|
||||
this._free = []
|
||||
this._batch = null
|
||||
this._batchState = null
|
||||
|
||||
this._infos = new Map()
|
||||
this._notify = new Map()
|
||||
|
||||
this.stream.on('data', this._ondata.bind(this))
|
||||
this.stream.on('error', noop) // we handle this in "close"
|
||||
this.stream.on('close', this._shutdown.bind(this))
|
||||
}
|
||||
|
||||
static from (other, opts) {
|
||||
return other.isProtomux === true ? other : new Protomux(other, opts)
|
||||
static from (stream, opts) {
|
||||
if (stream.isProtomux) return stream
|
||||
return new this(stream, opts)
|
||||
}
|
||||
|
||||
sendKeepAlive () {
|
||||
this.stream.write(this._alloc(0))
|
||||
* [Symbol.iterator] () {
|
||||
for (const session of this._local) {
|
||||
if (session !== null) yield session
|
||||
}
|
||||
}
|
||||
|
||||
cork () {
|
||||
if (++this.corked === 1) this._batch = []
|
||||
if (++this.corked === 1) {
|
||||
this._batch = []
|
||||
this._batchState = { buffer: null, start: 0, end: 1 }
|
||||
}
|
||||
}
|
||||
|
||||
uncork () {
|
||||
if (--this.corked !== 0) return
|
||||
|
||||
const batch = this._batch
|
||||
if (--this.corked === 0) {
|
||||
this._sendBatch(this._batch, this._batchState)
|
||||
this._batch = null
|
||||
|
||||
const state = { start: 0, end: 1, buffer: null }
|
||||
const lens = new Array(batch.length)
|
||||
|
||||
for (let i = 0; i < batch.length; i++) {
|
||||
const b = batch[i]
|
||||
const end = state.end
|
||||
|
||||
c.uint.preencode(state, b.type)
|
||||
b.encoding.preencode(state, b.message)
|
||||
c.uint.preencode(state, lens[i] = (state.end - end))
|
||||
this._batchState = null
|
||||
}
|
||||
}
|
||||
|
||||
pair ({ protocol, id = null }, notify) {
|
||||
this._notify.set(toKey(protocol, id), notify)
|
||||
}
|
||||
|
||||
unpair ({ protocol, id = null }) {
|
||||
this._notify.delete(toKey(protocol, id))
|
||||
}
|
||||
|
||||
opened ({ protocol, id = null }) {
|
||||
const key = toKey(protocol, id)
|
||||
const info = this._infos.get(key)
|
||||
return info ? info.opened > 0 : false
|
||||
}
|
||||
|
||||
open ({ protocol, id = null, context = null, unique = true, messages = [], onopen = noop, onclose = noop, ondestroy = noop }) {
|
||||
if (this.stream.destroyed) return null
|
||||
|
||||
const info = this._get(protocol, id)
|
||||
if (unique && info.opened > 0) return null
|
||||
|
||||
if (info.incoming.length === 0) {
|
||||
const session = new Session(this, info, protocol, id, context, messages, onopen, onclose, ondestroy)
|
||||
session._open()
|
||||
info.outgoing.push(session._localId)
|
||||
return session
|
||||
}
|
||||
|
||||
this._remoteBacklog--
|
||||
|
||||
const remoteId = info.incoming.shift()
|
||||
const r = this._remote[remoteId - 1]
|
||||
if (r === null) return null
|
||||
|
||||
const session = new Session(this, info, protocol, id, context, messages, onopen, onclose, ondestroy)
|
||||
|
||||
session._remoteId = remoteId
|
||||
session._open()
|
||||
session._fullyOpenSoon()
|
||||
|
||||
return session
|
||||
}
|
||||
|
||||
_pushBatch (localId, buffer) {
|
||||
if (this._batch.length === 0 || this._batch[this._batch.length - 1].localId !== localId) {
|
||||
this._batchState.end++
|
||||
c.uint.preencode(this._batchState, localId)
|
||||
}
|
||||
c.buffer.preencode(this._batchState, buffer)
|
||||
this._batch.push({ localId, buffer })
|
||||
}
|
||||
|
||||
_sendBatch (batch, state) {
|
||||
if (batch.length === 0) return
|
||||
|
||||
let prev = batch[0].localId
|
||||
|
||||
state.buffer = this._alloc(state.end)
|
||||
state.buffer[state.start++] = 0
|
||||
state.buffer[state.start++] = 0
|
||||
|
||||
c.uint.encode(state, prev)
|
||||
|
||||
for (let i = 0; i < batch.length; i++) {
|
||||
const b = batch[i]
|
||||
|
||||
c.uint.encode(state, lens[i])
|
||||
c.uint.encode(state, b.type)
|
||||
b.encoding.encode(state, b.message)
|
||||
if (prev !== b.localId) {
|
||||
state.buffer[state.start++] = 0
|
||||
c.uint.encode(state, (prev = b.localId))
|
||||
}
|
||||
c.buffer.encode(state, b.buffer)
|
||||
}
|
||||
|
||||
this.stream.write(state.buffer)
|
||||
}
|
||||
|
||||
hasProtocol (opts) {
|
||||
return !!this.getProtocol(opts)
|
||||
_get (protocol, id) {
|
||||
const key = toKey(protocol, id)
|
||||
|
||||
let info = this._infos.get(key)
|
||||
if (info) return info
|
||||
|
||||
info = { key, protocol, id, pairing: 0, opened: 0, incoming: [], outgoing: [] }
|
||||
this._infos.set(key, info)
|
||||
return info
|
||||
}
|
||||
|
||||
getProtocol ({ name, version }) {
|
||||
return this._getProtocol(name, version, false)
|
||||
}
|
||||
|
||||
addProtocol (opts) {
|
||||
const p = this._getProtocol(opts.name, (opts.version && opts.version.major) || 0, true)
|
||||
|
||||
if (opts.cork) p.cork()
|
||||
if (!p._attach(opts)) return p
|
||||
|
||||
this._unopened--
|
||||
this.offset += p.length
|
||||
this._push(1, addProtocol, {
|
||||
name: p.name,
|
||||
version: p.version,
|
||||
offset: p.offset,
|
||||
length: p.length
|
||||
})
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
destroy (err) {
|
||||
this.stream.destroy(err)
|
||||
}
|
||||
|
||||
_shutdown () {
|
||||
while (this.protocols.length) {
|
||||
const p = this.protocols.pop()
|
||||
if (!p.remoteOpened) continue
|
||||
if (p.remoteClosed) continue
|
||||
p.remoteOpened = false
|
||||
p.remoteClosed = true
|
||||
this._catch(p.onremoteclose())
|
||||
}
|
||||
}
|
||||
|
||||
_safeDestroy (err) {
|
||||
safetyCatch(err)
|
||||
this.destroy(err)
|
||||
}
|
||||
|
||||
_catch (p) {
|
||||
if (isPromise(p)) p.catch(this._safeDestroyBound)
|
||||
}
|
||||
|
||||
async _acceptMaybe (added) {
|
||||
let accept = false
|
||||
|
||||
try {
|
||||
accept = await this.onacceptprotocol(added)
|
||||
} catch (err) {
|
||||
this._safeDestroy(err)
|
||||
return
|
||||
}
|
||||
|
||||
if (!accept) this._rejectProtocol(added)
|
||||
}
|
||||
|
||||
_rejectProtocol (added) {
|
||||
for (let i = 0; i < this.protocols.length; i++) {
|
||||
const p = this.protocols[i]
|
||||
if (p.opened || p.name !== added.name || !p.remoteOpened) continue
|
||||
if (p.remoteVersion.major !== added.version.major) continue
|
||||
|
||||
this._unopened--
|
||||
this.protocols.splice(i, 1)
|
||||
this._push(3, c.uint, added.offset)
|
||||
return
|
||||
_gc (info) {
|
||||
if (info.opened === 0 && info.outgoing.length === 0 && info.incoming.length === 0) {
|
||||
this._infos.delete(info.key)
|
||||
}
|
||||
}
|
||||
|
||||
_ondata (buffer) {
|
||||
if (buffer.byteLength === 0) return // keep alive
|
||||
|
||||
const end = buffer.byteLength
|
||||
const state = { start: 0, end, buffer }
|
||||
|
||||
try {
|
||||
const type = c.uint.decode(state)
|
||||
if (type === 0) this._recvBatch(end, state)
|
||||
else this._recv(type, state)
|
||||
const state = { buffer, start: 0, end: buffer.byteLength }
|
||||
this._decode(c.uint.decode(state), state)
|
||||
} catch (err) {
|
||||
this._safeDestroy(err)
|
||||
}
|
||||
}
|
||||
|
||||
_getProtocol (name, major, upsert) {
|
||||
for (let i = 0; i < this.protocols.length; i++) {
|
||||
const p = this.protocols[i]
|
||||
const v = p.remoteVersion === null ? p.version : p.remoteVersion
|
||||
if (p.name === name && (v !== null && v.major === major)) return p
|
||||
}
|
||||
_decode (remoteId, state) {
|
||||
const type = c.uint.decode(state)
|
||||
|
||||
if (!upsert) return null
|
||||
|
||||
const p = new Protocol(this)
|
||||
this.protocols.push(p)
|
||||
this._unopened++
|
||||
return p
|
||||
}
|
||||
|
||||
_removeProtocol (p) {
|
||||
const i = this.protocols.indexOf(this)
|
||||
if (i > -1) this.protocols.splice(i, 1)
|
||||
if (!p.opened) this._unopened--
|
||||
}
|
||||
|
||||
_recvAddProtocol (state) {
|
||||
const add = addProtocol.decode(state)
|
||||
|
||||
const p = this._getProtocol(add.name, add.version.major, true)
|
||||
if (p.remoteOpened) throw new Error('Duplicate protocol received')
|
||||
|
||||
p.name = add.name
|
||||
p.remoteVersion = add.version
|
||||
p.remoteOffset = add.offset
|
||||
p.remoteEnd = add.offset + add.length
|
||||
p.remoteOpened = true
|
||||
p.remoteClosed = false
|
||||
|
||||
if (p.opened) {
|
||||
this._catch(p.onremoteopen())
|
||||
} else {
|
||||
this._acceptMaybe(add)
|
||||
}
|
||||
}
|
||||
|
||||
_recvRemoveProtocol (state) {
|
||||
const offset = c.uint.decode(state)
|
||||
|
||||
for (let i = 0; i < this.protocols.length; i++) {
|
||||
const p = this.protocols[i]
|
||||
|
||||
if (p.remoteOffset === offset && p.remoteOpened) {
|
||||
p.remoteVersion = null
|
||||
p.remoteOpened = false
|
||||
p.remoteClosed = true
|
||||
this._catch(p.onremoteclose())
|
||||
p._gc()
|
||||
if (remoteId === 0) {
|
||||
this._oncontrolsession(type, state)
|
||||
return
|
||||
}
|
||||
|
||||
const r = remoteId <= this._remote.length ? this._remote[remoteId - 1] : null
|
||||
|
||||
// if the channel is closed ignore - could just be a pipeline message...
|
||||
if (r === null) return
|
||||
|
||||
if (r.pending !== null) {
|
||||
this._bufferMessage(r, type, state)
|
||||
return
|
||||
}
|
||||
|
||||
r.session._recv(type, state)
|
||||
}
|
||||
|
||||
_oncontrolsession (type, state) {
|
||||
switch (type) {
|
||||
case 0:
|
||||
this._onbatch(state)
|
||||
break
|
||||
|
||||
case 1:
|
||||
this._onopensession(state)
|
||||
break
|
||||
|
||||
case 2:
|
||||
this._onrejectsession(state)
|
||||
break
|
||||
|
||||
case 3:
|
||||
this._onclosesession(state)
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
_recvRejectedProtocol (state) {
|
||||
const offset = c.uint.decode(state)
|
||||
|
||||
for (let i = 0; i < this.protocols.length; i++) {
|
||||
const p = this.protocols[i]
|
||||
|
||||
if (p.offset === offset && !p.remoteClosed) {
|
||||
p.remoteClosed = true
|
||||
this._catch(p.onremoteclose())
|
||||
p._gc()
|
||||
}
|
||||
}
|
||||
_bufferMessage (r, type, { buffer, start, end }) {
|
||||
const state = { buffer, start, end } // copy
|
||||
r.pending.push({ type, state })
|
||||
this._buffered += byteSize(state)
|
||||
this._pauseMaybe()
|
||||
}
|
||||
|
||||
_recvBatch (end, state) {
|
||||
while (state.start < state.end) {
|
||||
_pauseMaybe () {
|
||||
if (this._paused === true || this._buffered <= MAX_BUFFERED) return
|
||||
this._paused = true
|
||||
this.stream.pause()
|
||||
}
|
||||
|
||||
_resumeMaybe () {
|
||||
if (this._paused === false || this._buffered > MAX_BUFFERED) return
|
||||
this._paused = false
|
||||
this.stream.resume()
|
||||
}
|
||||
|
||||
_onbatch (state) {
|
||||
const end = state.end
|
||||
let remoteId = c.uint.decode(state)
|
||||
|
||||
while (state.end > state.start) {
|
||||
const len = c.uint.decode(state)
|
||||
const type = c.uint.decode(state)
|
||||
state.end = state.start + len
|
||||
this._recv(type, state)
|
||||
if (len === 0) {
|
||||
remoteId = c.uint.decode(state)
|
||||
continue
|
||||
}
|
||||
state.end = state.start + end
|
||||
this._decode(remoteId, state)
|
||||
state.end = end
|
||||
}
|
||||
}
|
||||
|
||||
_recv (type, state) {
|
||||
if (type < 4) {
|
||||
if (type === 0) {
|
||||
throw new Error('Invalid nested batch')
|
||||
}
|
||||
_onopensession (state) {
|
||||
const protocol = c.string.decode(state)
|
||||
const id = c.buffer.decode(state)
|
||||
const remoteId = c.uint.decode(state)
|
||||
|
||||
if (type === 1) {
|
||||
this._recvAddProtocol(state)
|
||||
// remote tried to open the control session - auto reject for now
|
||||
// as we can use as an explicit control protocol declaration if we need to
|
||||
if (remoteId === 0) {
|
||||
this._rejectSession(0)
|
||||
return
|
||||
}
|
||||
|
||||
if (type === 2) {
|
||||
this._recvRemoveProtocol(state)
|
||||
const rid = remoteId - 1
|
||||
const info = this._get(protocol, id)
|
||||
|
||||
// allow the remote to grow the ids by one
|
||||
if (this._remote.length === rid) {
|
||||
this._remote.push(null)
|
||||
}
|
||||
|
||||
if (rid >= this._remote.length || this._remote[rid] !== null) {
|
||||
throw new Error('Invalid open message')
|
||||
}
|
||||
|
||||
if (info.outgoing.length > 0) {
|
||||
const localId = info.outgoing.shift()
|
||||
const session = this._local[localId - 1]
|
||||
|
||||
if (session === null) { // we already closed the channel - ignore
|
||||
this._free.push(localId - 1)
|
||||
return
|
||||
}
|
||||
|
||||
if (type === 3) {
|
||||
this._recvRejectedProtocol(state)
|
||||
this._remote[rid] = { pending: null, session: null }
|
||||
|
||||
session._remoteId = remoteId
|
||||
session._fullyOpen()
|
||||
return
|
||||
}
|
||||
|
||||
return
|
||||
this._remote[rid] = { pending: [], session: null }
|
||||
|
||||
if (++this._remoteBacklog > MAX_BACKLOG) {
|
||||
throw new Error('Remote exceeded backlog')
|
||||
}
|
||||
|
||||
// TODO: Consider make this array sorted by remoteOffset and use a bisect here.
|
||||
// For now we use very few protocols in practice, so it might be overkill.
|
||||
for (let i = 0; i < this.protocols.length; i++) {
|
||||
const p = this.protocols[i]
|
||||
info.pairing++
|
||||
info.incoming.push(remoteId)
|
||||
|
||||
if (p.remoteOffset <= type && type < p.remoteEnd) {
|
||||
p._recv(type - p.remoteOffset, state)
|
||||
break
|
||||
this._requestSession(protocol, id, info).catch(this._safeDestroyBound)
|
||||
}
|
||||
|
||||
_onrejectsession (state) {
|
||||
const protocol = c.string.decode(state)
|
||||
const id = c.buffer.decode(state)
|
||||
const info = this._get(protocol, id)
|
||||
|
||||
if (info.outgoing.length === 0) {
|
||||
throw new Error('Invalid reject message')
|
||||
}
|
||||
|
||||
const localId = info.outgoing.shift()
|
||||
const session = this._local[localId - 1]
|
||||
|
||||
this._free.push(localId - 1)
|
||||
if (session !== null) session._close(true)
|
||||
}
|
||||
|
||||
_onclosesession (state) {
|
||||
const remoteId = c.uint.decode(state)
|
||||
|
||||
if (remoteId === 0) return // ignore
|
||||
|
||||
const rid = remoteId - 1
|
||||
const r = rid < this._remote.length ? this._remote[rid] : null
|
||||
|
||||
if (r === null) return
|
||||
|
||||
if (r.session !== null) r.session._close(true)
|
||||
}
|
||||
|
||||
async _requestSession (protocol, id, info) {
|
||||
const notify = this._notify.get(toKey(protocol, id)) || this._notify.get(toKey(protocol, null))
|
||||
|
||||
if (notify) await notify(id)
|
||||
|
||||
if (--info.pairing > 0) return
|
||||
|
||||
while (info.incoming.length > 0) {
|
||||
this._rejectSession(info, info.incoming.pop())
|
||||
}
|
||||
|
||||
this._gc(info)
|
||||
}
|
||||
|
||||
_rejectSession (info, remoteId) {
|
||||
if (remoteId > 0) {
|
||||
const r = this._remote[remoteId - 1]
|
||||
|
||||
if (r.pending !== null) {
|
||||
for (let i = 0; i < r.pending.length; i++) {
|
||||
this._buffered -= byteSize(r.pending[i].state)
|
||||
}
|
||||
}
|
||||
|
||||
_push (type, enc, message) {
|
||||
if (this.corked > 0) {
|
||||
this._batch.push({ type, encoding: enc, message })
|
||||
return false
|
||||
this._remote[remoteId - 1] = null
|
||||
this._resumeMaybe()
|
||||
}
|
||||
|
||||
const state = { start: 0, end: 0, buffer: null }
|
||||
const state = { buffer: null, start: 2, end: 2 }
|
||||
|
||||
c.uint.preencode(state, type)
|
||||
enc.preencode(state, message)
|
||||
c.string.preencode(state, info.protocol)
|
||||
c.buffer.preencode(state, info.id)
|
||||
|
||||
state.buffer = this._alloc(state.end)
|
||||
|
||||
c.uint.encode(state, type)
|
||||
enc.encode(state, message)
|
||||
state.buffer[0] = 0
|
||||
state.buffer[1] = 2
|
||||
c.string.encode(state, info.protocol)
|
||||
c.buffer.encode(state, info.id)
|
||||
|
||||
return this.stream.write(state.buffer)
|
||||
this._write0(state.buffer)
|
||||
}
|
||||
|
||||
_write0 (buffer) {
|
||||
if (this._batch !== null) {
|
||||
this._pushBatch(0, buffer.subarray(1))
|
||||
return
|
||||
}
|
||||
|
||||
this.stream.write(buffer)
|
||||
}
|
||||
|
||||
_safeDestroy (err) {
|
||||
safetyCatch(err)
|
||||
this.stream.destroy(err)
|
||||
}
|
||||
|
||||
_shutdown () {
|
||||
for (const s of this._local) {
|
||||
if (s !== null) s._close(true)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function noop () {}
|
||||
|
||||
function isPromise (p) {
|
||||
return typeof p === 'object' && p !== null && !!p.catch
|
||||
function toKey (protocol, id) {
|
||||
return protocol + '##' + (id ? b4a.toString(id, 'hex') : '')
|
||||
}
|
||||
|
||||
function byteSize (state) {
|
||||
return 512 + (state.end - state.start)
|
||||
}
|
||||
|
||||
function isPromise (p) {
|
||||
return !!(p && typeof p.then === 'function')
|
||||
}
|
||||
|
||||
function encodingLength (enc, val) {
|
||||
const state = { buffer: null, start: 0, end: 0 }
|
||||
enc.preencode(state, val)
|
||||
return state.end
|
||||
}
|
||||
|
|
|
|||
41
messages.js
41
messages.js
|
|
@ -1,41 +0,0 @@
|
|||
const c = require('compact-encoding')
|
||||
|
||||
const version = {
|
||||
preencode (state, v) {
|
||||
c.uint.preencode(state, v.major)
|
||||
c.uint.preencode(state, v.minor)
|
||||
},
|
||||
encode (state, v) {
|
||||
c.uint.encode(state, v.major)
|
||||
c.uint.encode(state, v.minor)
|
||||
},
|
||||
decode (state, v) {
|
||||
return {
|
||||
major: c.uint.decode(state),
|
||||
minor: c.uint.decode(state)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
exports.addProtocol = {
|
||||
preencode (state, p) {
|
||||
c.string.preencode(state, p.name)
|
||||
version.preencode(state, p.version)
|
||||
c.uint.preencode(state, p.offset)
|
||||
c.uint.preencode(state, p.length)
|
||||
},
|
||||
encode (state, p) {
|
||||
c.string.encode(state, p.name)
|
||||
version.encode(state, p.version)
|
||||
c.uint.encode(state, p.offset)
|
||||
c.uint.encode(state, p.length)
|
||||
},
|
||||
decode (state, p) {
|
||||
return {
|
||||
name: c.string.decode(state),
|
||||
version: version.decode(state),
|
||||
offset: c.uint.decode(state),
|
||||
length: c.uint.decode(state)
|
||||
}
|
||||
}
|
||||
}
|
||||
59
test.js
59
test.js
|
|
@ -9,10 +9,9 @@ test('basic', function (t) {
|
|||
|
||||
replicate(a, b)
|
||||
|
||||
const p = a.addProtocol({
|
||||
name: 'foo',
|
||||
messages: 1,
|
||||
onremoteopen () {
|
||||
const p = a.open({
|
||||
protocol: 'foo',
|
||||
onopen () {
|
||||
t.pass('a remote opened')
|
||||
}
|
||||
})
|
||||
|
|
@ -24,9 +23,8 @@ test('basic', function (t) {
|
|||
}
|
||||
})
|
||||
|
||||
const bp = b.addProtocol({
|
||||
name: 'foo',
|
||||
messages: 1
|
||||
const bp = b.open({
|
||||
protocol: 'foo'
|
||||
})
|
||||
|
||||
t.plan(2)
|
||||
|
|
@ -40,9 +38,8 @@ test('echo message', function (t) {
|
|||
|
||||
replicate(a, b)
|
||||
|
||||
const ap = a.addProtocol({
|
||||
name: 'foo',
|
||||
messages: 1
|
||||
const ap = a.open({
|
||||
protocol: 'foo'
|
||||
})
|
||||
|
||||
const aEcho = ap.addMessage({
|
||||
|
|
@ -52,15 +49,13 @@ test('echo message', function (t) {
|
|||
}
|
||||
})
|
||||
|
||||
b.addProtocol({
|
||||
name: 'other',
|
||||
messages: 2
|
||||
b.open({
|
||||
protocol: 'other'
|
||||
})
|
||||
|
||||
const bp = b.addProtocol({
|
||||
name: 'foo',
|
||||
messages: 1,
|
||||
onremoteopen () {
|
||||
const bp = b.open({
|
||||
protocol: 'foo',
|
||||
onopen () {
|
||||
t.pass('b remote opened')
|
||||
}
|
||||
})
|
||||
|
|
@ -80,14 +75,12 @@ test('echo message', function (t) {
|
|||
test('multi message', function (t) {
|
||||
const a = new Protomux(new SecretStream(true))
|
||||
|
||||
a.addProtocol({
|
||||
name: 'other',
|
||||
messages: 2
|
||||
a.open({
|
||||
protocol: 'other'
|
||||
})
|
||||
|
||||
const ap = a.addProtocol({
|
||||
name: 'multi',
|
||||
messages: 3
|
||||
const ap = a.open({
|
||||
protocol: 'multi'
|
||||
})
|
||||
|
||||
const a1 = ap.addMessage({ encoding: c.int })
|
||||
|
|
@ -96,9 +89,8 @@ test('multi message', function (t) {
|
|||
|
||||
const b = new Protomux(new SecretStream(false))
|
||||
|
||||
const bp = b.addProtocol({
|
||||
name: 'multi',
|
||||
messages: 2
|
||||
const bp = b.open({
|
||||
protocol: 'multi'
|
||||
})
|
||||
|
||||
const b1 = bp.addMessage({ encoding: c.int })
|
||||
|
|
@ -131,14 +123,12 @@ test('corks', function (t) {
|
|||
|
||||
a.cork()
|
||||
|
||||
a.addProtocol({
|
||||
name: 'other',
|
||||
messages: 2
|
||||
a.open({
|
||||
protocol: 'other'
|
||||
})
|
||||
|
||||
const ap = a.addProtocol({
|
||||
name: 'multi',
|
||||
messages: 2
|
||||
const ap = a.open({
|
||||
protocol: 'multi'
|
||||
})
|
||||
|
||||
const a1 = ap.addMessage({ encoding: c.int })
|
||||
|
|
@ -146,9 +136,8 @@ test('corks', function (t) {
|
|||
|
||||
const b = new Protomux(new SecretStream(false))
|
||||
|
||||
const bp = b.addProtocol({
|
||||
name: 'multi',
|
||||
messages: 2
|
||||
const bp = b.open({
|
||||
protocol: 'multi'
|
||||
})
|
||||
|
||||
const b1 = bp.addMessage({ encoding: c.int })
|
||||
|
|
|
|||
Reference in New Issue