bare-rpc 1.3.4 → 1.3.6

package/index.d.ts

@@ -95,6 +95,8 @@ declare class RPCOutgoingStream extends Writable {
 }
 
 interface RPC {
+  readonly idle: boolean
+
   event(command: number): RPCOutgoingEvent
   request(command: number): RPCOutgoingRequest
 }

package/index.js

@@ -42,6 +42,19 @@ module.exports = exports = class RPC {
     this._stream.on('error', this._onerror).on('data', this._ondata).on('drain', this._ondrain)
   }
 
+  // Whether there are no requests or responses currently in flight. Useful for
+  // determining when it is safe to tear down the underlying stream.
+  get idle() {
+    return (
+      this._outgoingRequests.size === 0 &&
+      this._outgoingResponses.size === 0 &&
+      this._incomingRequests.size === 0 &&
+      this._incomingResponses.size === 0 &&
+      this._pendingRequests.size === 0 &&
+      this._pendingResponses.size === 0
+    )
+  }
+
   event(command) {
     return new OutgoingEvent(this, command)
   }
@@ -51,6 +64,14 @@ module.exports = exports = class RPC {
   }
 
   _sendMessage(message, cb) {
+    // Once the underlying stream is being torn down there is nowhere left to
+    // write, so drop the message and settle the callback immediately. This
+    // keeps stream teardown from stalling on a drain that will never arrive.
+    if (this._stream.destroying) {
+      if (cb) cb(null)
+      return
+    }
+
     const header = c.encode(m.header, message)
 
     let flushed = this._stream.write(header)
@@ -90,6 +111,8 @@ module.exports = exports = class RPC {
       this._outgoingRequests.set(request.id, request)
 
       request._requestStream = new OutgoingStream(this, request, t.REQUEST, opts)
+
+      request._requestStream.on('close', () => this._gcOutgoingRequest(request))
     } else {
       this._incomingRequests.set(request.id, request)
 
@@ -114,12 +137,19 @@ module.exports = exports = class RPC {
       this._outgoingResponses.set(request.id, request)
 
       request._responseStream = new OutgoingStream(this, request, t.RESPONSE, opts)
+
+      request._responseStream.on('close', () => this._outgoingResponses.delete(request.id))
     } else {
       this._incomingResponses.set(request.id, request)
 
       request._responseStream = new IncomingStream(this, request, t.RESPONSE, opts)
 
-      request._responseStream.on('close', () => this._incomingResponses.delete(request.id))
+      request._responseStream.on('close', () => {
+        this._incomingResponses.delete(request.id)
+
+        request._responded = true
+        this._gcOutgoingRequest(request)
+      })
     }
   }
 
@@ -133,10 +163,54 @@ module.exports = exports = class RPC {
     })
   }
 
+  _gcOutgoingRequest(request) {
+    // The entry must stay reachable for as long as an incoming message might
+    // still target it; until the response has settled and, if the request was
+    // streamed, until the outgoing request stream has closed. Either can be the
+    // last to arrive, so only remove the entry once both have completed.
+    if (!request._responded) return
+    if (request._requestStream !== null && !request._requestStream.destroyed) return
+
+    this._outgoingRequests.delete(request.id)
+  }
+
   _onerror(err) {
     this._ondrain(err)
 
-    // TODO Destroy pending requests and responses
+    // Reject any request awaiting a plain reply. Requests whose response is
+    // delivered over a stream are torn down through that stream below.
+    for (const request of this._outgoingRequests.values()) {
+      if (request.received && request._responseStream === null) request._reject(err)
+    }
+
+    // Collect the streams first, deduplicating as a single request may appear
+    // in more than one map, then destroy them once the maps have been cleared.
+    const streams = new Set()
+
+    for (const request of this._outgoingRequests.values()) {
+      if (request._requestStream !== null) streams.add(request._requestStream)
+    }
+
+    for (const request of this._incomingRequests.values()) {
+      if (request._requestStream !== null) streams.add(request._requestStream)
+    }
+
+    for (const request of this._outgoingResponses.values()) {
+      if (request._responseStream !== null) streams.add(request._responseStream)
+    }
+
+    for (const request of this._incomingResponses.values()) {
+      if (request._responseStream !== null) streams.add(request._responseStream)
+    }
+
+    this._outgoingRequests.clear()
+    this._outgoingResponses.clear()
+    this._incomingRequests.clear()
+    this._incomingResponses.clear()
+    this._pendingRequests.clear()
+    this._pendingResponses.clear()
+
+    for (const stream of streams) stream.destroy(err)
   }
 
   _ondata(data) {
@@ -226,8 +300,14 @@ module.exports = exports = class RPC {
     if (request === undefined) return
 
     if (message.error) {
+      request._responded = true
+      this._gcOutgoingRequest(request)
+
       request._reject(message.error)
     } else if (message.stream === 0) {
+      request._responded = true
+      this._gcOutgoingRequest(request)
+
       request._resolve(message.data)
     }
   }

package/lib/outgoing-request.js

@@ -9,6 +9,8 @@ module.exports = class RPCOutgoingRequest {
     this.sent = false
     this.received = false
 
+    this._responded = false
+
     this._promise = new Promise((resolve, reject) => {
       this._resolve = resolve
       this._reject = reject

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-rpc",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "description": "librpc ABI compatible RPC for Bare",
   "exports": {
     ".": {