bare-rpc 0.0.1 → 0.1.1

package/index.js

@@ -1,17 +1,21 @@
 const safetyCatch = require('safety-catch')
+const b4a = require('b4a')
 const c = require('compact-encoding')
 const m = require('./lib/messages')
-const { type } = require('./lib/constants')
+const { type: t, stream: s } = require('./lib/constants')
 const IncomingRequest = require('./lib/incoming-request')
+const IncomingStream = require('./lib/incoming-stream')
 const OutgoingRequest = require('./lib/outgoing-request')
+const OutgoingStream = require('./lib/outgoing-stream')
 
 module.exports = class RPC {
   constructor (stream, onrequest) {
     this._stream = stream
 
     this._id = 0
-    this._responding = 0
     this._requests = new Map()
+    this._responses = new Map()
+    this._incoming = new Map()
 
     this._buffer = null
 
@@ -26,42 +30,77 @@ module.exports = class RPC {
     return new OutgoingRequest(this, command)
   }
 
-  _send (request, data) {
-    const id = ++this._id
+  _sendMessage (message) {
+    this._stream.write(c.encode(m.message, message))
+  }
+
+  _sendRequest (request, data = null) {
+    const id = request.id = ++this._id
 
     this._requests.set(id, request)
 
-    this._stream.write(c.encode(m.message, {
-      type: type.REQUEST,
+    this._sendMessage({
+      type: t.REQUEST,
       id,
       command: request.command,
+      stream: 0,
       data
-    }))
+    })
   }
 
-  _reply (request, data) {
-    this._stream.write(c.encode(m.message, {
-      type: type.RESPONSE,
+  _createRequestStream (request, isInitiator, opts) {
+    if (isInitiator) {
+      const id = request.id = ++this._id
+
+      this._requests.set(id, request)
+
+      request._requestStream = new OutgoingStream(this, request, t.REQUEST, opts)
+    } else {
+      this._incoming.set(request.id, request)
+
+      const stream = request._requestStream = new IncomingStream(this, request, t.REQUEST, opts)
+
+      stream.on('close', () => this._incoming.delete(request.id))
+    }
+  }
+
+  _sendResponse (request, data) {
+    this._sendMessage({
+      type: t.RESPONSE,
       id: request.id,
-      error: false,
+      stream: 0,
+      error: null,
       data
-    }))
+    })
+  }
+
+  _createResponseStream (request, isInitiator, opts) {
+    if (isInitiator) {
+      this._responses.set(request.id, request)
+
+      request._responseStream = new OutgoingStream(this, request, t.RESPONSE, opts)
+    } else {
+      this._incoming.set(request.id, request)
+
+      const stream = request._responseStream = new IncomingStream(this, request, t.RESPONSE, opts)
+
+      stream.on('close', () => this._incoming.delete(request.id))
+    }
   }
 
-  _error (request, err) {
-    this._stream.write(c.encode(m.message, {
-      type: type.RESPONSE,
+  _sendError (request, err) {
+    this._sendMessage({
+      type: t.RESPONSE,
       id: request.id,
-      error: true,
-      message: err.message,
-      code: err.code || '',
-      status: err.errno || 0
-    }))
+      stream: 0,
+      error: err,
+      data: null
+    })
   }
 
   _ondata (data) {
     if (this._buffer === null) this._buffer = data
-    else this._buffer = Buffer.concat([this._buffer, data])
+    else this._buffer = b4a.concat([this._buffer, data])
 
     while (this._buffer !== null) {
       const state = { start: 0, end: this._buffer.length, buffer: this._buffer }
@@ -78,7 +117,7 @@ module.exports = class RPC {
       if (message === null) return
 
       switch (message.type) {
-        case type.REQUEST: {
+        case t.REQUEST: {
           const request = new IncomingRequest(this, message.id, message.command, message.data)
 
           try {
@@ -86,18 +125,23 @@ module.exports = class RPC {
           } catch (err) {
             safetyCatch(err)
 
-            this._error(request, err)
+            this._sendError(request, err)
           }
-
           break
         }
-
-        case type.RESPONSE:
+        case t.RESPONSE:
           try {
             this._onresponse(message)
           } catch (err) {
             safetyCatch(err)
           }
+          break
+        case t.STREAM:
+          try {
+            this._onstream(message)
+          } catch (err) {
+            safetyCatch(err)
+          }
       }
 
       this._buffer = state.start === state.end ? null : this._buffer.subarray(state.start)
@@ -108,17 +152,164 @@ module.exports = class RPC {
     if (message.id === 0) return
 
     const request = this._requests.get(message.id)
-
     if (request === undefined) return
 
     if (message.error) {
-      const err = new Error(`${message.message}`)
-      err.code = message.code
-      err.errno = message.status
+      request._reject(message.error)
+    } else if (message.stream === 0) {
+      request._resolve(message.data)
+    }
+  }
+
+  _onstream (message) {
+    if (message.id === 0) return
+
+    if (message.stream & s.OPEN) this._onstreamopen(message)
+    else if (message.stream & s.CLOSE) this._onstreamclose(message)
+    else if (message.stream & s.PAUSE) this._onstreampause(message)
+    else if (message.stream & s.RESUME) this._onstreamresume(message)
+    else if (message.stream & s.DATA) this._onstreamdata(message)
+    else if (message.stream & s.END) this._onstreamend(message)
+    else if (message.stream & s.DESTROY) this._onstreamdestroy(message)
+  }
+
+  _onstreamopen (message) {
+    let stream
 
-      request._reject(err)
+    if (message.stream & s.REQUEST) {
+      const request = this._requests.get(message.id)
+      if (request === undefined) return
+
+      stream = request._requestStream
+    } else if (message.stream & s.RESPONSE) {
+      const request = this._responses.get(message.id)
+      if (request === undefined) return
+
+      stream = request._responseStream
     } else {
-      request._resolve(message.data)
+      return
+    }
+
+    stream._continueOpen()
+  }
+
+  _onstreamclose (message) {
+    const request = this._incoming.get(message.id)
+    if (request === undefined) return
+
+    let stream
+
+    if (message.stream & s.REQUEST) {
+      stream = request._requestStream
+    } else if (message.stream & s.RESPONSE) {
+      stream = request._responseStream
+    } else {
+      return
+    }
+
+    if (message.error) stream.destroy(message.error)
+    else stream.push(null)
+  }
+
+  _onstreampause (message) {
+    let stream
+
+    if (message.stream & s.REQUEST) {
+      const request = this._requests.get(message.id)
+      if (request === undefined) return
+
+      stream = request._requestStream
+    } else if (message.stream & s.RESPONSE) {
+      const request = this._responses.get(message.id)
+      if (request === undefined) return
+
+      stream = request._responseStream
+    } else {
+      return
+    }
+
+    stream.cork()
+  }
+
+  _onstreamresume (message) {
+    let stream
+
+    if (message.stream & s.REQUEST) {
+      const request = this._requests.get(message.id)
+      if (request === undefined) return
+
+      stream = request._requestStream
+    } else if (message.stream & s.RESPONSE) {
+      const request = this._responses.get(message.id)
+      if (request === undefined) return
+
+      stream = request._responseStream
+    } else {
+      return
     }
+
+    stream.uncork()
+  }
+
+  _onstreamdata (message) {
+    const request = this._incoming.get(message.id)
+    if (request === undefined) return
+
+    let stream
+
+    if (message.stream & s.REQUEST) {
+      stream = request._requestStream
+    } else if (message.stream & s.RESPONSE) {
+      stream = request._responseStream
+    } else {
+      return
+    }
+
+    if (stream.push(message.data) === false) {
+      this._sendMessage({
+        type: t.STREAM,
+        id: stream._request.id,
+        stream: stream._mask | s.PAUSE,
+        error: null,
+        data: null
+      })
+    }
+  }
+
+  _onstreamend (message) {
+    const request = this._incoming.get(message.id)
+    if (request === undefined) return
+
+    let stream
+
+    if (message.stream & s.REQUEST) {
+      stream = request._requestStream
+    } else if (message.stream & s.RESPONSE) {
+      stream = request._responseStream
+    } else {
+      return
+    }
+
+    stream.push(null)
+  }
+
+  _onstreamdestroy (message) {
+    let stream
+
+    if (message.stream & s.REQUEST) {
+      const request = this._requests.get(message.id)
+      if (request === undefined) return
+
+      stream = request._requestStream
+    } else if (message.stream & s.RESPONSE) {
+      const request = this._responses.get(message.id)
+      if (request === undefined) return
+
+      stream = request._responseStream
+    } else {
+      return
+    }
+
+    stream.destroy(message.error)
   }
 }

package/lib/constants.js

@@ -1,6 +1,19 @@
 module.exports = {
   type: {
     REQUEST: 1,
-    RESPONSE: 2
+    RESPONSE: 2,
+    STREAM: 3
+  },
+  stream: {
+    OPEN: 0x1,
+    CLOSE: 0x2,
+    PAUSE: 0x4,
+    RESUME: 0x8,
+    DATA: 0x10,
+    END: 0x20,
+    DESTROY: 0x40,
+    ERROR: 0x80,
+    REQUEST: 0x100,
+    RESPONSE: 0x200
   }
 }

package/lib/incoming-request.js

@@ -1,12 +1,34 @@
+const b4a = require('b4a')
+const errors = require('./errors')
+
 module.exports = class RPCIncomingRequest {
   constructor (rpc, id, command, data) {
     this.rpc = rpc
     this.id = id
     this.command = command
     this.data = data
+    this.sent = false
+
+    this._requestStream = null
+    this._responseStream = null
   }
 
   reply (data) {
-    return this.rpc._reply(this, typeof data === 'string' ? Buffer.from(data) : data)
+    if (this.sent) throw errors.ALREADY_SENT('Response has already been sent')
+    this.sent = true
+
+    this.rpc._sendResponse(this, typeof data === 'string' ? b4a.from(data) : data)
+  }
+
+  createResponseStream (opts = {}) {
+    if (this._responseStream === null) this.rpc._createResponseStream(this, true, opts)
+
+    return this._responseStream
+  }
+
+  createRequestStream (opts = {}) {
+    if (this._requestStream === null) this.rpc._createRequestStream(this, false, opts)
+
+    return this._requestStream
   }
 }

package/lib/incoming-stream.js

@@ -0,0 +1,59 @@
+const { Readable } = require('bare-stream')
+const { type: t, stream: s } = require('./constants')
+
+module.exports = class RPCIncomingStream extends Readable {
+  constructor (rpc, request, type, opts) {
+    super({ ...opts, eagerOpen: true })
+
+    this._rpc = rpc
+    this._request = request
+    this._type = type
+    this._mask = type === t.REQUEST ? s.REQUEST : s.RESPONSE
+
+    this._pendingOpen = null
+  }
+
+  _open (cb) {
+    this._rpc._sendMessage({
+      type: t.STREAM,
+      id: this._request.id,
+      stream: this._mask | s.OPEN,
+      error: null,
+      data: null
+    })
+
+    cb(null)
+  }
+
+  _read () {
+    this._rpc._sendMessage({
+      type: t.STREAM,
+      id: this._request.id,
+      stream: this._mask | s.RESUME,
+      error: null,
+      data: null
+    })
+  }
+
+  _destroy (err, cb) {
+    if (err) {
+      this._rpc._sendMessage({
+        type: t.STREAM,
+        id: this._request.id,
+        stream: this._mask | s.DESTROY | s.ERROR,
+        error: err,
+        data: null
+      })
+    } else {
+      this._rpc._sendMessage({
+        type: t.STREAM,
+        id: this._request.id,
+        stream: this._mask | s.DESTROY,
+        error: null,
+        data: null
+      })
+    }
+
+    cb(null)
+  }
+}

package/lib/messages.js

@@ -1,74 +1,92 @@
 const c = require('compact-encoding')
-const { type: t } = require('./constants')
+const { type: t, stream: s } = require('./constants')
 const errors = require('./errors')
 
 const request = {
   preencode (state, m) {
     c.utf8.preencode(state, m.command)
-    c.buffer.preencode(state, m.data)
-    c.uint.preencode(state, 0) // Reserved
+    c.uint.preencode(state, m.stream)
+    if (m.stream === 0) c.buffer.preencode(state, m.data)
   },
   encode (state, m) {
     c.utf8.encode(state, m.command)
-    c.buffer.encode(state, m.data)
-    c.uint.encode(state, 0) // Reserved
+    c.uint.encode(state, m.stream)
+    if (m.stream === 0) c.buffer.encode(state, m.data)
   },
   decode (state, id) {
     const command = c.utf8.decode(state)
-    const data = c.buffer.decode(state)
-    c.uint.decode(state)
+    const stream = c.uint.decode(state)
+    const data = stream === 0 ? c.buffer.decode(state) : null
 
-    return { type: t.REQUEST, id, command, data }
+    return { type: t.REQUEST, id, command, stream, data }
   }
 }
 
 const error = {
   preencode (state, m) {
     c.utf8.preencode(state, m.message)
-    c.utf8.preencode(state, m.code)
-    c.int.preencode(state, m.status)
+    c.utf8.preencode(state, m.code || '')
+    c.int.preencode(state, m.errno || 0)
   },
   encode (state, m) {
     c.utf8.encode(state, m.message)
-    c.utf8.encode(state, m.code)
-    c.int.encode(state, m.status)
+    c.utf8.encode(state, m.code || '')
+    c.int.encode(state, m.errno || 0)
   },
   decode (state) {
-    return {
-      message: c.utf8.decode(state),
-      code: c.utf8.decode(state),
-      status: c.int.decode(state)
-    }
+    const err = new Error(`${c.utf8.decode(state)}`)
+    err.code = c.utf8.decode(state)
+    err.errno = c.int.decode(state)
+    return err
   }
 }
 
 const response = {
   preencode (state, m) {
-    c.bool.preencode(state, m.error)
-
-    if (m.error) error.preencode(state, m)
-    else c.buffer.preencode(state, m.data)
+    c.bool.preencode(state, !!m.error)
+    c.uint.preencode(state, m.stream)
 
-    c.uint.preencode(state, 0) // Reserved
+    if (m.error) error.preencode(state, m.error)
+    else if (m.stream === 0) c.buffer.preencode(state, m.data)
   },
   encode (state, m) {
-    c.bool.encode(state, m.error)
+    c.bool.encode(state, !!m.error)
+    c.uint.encode(state, m.stream)
 
     if (m.error) error.encode(state, m)
-    else c.buffer.encode(state, m.data)
-
-    c.uint.encode(state, 0) // Reserved
+    else if (m.stream === 0) c.buffer.encode(state, m.data)
   },
   decode (state) {
     const error = c.bool.decode(state)
+    const stream = c.uint.decode(state)
+
+    if (error) return { stream, error: error.decode(state), data: null }
+    if (stream === 0) return { stream, error: null, data: c.buffer.decode(state) }
+
+    return { stream, error: null, data: null }
+  }
+}
+
+const stream = {
+  preencode (state, m) {
+    c.uint.preencode(state, m.stream)
 
-    let response
-    if (error) response = error.decode(state)
-    else response = { data: c.buffer.decode(state) }
+    if (m.stream & s.ERROR) error.preencode(state, m.error)
+    else if (m.stream & s.DATA) c.buffer.preencode(state, m.data)
+  },
+  encode (state, m) {
+    c.uint.encode(state, m.stream)
+
+    if (m.stream & s.ERROR) error.encode(state, m.error)
+    else if (m.stream & s.DATA) c.buffer.encode(state, m.data)
+  },
+  decode (state) {
+    const stream = c.uint.decode(state)
 
-    c.uint.decode(state)
+    if (stream & s.ERROR) return { stream, error: error.decode(state), data: null }
+    if (stream & s.DATA) return { stream, error: null, data: c.buffer.decode(state) }
 
-    return { error, ...response }
+    return { stream, error: null, data: null }
   }
 }
 
@@ -84,6 +102,10 @@ exports.message = {
         break
       case t.RESPONSE:
         response.preencode(state, m)
+        break
+      case t.STREAM:
+        stream.preencode(state, m)
+        break
     }
   },
   encode (state, m) {
@@ -102,6 +124,10 @@ exports.message = {
         break
       case t.RESPONSE:
         response.encode(state, m)
+        break
+      case t.STREAM:
+        stream.encode(state, m)
+        break
     }
 
     const end = state.start
@@ -124,9 +150,11 @@ exports.message = {
 
     switch (type) {
       case t.REQUEST:
-        return { type: t.REQUEST, id, ...request.decode(state, id) }
+        return { type, id, ...request.decode(state, id) }
       case t.RESPONSE:
-        return { type: t.RESPONSE, id, ...response.decode(state, id) }
+        return { type, id, ...response.decode(state, id) }
+      case t.STREAM:
+        return { type, id, ...stream.decode(state, id) }
       default:
         throw errors.UNKNOWN_MESSAGE(`Unknown message '${type}'`)
     }

package/lib/outgoing-request.js

@@ -1,29 +1,42 @@
+const b4a = require('b4a')
 const errors = require('./errors')
 
 module.exports = class RPCOutgoingRequest {
   constructor (rpc, command) {
     this.rpc = rpc
+    this.id = -1
     this.command = command
     this.sent = false
 
-    this._resolve = null
-    this._reject = null
-    this._promise = null
-  }
-
-  send (data) {
-    if (this.sent) throw errors.ALREADY_SENT('Response has already been sent')
-    this.sent = true
-
     this._promise = new Promise((resolve, reject) => {
       this._resolve = resolve
       this._reject = reject
     })
 
-    return this.rpc._send(this, typeof data === 'string' ? Buffer.from(data) : data)
+    this._requestStream = null
+    this._responseStream = null
+  }
+
+  send (data) {
+    if (this.sent) throw errors.ALREADY_SENT('Request has already been sent')
+    this.sent = true
+
+    this.rpc._sendRequest(this, typeof data === 'string' ? b4a.from(data) : data)
   }
 
   reply () {
     return this._promise
   }
+
+  createRequestStream (opts = {}) {
+    if (this._requestStream === null) this.rpc._createRequestStream(this, true, opts)
+
+    return this._requestStream
+  }
+
+  createResponseStream (opts = {}) {
+    if (this._requestStream === null) this.rpc._createResponseStream(this, false, opts)
+
+    return this._responseStream
+  }
 }

package/lib/outgoing-stream.js

@@ -0,0 +1,94 @@
+const { Writable } = require('bare-stream')
+const { type: t, stream: s } = require('./constants')
+
+module.exports = class RPCOutgoingStream extends Writable {
+  constructor (rpc, request, type, opts) {
+    super({ ...opts, eagerOpen: true })
+
+    this._rpc = rpc
+    this._request = request
+    this._type = type
+    this._mask = type === t.REQUEST ? s.REQUEST : s.RESPONSE
+
+    this._pendingOpen = null
+  }
+
+  _open (cb) {
+    this._pendingOpen = cb
+
+    switch (this._type) {
+      case t.REQUEST:
+        this._rpc._sendMessage({
+          type: t.REQUEST,
+          id: this._request.id,
+          command: this._request.command,
+          stream: s.OPEN,
+          data: null
+        })
+        break
+
+      case t.RESPONSE:
+        this._rpc._sendMessage({
+          type: t.RESPONSE,
+          id: this._request.id,
+          error: false,
+          stream: s.OPEN,
+          data: null
+        })
+        break
+    }
+  }
+
+  _continueOpen () {
+    if (this._pendingOpen === null) return
+    const cb = this._pendingOpen
+    this._pendingOpen = null
+    cb()
+  }
+
+  _write (data, encoding, cb) {
+    this._rpc._sendMessage({
+      type: t.STREAM,
+      id: this._request.id,
+      stream: this._mask | s.DATA,
+      error: null,
+      data
+    })
+
+    cb(null)
+  }
+
+  _final (cb) {
+    this._rpc._sendMessage({
+      type: t.STREAM,
+      id: this._request.id,
+      stream: this._mask | s.END,
+      error: null,
+      data: null
+    })
+
+    cb(null)
+  }
+
+  _destroy (err, cb) {
+    if (err) {
+      this._rpc._sendMessage({
+        type: t.STREAM,
+        id: this._request.id,
+        stream: this._mask | s.CLOSE | s.ERROR,
+        error: err,
+        data: null
+      })
+    } else {
+      this._rpc._sendMessage({
+        type: t.STREAM,
+        id: this._request.id,
+        stream: this._mask | s.CLOSE,
+        error: null,
+        data: null
+      })
+    }
+
+    cb(null)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-rpc",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "description": "librpc ABI compatible RPC for Bare",
   "exports": {
     ".": "./index.js",
@@ -25,11 +25,12 @@
   },
   "homepage": "https://github.com/holepunchto/bare-rpc#readme",
   "dependencies": {
+    "b4a": "^1.6.6",
+    "bare-stream": "^2.1.3",
     "compact-encoding": "^2.15.0",
     "safety-catch": "^1.0.2"
   },
   "devDependencies": {
-    "bare-stream": "^2.1.3",
     "brittle": "^3.2.1",
     "standard": "^17.0.0"
   }