@dxos/rpc 2.19.7-dev.42eb65c2 → 2.19.8-dev.98e1d63e

package/src/rpc.test.ts

@@ -9,6 +9,7 @@ import { sleep } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 
 import { SerializedRpcError } from './errors';
+import { Any } from './proto/gen/google/protobuf';
 import { RpcPeer } from './rpc';
 import { createLinkedPorts } from './testutil';
 
@@ -17,11 +18,11 @@ describe('RpcPeer', () => {
     const [alicePort, bobPort] = createLinkedPorts();
 
     const alice = new RpcPeer({
-      messageHandler: async msg => new Uint8Array(),
+      messageHandler: async msg => ({}),
       port: alicePort
     });
     const bob = new RpcPeer({
-      messageHandler: async msg => new Uint8Array(),
+      messageHandler: async msg => ({}),
       port: bobPort
     });
 
@@ -38,13 +39,13 @@ describe('RpcPeer', () => {
       const alice = new RpcPeer({
         messageHandler: async (method, msg) => {
           expect(method).toEqual('method');
-          expect(msg).toEqual(Buffer.from('request'));
-          return Buffer.from('response');
+          expect(msg.value).toEqual(Buffer.from('request'));
+          return { value: Buffer.from('response') };
         },
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async (method, msg) => new Uint8Array(),
+        messageHandler: async (method, msg) => ({}),
         port: bobPort
       });
 
@@ -53,8 +54,8 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      const response = await bob.call('method', Buffer.from('request'));
-      expect(response).toEqual(Buffer.from('response'));
+      const response = await bob.call('method', { value: Buffer.from('request') });
+      expect(response).toEqual({ value: Buffer.from('response') });
     });
 
     test('can send multiple requests', async () => {
@@ -65,7 +66,7 @@ describe('RpcPeer', () => {
           expect(method).toEqual('method');
           await sleep(5);
 
-          const text = Buffer.from(msg).toString();
+          const text = Buffer.from(msg.value!).toString();
 
           if (text === 'error') {
             throw new Error('test error');
@@ -76,7 +77,7 @@ describe('RpcPeer', () => {
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: bobPort
       });
 
@@ -85,14 +86,14 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      expect(await bob.call('method', Buffer.from('request'))).toEqual(Buffer.from('request'));
+      expect((await bob.call('method', { value: Buffer.from('request') })).value).toEqual(Buffer.from('request'));
 
-      const parallel1 = bob.call('method', Buffer.from('p1'));
-      const parallel2 = bob.call('method', Buffer.from('p2'));
-      const error = bob.call('method', Buffer.from('error'));
+      const parallel1 = bob.call('method', { value: Buffer.from('p1') });
+      const parallel2 = bob.call('method', { value: Buffer.from('p2') });
+      const error = bob.call('method', { value: Buffer.from('error') });
 
-      await expect(await parallel1).toEqual(Buffer.from('p1'));
-      await expect(await parallel2).toEqual(Buffer.from('p2'));
+      await expect(await parallel1).toEqual({ value: Buffer.from('p1') });
+      await expect(await parallel2).toEqual({ value: Buffer.from('p2') });
       await expect(error).toBeRejected();
     });
 
@@ -111,7 +112,7 @@ describe('RpcPeer', () => {
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: bobPort
       });
 
@@ -122,7 +123,7 @@ describe('RpcPeer', () => {
 
       let error!: Error;
       try {
-        await bob.call('RpcMethodName', Buffer.from('request'));
+        await bob.call('RpcMethodName', { value: Buffer.from('request') });
       } catch (err: any) {
         error = err;
       }
@@ -145,7 +146,7 @@ describe('RpcPeer', () => {
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: bobPort
       });
 
@@ -154,7 +155,7 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      const req = bob.call('method', Buffer.from('request'));
+      const req = bob.call('method', { value: Buffer.from('request') });
       bob.close();
 
       await expect(req).toBeRejected();
@@ -172,7 +173,7 @@ describe('RpcPeer', () => {
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: bobPort,
         timeout: 50
       });
@@ -183,7 +184,7 @@ describe('RpcPeer', () => {
       ]);
 
       alice.close();
-      const req = bob.call('method', Buffer.from('request'));
+      const req = bob.call('method', { value: Buffer.from('request') });
 
       await expect(req).toBeRejected();
     });
@@ -191,11 +192,11 @@ describe('RpcPeer', () => {
     test('open waits for the other peer to call open', async () => {
       const [alicePort, bobPort] = createLinkedPorts();
       const alice: RpcPeer = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: bobPort
       });
 
@@ -219,7 +220,7 @@ describe('RpcPeer', () => {
 
       // eslint-disable-next-line prefer-const
       const alice: RpcPeer = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: alicePort
       });
       const aliceOpen = alice.open();
@@ -227,7 +228,7 @@ describe('RpcPeer', () => {
       await sleep(5);
 
       const bob = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: bobPort
       });
 
@@ -243,20 +244,20 @@ describe('RpcPeer', () => {
       const [alicePort, bobPort] = createLinkedPorts();
 
       const alice = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         streamHandler: (method, msg) => {
           expect(method).toEqual('method');
-          expect(msg).toEqual(Buffer.from('request'));
-          return new Stream<Uint8Array>(({ next, close }) => {
-            next(Buffer.from('res1'));
-            next(Buffer.from('res2'));
+          expect(msg.value!).toEqual(Buffer.from('request'));
+          return new Stream<Any>(({ next, close }) => {
+            next({ value: Buffer.from('res1') });
+            next({ value: Buffer.from('res2') });
             close();
           });
         },
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: bobPort
       });
 
@@ -265,12 +266,12 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      const stream = await bob.callStream('method', Buffer.from('request'));
+      const stream = await bob.callStream('method', { value: Buffer.from('request') });
       expect(stream).toBeA(Stream);
 
       expect(await Stream.consume(stream)).toEqual([
-        { data: Buffer.from('res1') },
-        { data: Buffer.from('res2') },
+        { data: { value: Buffer.from('res1') } },
+        { data: { value: Buffer.from('res2') } },
         { closed: true }
       ]);
     });
@@ -279,18 +280,18 @@ describe('RpcPeer', () => {
       const [alicePort, bobPort] = createLinkedPorts();
 
       const alice = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         streamHandler: (method, msg) => {
           expect(method).toEqual('method');
-          expect(msg).toEqual(Buffer.from('request'));
-          return new Stream<Uint8Array>(({ next, close }) => {
+          expect(msg.value).toEqual(Buffer.from('request'));
+          return new Stream<Any>(({ next, close }) => {
             close(new Error('Test error'));
           });
         },
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: bobPort
       });
 
@@ -299,7 +300,7 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      const stream = await bob.callStream('method', Buffer.from('request'));
+      const stream = await bob.callStream('method', { value: Buffer.from('request') });
       expect(stream).toBeA(Stream);
 
       const msgs = await Stream.consume(stream);
@@ -315,9 +316,9 @@ describe('RpcPeer', () => {
 
       let closeCalled = false;
       const alice = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         streamHandler: (method, msg) => {
-          return new Stream<Uint8Array>(({ next, close }) => {
+          return new Stream<Any>(({ next, close }) => {
             return () => {
               closeCalled = true;
             };
@@ -327,7 +328,7 @@ describe('RpcPeer', () => {
       });
 
       const bob = new RpcPeer({
-        messageHandler: async msg => new Uint8Array(),
+        messageHandler: async msg => ({}),
         port: bobPort
       });
 
@@ -336,7 +337,7 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      const stream = bob.callStream('method', Buffer.from('request'));
+      const stream = bob.callStream('method', { value: Buffer.from('request') });
       stream.close();
 
       await sleep(1);
@@ -350,7 +351,7 @@ describe('RpcPeer', () => {
 
     // eslint-disable-next-line prefer-const
     const alice: RpcPeer = new RpcPeer({
-      messageHandler: async msg => new Uint8Array(),
+      messageHandler: async msg => ({}),
       port: alicePort
     });
     const aliceOpen = alice.open();
@@ -358,7 +359,7 @@ describe('RpcPeer', () => {
     await sleep(5);
 
     const bob = new RpcPeer({
-      messageHandler: async msg => new Uint8Array(),
+      messageHandler: async msg => ({}),
       port: bobPort
     });
 

package/src/rpc.ts

@@ -12,6 +12,7 @@ import { StackTrace } from '@dxos/debug';
 import { RpcClosedError, RpcNotOpenError, SerializedRpcError } from './errors';
 import { schema } from './proto/gen';
 import { Request, Response, Error as ErrorResponse, RpcMessage } from './proto/gen/dxos/rpc';
+import { Any } from './proto/gen/google/protobuf';
 
 const DEFAULT_TIMEOUT = 3000;
 
@@ -20,8 +21,8 @@ const log = debug('dxos:rpc');
 type MaybePromise<T> = Promise<T> | T
 
 export interface RpcPeerOptions {
-  messageHandler: (method: string, request: Uint8Array) => MaybePromise<Uint8Array>
-  streamHandler?: (method: string, request: Uint8Array) => Stream<Uint8Array>
+  messageHandler: (method: string, request: Any) => MaybePromise<Any>
+  streamHandler?: (method: string, request: Any) => Stream<Any>
   port: RpcPort,
   timeout?: number,
 }
@@ -55,6 +56,8 @@ const codec = schema.getCodecForType('dxos.rpc.RpcMessage');
  * Both sides must be opened before making any RPC calls.
  *
  * Errors inside the handler get serialized and sent to the other side.
+ *
+ * Inspired by JSON-RPC 2.0 https://www.jsonrpc.org/specification.
  */
 export class RpcPeer {
   private readonly _outgoingRequests = new Map<number, RequestItem>();
@@ -169,7 +172,7 @@ export class RpcPeer {
    *
    * Peer should be open before making this call.
    */
-  async call (method: string, request: Uint8Array): Promise<Uint8Array> {
+  async call (method: string, request: Any): Promise<Any> {
     if (!this._open) {
       throw new RpcNotOpenError();
     }
@@ -223,7 +226,7 @@ export class RpcPeer {
    *
    * Peer should be open before making this call.
    */
-  callStream (method: string, request: Uint8Array): Stream<Uint8Array> {
+  callStream (method: string, request: Any): Stream<Any> {
     if (!this._open) {
       throw new RpcNotOpenError();
     }

package/src/trace.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+
+import { MessageTrace } from './proto/gen/dxos/rpc';
+import { RpcPort } from './rpc';
+
+export class PortTracer {
+  readonly message = new Event<MessageTrace>();
+
+  private readonly _port: RpcPort;
+
+  constructor (
+    private readonly _wrappedPort: RpcPort
+  ) {
+    this._port = {
+      send: (msg: Uint8Array) => {
+        this.message.emit({
+          direction: MessageTrace.Direction.OUTGOING,
+          data: msg
+        });
+
+        return this._wrappedPort.send(msg);
+      },
+      subscribe: (cb: (msg: Uint8Array) => void) => {
+        return this._wrappedPort.subscribe(msg => {
+          this.message.emit({
+            direction: MessageTrace.Direction.INCOMING,
+            data: msg
+          });
+          cb(msg);
+        });
+      }
+    };
+  }
+
+  public get port () {
+    return this._port;
+  }
+}

package/src/proto/schema.proto

@@ -1,48 +0,0 @@
-//
-// Copyright 2020 DXOS.org
-//
-
-syntax = "proto3";
-
-package dxos.rpc;
-
-message RpcMessage {
-  oneof content {
-    Request request = 1;
-    Response response = 2;
-
-    /// Means that the node is open to receiving requests. Second stage of the hasnshake protocol.
-    bool open = 3;
-
-    StreamClose streamClose = 4;
-  }
-}
-
-message Request {
-  int32 id = 1;
-  string method = 2;
-  bytes payload = 3;
-  bool stream = 4;
-}
-
-message Response {
-  int32 id = 1;
-  oneof content {
-    bytes payload = 2;
-    Error error = 3;
-    // Sent when stream is closed without an error.
-    bool close = 4;
-  }
-}
-
-// Sent by client to end the streaming response.
-message StreamClose {
-  int32 id = 1;
-}
-
-
-message Error {
-  string name = 1;
-  string message = 2;
-  string stack = 3;
-}