@dxos/rpc 2.33.9-dev.7d11f506 → 2.33.9-dev.9bbef4e2

package/src/rpc.test.ts

@@ -13,17 +13,22 @@ import { Any } from './proto/gen/google/protobuf';
 import { RpcPeer } from './rpc';
 import { createLinkedPorts } from './testutil';
 
+const createPayload = (value = ''): Any => ({
+  type_url: '',
+  value: Buffer.from(value)
+});
+
 describe('RpcPeer', () => {
   describe('handshake', () => {
     test('can open', async () => {
       const [alicePort, bobPort] = createLinkedPorts();
 
       const alice = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort
       });
 
@@ -36,11 +41,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 => ({}),
+        messageHandler: async msg => createPayload(),
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort
       });
 
@@ -64,7 +69,7 @@ describe('RpcPeer', () => {
       const [alicePort, bobPort] = createLinkedPorts();
 
       const alice: RpcPeer = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: alicePort
       });
       const aliceOpen = alice.open();
@@ -72,7 +77,7 @@ describe('RpcPeer', () => {
       await sleep(5);
 
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort
       });
 
@@ -88,7 +93,7 @@ describe('RpcPeer', () => {
       let portOpen = false;
 
       const alice: RpcPeer = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: {
           send: msg => {
             portOpen && alicePort.send(msg);
@@ -98,7 +103,7 @@ describe('RpcPeer', () => {
       });
 
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: {
           send: msg => {
             portOpen && bobPort.send(msg);
@@ -123,7 +128,7 @@ describe('RpcPeer', () => {
       const [alicePort, bobPort] = createLinkedPorts();
 
       const alice: RpcPeer = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: {
           send: msg => { },
           subscribe: alicePort.subscribe
@@ -131,7 +136,7 @@ describe('RpcPeer', () => {
       });
 
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort
       });
 
@@ -160,12 +165,12 @@ describe('RpcPeer', () => {
         messageHandler: async (method, msg) => {
           expect(method).toEqual('method');
           expect(msg.value).toEqual(Buffer.from('request'));
-          return { value: Buffer.from('response') };
+          return createPayload('response');
         },
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async (method, msg) => ({}),
+        messageHandler: async (method, msg) => createPayload(),
         port: bobPort
       });
 
@@ -174,8 +179,8 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      const response = await bob.call('method', { value: Buffer.from('request') });
-      expect(response).toEqual({ value: Buffer.from('response') });
+      const response = await bob.call('method', createPayload('request'));
+      expect(response).toEqual(createPayload('response'));
     });
 
     test('can send multiple requests', async () => {
@@ -197,7 +202,7 @@ describe('RpcPeer', () => {
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort
       });
 
@@ -206,14 +211,14 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      expect((await bob.call('method', { value: Buffer.from('request') })).value).toEqual(Buffer.from('request'));
+      expect((await bob.call('method', createPayload('request'))).value).toEqual(Buffer.from('request'));
 
-      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') });
+      const parallel1 = bob.call('method', createPayload('p1'));
+      const parallel2 = bob.call('method', createPayload('p2'));
+      const error = bob.call('method', createPayload('error'));
 
-      await expect(await parallel1).toEqual({ value: Buffer.from('p1') });
-      await expect(await parallel2).toEqual({ value: Buffer.from('p2') });
+      await expect(await parallel1).toEqual(createPayload('p1'));
+      await expect(await parallel2).toEqual(createPayload('p2'));
       await expect(error).toBeRejected();
     });
 
@@ -232,7 +237,7 @@ describe('RpcPeer', () => {
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort
       });
 
@@ -243,7 +248,7 @@ describe('RpcPeer', () => {
 
       let error!: Error;
       try {
-        await bob.call('RpcMethodName', { value: Buffer.from('request') });
+        await bob.call('RpcMethodName', createPayload('request'));
       } catch (err: any) {
         error = err;
       }
@@ -266,7 +271,7 @@ describe('RpcPeer', () => {
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort
       });
 
@@ -275,7 +280,7 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      const req = bob.call('method', { value: Buffer.from('request') });
+      const req = bob.call('method', createPayload('request'));
       bob.close();
 
       await expect(req).toBeRejected();
@@ -293,7 +298,7 @@ describe('RpcPeer', () => {
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort,
         timeout: 50
       });
@@ -304,8 +309,34 @@ describe('RpcPeer', () => {
       ]);
 
       alice.close();
-      const req = bob.call('method', { value: Buffer.from('request') });
+      const req = bob.call('method', createPayload('request'));
+
+      await expect(req).toBeRejected();
+    });
+
+    test('requests failing on timeout', async () => {
+      const [alicePort, bobPort] = createLinkedPorts();
+
+      const alice: RpcPeer = new RpcPeer({
+        messageHandler: async (method, msg) => {
+          expect(method).toEqual('method');
+          await sleep(50);
+          return msg;
+        },
+        port: alicePort
+      });
+      const bob = new RpcPeer({
+        messageHandler: async msg => createPayload(),
+        port: bobPort,
+        timeout: 10
+      });
 
+      await Promise.all([
+        alice.open(),
+        bob.open()
+      ]);
+
+      const req = bob.call('method', createPayload('request'));
       await expect(req).toBeRejected();
     });
 
@@ -316,20 +347,20 @@ describe('RpcPeer', () => {
       const [alicePort, bobPort] = createLinkedPorts();
 
       const alice = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         streamHandler: (method, msg) => {
           expect(method).toEqual('method');
           expect(msg.value!).toEqual(Buffer.from('request'));
           return new Stream<Any>(({ next, close }) => {
-            next({ value: Buffer.from('res1') });
-            next({ value: Buffer.from('res2') });
+            next(createPayload('res1'));
+            next(createPayload('res2'));
             close();
           });
         },
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort
       });
 
@@ -338,12 +369,13 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      const stream = await bob.callStream('method', { value: Buffer.from('request') });
+      const stream = await bob.callStream('method', createPayload('request'));
       expect(stream).toBeA(Stream);
 
       expect(await Stream.consume(stream)).toEqual([
-        { data: { value: Buffer.from('res1') } },
-        { data: { value: Buffer.from('res2') } },
+        { ready: true },
+        { data: createPayload('res1') },
+        { data: createPayload('res2') },
         { closed: true }
       ]);
     });
@@ -352,7 +384,7 @@ describe('RpcPeer', () => {
       const [alicePort, bobPort] = createLinkedPorts();
 
       const alice = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         streamHandler: (method, msg) => {
           expect(method).toEqual('method');
           expect(msg.value).toEqual(Buffer.from('request'));
@@ -363,7 +395,7 @@ describe('RpcPeer', () => {
         port: alicePort
       });
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort
       });
 
@@ -372,7 +404,7 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      const stream = await bob.callStream('method', { value: Buffer.from('request') });
+      const stream = await bob.callStream('method', createPayload('request'));
       expect(stream).toBeA(Stream);
 
       const msgs = await Stream.consume(stream);
@@ -388,7 +420,7 @@ describe('RpcPeer', () => {
 
       let closeCalled = false;
       const alice = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         streamHandler: (method, msg) => new Stream<Any>(({ next, close }) => () => {
           closeCalled = true;
         }),
@@ -396,7 +428,7 @@ describe('RpcPeer', () => {
       });
 
       const bob = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: bobPort
       });
 
@@ -405,13 +437,49 @@ describe('RpcPeer', () => {
         bob.open()
       ]);
 
-      const stream = bob.callStream('method', { value: Buffer.from('request') });
+      const stream = bob.callStream('method', createPayload('request'));
       stream.close();
 
       await sleep(1);
 
       expect(closeCalled).toEqual(true);
     });
+
+    test('reports stream being ready', async () => {
+      const [alicePort, bobPort] = createLinkedPorts();
+
+      const alice = new RpcPeer({
+        messageHandler: async msg => createPayload(),
+        streamHandler: (method, msg) => {
+          expect(method).toEqual('method');
+          expect(msg.value!).toEqual(Buffer.from('request'));
+          return new Stream<Any>(({ ready, close }) => {
+            ready();
+            close();
+          });
+        },
+        port: alicePort
+      });
+      const bob = new RpcPeer({
+        messageHandler: async msg => createPayload(),
+        port: bobPort
+      });
+
+      await Promise.all([
+        alice.open(),
+        bob.open()
+      ]);
+
+      const stream = await bob.callStream('method', createPayload('request'));
+      expect(stream).toBeA(Stream);
+
+      await stream.waitUntilReady();
+
+      expect(await Stream.consume(stream)).toEqual([
+        { ready: true },
+        { closed: true }
+      ]);
+    });
   });
 
   describe('with disabled handshake', () => {
@@ -419,7 +487,7 @@ describe('RpcPeer', () => {
       const [alicePort] = createLinkedPorts();
 
       const alice = new RpcPeer({
-        messageHandler: async msg => ({}),
+        messageHandler: async msg => createPayload(),
         port: alicePort,
         noHandshake: true
       });
@@ -434,13 +502,13 @@ describe('RpcPeer', () => {
         messageHandler: async (method, msg) => {
           expect(method).toEqual('method');
           expect(msg.value).toEqual(Buffer.from('request'));
-          return { value: Buffer.from('response') };
+          return createPayload('response');
         },
         port: alicePort,
         noHandshake: true
       });
       const bob = new RpcPeer({
-        messageHandler: async (method, msg) => ({}),
+        messageHandler: async (method, msg) => createPayload(),
         port: bobPort,
         noHandshake: true
       });
@@ -448,8 +516,8 @@ describe('RpcPeer', () => {
       await alice.open();
       await bob.open();
 
-      const response = await bob.call('method', { value: Buffer.from('request') });
-      expect(response).toEqual({ value: Buffer.from('response') });
+      const response = await bob.call('method', createPayload('request'));
+      expect(response).toEqual(createPayload('response'));
     });
   });
 });

package/src/rpc.ts

@@ -2,12 +2,13 @@
 // Copyright 2021 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
-import { sleep, synchronized, Trigger } from '@dxos/async';
+import { synchronized, Trigger } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { StackTrace } from '@dxos/debug';
+import { exponentialBackoffInterval } from '@dxos/util';
 
 import { RpcClosedError, RpcNotOpenError, SerializedRpcError } from './errors';
 import { schema } from './proto/gen';
@@ -142,7 +143,12 @@ export class RpcPeer {
     if (decoded.request) {
       if (!this._open) {
         log('Received request while not open.');
-        await this._sendMessage({ response: { error: encodeError(new RpcClosedError()) } });
+        await this._sendMessage({
+          response: {
+            id: decoded.request.id,
+            error: encodeError(new RpcClosedError())
+          }
+        });
         return;
       }
 
@@ -168,16 +174,18 @@ export class RpcPeer {
         return; // Ignore when not open.
       }
 
-      assert(typeof decoded.response.id === 'number');
-      if (!this._outgoingRequests.has(decoded.response.id)) {
-        log(`Received response with incorrect id: ${decoded.response.id}`);
+      const responseId = decoded.response.id;
+
+      assert(typeof responseId === 'number');
+      if (!this._outgoingRequests.has(responseId)) {
+        log(`Received response with incorrect id: ${responseId}`);
         return; // Ignore requests with incorrect id.
       }
 
-      const item = this._outgoingRequests.get(decoded.response.id)!;
+      const item = this._outgoingRequests.get(responseId)!;
       // Delete the request record if no more responses are expected.
       if (!item.stream) {
-        this._outgoingRequests.delete(decoded.response.id);
+        this._outgoingRequests.delete(responseId);
       }
 
       log(`Response: ${decoded.response.payload?.type_url}`);
@@ -239,20 +247,18 @@ export class RpcPeer {
     // Here we're attaching a dummy handler that will not interfere with error handling to avoid that warning.
     promise.catch(() => {});
 
-    await this._sendMessage({
+    void this._sendMessage({
       request: {
         id,
         method,
-        payload: request
+        payload: request,
+        stream: false
       }
     });
 
-    const timeoutPromise = sleep(this._options.timeout ?? DEFAULT_TIMEOUT).then(() => Promise.reject(new Error('Timeout')));
-    timeoutPromise.catch(() => {}); // Mute the promise.
-
     let response: Response;
     try {
-      response = await Promise.race([promise, timeoutPromise]);
+      response = await Promise.race([promise, createTimeoutPromise(this._options.timeout ?? DEFAULT_TIMEOUT, new Error(`RPC call timed out: ${method}`))]);
     } catch (err) {
       if (err instanceof RpcClosedError) {
         // Rethrow the error here to have the correct stack-trace.
@@ -285,9 +291,11 @@ export class RpcPeer {
 
     const id = this._nextId++;
 
-    return new Stream(({ next, close }) => {
+    return new Stream(({ ready, next, close }) => {
       const onResponse = (response: Response) => {
-        if (response.close) {
+        if (response.streamReady) {
+          ready();
+        } else if (response.close) {
           close();
         } else if (response.error) {
           assert(response.error.name);
@@ -361,6 +369,12 @@ export class RpcPeer {
       assert(req.payload);
       assert(req.method);
       const responseStream = this._options.streamHandler(req.method, req.payload);
+      responseStream.onReady(() => {
+        callback({
+          id: req.id,
+          streamReady: true
+        });
+      });
       responseStream.subscribe(
         msg => {
           callback({
@@ -411,16 +425,22 @@ const encodeError = (err: any): ErrorResponse => {
 };
 
 /**
- * Runs the callback in an exponentially increasing interval
- * @returns Callback to clear the interval.
+ * Creates a promise that will be rejected after a certain timeout.
+ * The promise will never cause unhandledPromiseRejection.
+ * The timeout will not block the Node.JS process from exiting.
  */
-const exponentialBackoffInterval = (cb: () => void, initialInterval: number): () => void => {
-  let interval = initialInterval;
-  const repeat = () => {
-    cb();
-    interval *= 2;
-    timeoutId = setTimeout(repeat, interval);
-  };
-  let timeoutId = setTimeout(repeat, interval);
-  return () => clearTimeout(timeoutId);
+const createTimeoutPromise = (timeout: number, error: Error) => {
+  const timeoutPromise = new Promise<any>((resolve, reject) => {
+    const timeoutId = setTimeout(
+      () => reject(error),
+      timeout
+    );
+
+    // `unref` prevents the timeout from blocking Node.JS process from exiting. Not available in browsers.
+    if (typeof timeoutId === 'object' && 'unref' in timeoutId) {
+      timeoutId.unref();
+    }
+  });
+  timeoutPromise.catch(() => {}); // Mute the promise.
+  return timeoutPromise;
 };

package/src/service.test.ts

@@ -161,6 +161,7 @@ describe('Protobuf service', () => {
       const stream = client.rpc.testCall({ data: 'requestData' });
 
       expect(await Stream.consume(stream)).toEqual([
+        { ready: true },
         { data: { data: 'foo' } },
         { data: { data: 'bar' } },
         { data: { data: 'baz' } },

package/src/service.ts

@@ -86,9 +86,12 @@ export const createBundledRpcClient = <S>(descriptors: ServiceBundle<S>, options
 
   const rpc: S = {} as S;
   for (const serviceName of Object.keys(descriptors) as (keyof S)[]) {
+    // Get full service name with the package name without '.' at the beginning.
+    const serviceFqn = descriptors[serviceName].serviceProto.fullName.slice(1);
+
     rpc[serviceName] = descriptors[serviceName].createClient({
-      call: (method, req) => peer.call(`${String(serviceName)}.${method}`, req),
-      callStream: (method, req) => peer.callStream(`${String(serviceName)}.${method}`, req)
+      call: (method, req) => peer.call(`${serviceFqn}.${method}`, req),
+      callStream: (method, req) => peer.callStream(`${serviceFqn}.${method}`, req)
     });
   }
 
@@ -106,7 +109,10 @@ export interface RpcBundledServerOptions<S> extends Omit<RpcPeerOptions, 'messag
 export const createBundledRpcServer = <S>({ services, handlers, ...rest }: RpcBundledServerOptions<S>): RpcPeer => {
   const rpc: Record<string, ServiceHandler<any>> = {};
   for (const serviceName of Object.keys(services) as (keyof S)[]) {
-    rpc[serviceName as any] = services[serviceName].createServer(handlers[serviceName] as any);
+    // Get full service name with the package name without '.' at the beginning.
+    const serviceFqn = services[serviceName].serviceProto.fullName.slice(1);
+
+    rpc[serviceFqn] = services[serviceName].createServer(handlers[serviceName] as any);
   }
 
   const peer = new RpcPeer({
@@ -133,9 +139,11 @@ export const createBundledRpcServer = <S>({ services, handlers, ...rest }: RpcBu
 };
 
 const parseMethodName = (method: string): [serviceName: string, methodName: string] => {
-  const [serviceName, ...rest] = method.split('.');
-  if (rest.length === 0) {
-    throw new Error('Method name required');
+  const separator = method.lastIndexOf('.');
+  const serviceName = method.slice(0, separator);
+  const methodName = method.slice(separator + 1);
+  if (serviceName.length === 0 || methodName.length === 0) {
+    throw new Error(`Invalid method: ${method}`);
   }
-  return [serviceName, rest.join('.')];
+  return [serviceName, methodName];
 };