@dxos/teleport 0.1.55-main.b01c908 → 0.1.55-main.de1d511

package/dist/lib/browser/{chunk-7TGKNWZQ.mjs → chunk-HCC6HY7F.mjs}

@@ -1,5 +1,22 @@
 import "@dxos/node-std/globals";
 
+// packages/core/mesh/teleport/src/testing/test-builder.ts
+import { pipeline } from "@dxos/node-std/stream";
+import invariant4 from "tiny-invariant";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log3 } from "@dxos/log";
+
+// packages/core/mesh/teleport/src/teleport.ts
+import invariant3 from "tiny-invariant";
+import { asyncTimeout, scheduleTaskInterval as scheduleTaskInterval2, runInContextAsync, synchronized, scheduleTask } from "@dxos/async";
+import { Context as Context2 } from "@dxos/context";
+import { failUndefined as failUndefined2 } from "@dxos/debug";
+import { PublicKey } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
+import { schema as schema2, RpcClosedError } from "@dxos/protocols";
+import { createProtoRpcPeer } from "@dxos/rpc";
+import { Callback } from "@dxos/util";
+
 // packages/core/mesh/teleport/src/muxing/framer.ts
 import { Duplex } from "@dxos/node-std/stream";
 import invariant from "tiny-invariant";
@@ -318,11 +335,11 @@ var Muxer = class {
       return;
     }
     this._destroying = true;
-    Promise.resolve(this._sendCommand({
+    this._sendCommand({
       destroy: {
         error: err == null ? void 0 : err.message
       }
-    }, SYSTEM_CHANNEL_ID)).then(() => {
+    }, SYSTEM_CHANNEL_ID).then(() => {
       this._dispose();
     }).catch((err2) => {
       this._dispose(err2);
@@ -350,7 +367,7 @@ var Muxer = class {
       cmd
     }, {
       F: __dxlog_file,
-      L: 239,
+      L: 237,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -359,7 +376,7 @@ var Muxer = class {
         cmd
       }, {
         F: __dxlog_file,
-        L: 242,
+        L: 240,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -387,7 +404,7 @@ var Muxer = class {
           tag: stream.tag
         }, {
           F: __dxlog_file,
-          L: 269,
+          L: 267,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -463,15 +480,6 @@ var Muxer = class {
 };
 
 // packages/core/mesh/teleport/src/teleport.ts
-import invariant3 from "tiny-invariant";
-import { asyncTimeout, scheduleTaskInterval as scheduleTaskInterval2, runInContextAsync, synchronized, scheduleTask } from "@dxos/async";
-import { Context as Context2 } from "@dxos/context";
-import { failUndefined as failUndefined2 } from "@dxos/debug";
-import { PublicKey } from "@dxos/keys";
-import { log as log2 } from "@dxos/log";
-import { schema as schema2, RpcClosedError } from "@dxos/protocols";
-import { createProtoRpcPeer } from "@dxos/rpc";
-import { Callback } from "@dxos/util";
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -516,7 +524,6 @@ var Teleport = class {
     invariant3(typeof initiator === "boolean");
     invariant3(PublicKey.isPublicKey(localPeerId));
     invariant3(PublicKey.isPublicKey(remotePeerId));
-    invariant3(typeof initiator === "boolean");
     this.initiator = initiator;
     this.localPeerId = localPeerId;
     this.remotePeerId = remotePeerId;
@@ -525,7 +532,7 @@ var Teleport = class {
         name
       }, {
         F: __dxlog_file2,
-        L: 65,
+        L: 64,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -576,7 +583,7 @@ var Teleport = class {
       } catch (err2) {
         log2.catch(err2, void 0, {
           F: __dxlog_file2,
-          L: 125,
+          L: 124,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -592,7 +599,7 @@ var Teleport = class {
       name
     }, {
       F: __dxlog_file2,
-      L: 137,
+      L: 136,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -624,7 +631,7 @@ var Teleport = class {
       extensionName
     }, {
       F: __dxlog_file2,
-      L: 167,
+      L: 166,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -652,7 +659,7 @@ var Teleport = class {
       extensionName
     }, {
       F: __dxlog_file2,
-      L: 190,
+      L: 189,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -713,13 +720,134 @@ var ControlExtension = class {
   }
 };
 
+// packages/core/mesh/teleport/src/testing/test-builder.ts
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-builder.ts";
+var TestBuilder = class {
+  constructor() {
+    this._peers = /* @__PURE__ */ new Set();
+  }
+  createPeer(opts) {
+    const peer = opts.factory();
+    this._peers.add(peer);
+    return peer;
+  }
+  *createPeers(opts) {
+    while (true) {
+      yield this.createPeer(opts);
+    }
+  }
+  async destroy() {
+    await Promise.all(Array.from(this._peers).map((agent) => agent.destroy()));
+  }
+  async connect(peer1, peer2) {
+    invariant4(peer1 !== peer2);
+    invariant4(this._peers.has(peer1));
+    invariant4(this._peers.has(peer1));
+    const connection1 = peer1.createConnection({
+      initiator: true,
+      remotePeerId: peer2.peerId
+    });
+    const connection2 = peer2.createConnection({
+      initiator: false,
+      remotePeerId: peer1.peerId
+    });
+    pipeStreams(connection1.teleport.stream, connection2.teleport.stream);
+    await Promise.all([
+      peer1.openConnection(connection1),
+      peer2.openConnection(connection2)
+    ]);
+    return [
+      connection1,
+      connection2
+    ];
+  }
+  async disconnect(peer1, peer2) {
+    invariant4(peer1 !== peer2);
+    invariant4(this._peers.has(peer1));
+    invariant4(this._peers.has(peer1));
+    const connection1 = Array.from(peer1.connections).find((connection) => connection.remotePeerId.equals(peer2.peerId));
+    const connection2 = Array.from(peer2.connections).find((connection) => connection.remotePeerId.equals(peer1.peerId));
+    invariant4(connection1);
+    invariant4(connection2);
+    await Promise.all([
+      peer1.closeConnection(connection1),
+      peer2.closeConnection(connection2)
+    ]);
+  }
+};
+var TestPeer = class {
+  constructor(peerId = PublicKey2.random()) {
+    this.peerId = peerId;
+    this.connections = /* @__PURE__ */ new Set();
+  }
+  async onOpen(connection) {
+  }
+  async onClose(connection) {
+  }
+  createConnection({ initiator, remotePeerId }) {
+    const connection = new TestConnection(this.peerId, remotePeerId, initiator);
+    this.connections.add(connection);
+    return connection;
+  }
+  async openConnection(connection) {
+    invariant4(this.connections.has(connection));
+    await connection.teleport.open();
+    await this.onOpen(connection);
+  }
+  async closeConnection(connection) {
+    invariant4(this.connections.has(connection));
+    await this.onClose(connection);
+    await connection.teleport.close();
+    this.connections.delete(connection);
+  }
+  async destroy() {
+    for (const teleport of this.connections) {
+      await this.closeConnection(teleport);
+    }
+  }
+};
+var pipeStreams = (stream1, stream2) => {
+  pipeline(stream1, stream2, (err) => {
+    if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+      log3.catch(err, void 0, {
+        F: __dxlog_file3,
+        L: 106,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  });
+  pipeline(stream2, stream1, (err) => {
+    if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+      log3.catch(err, void 0, {
+        F: __dxlog_file3,
+        L: 111,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  });
+};
+var TestConnection = class {
+  constructor(localPeerId, remotePeerId, initiator) {
+    this.localPeerId = localPeerId;
+    this.remotePeerId = remotePeerId;
+    this.initiator = initiator;
+    this.teleport = new Teleport({
+      initiator,
+      localPeerId,
+      remotePeerId
+    });
+  }
+};
+
 // packages/core/mesh/teleport/src/testing/test-extension.ts
-import invariant4 from "tiny-invariant";
+import invariant5 from "tiny-invariant";
 import { asyncTimeout as asyncTimeout2, Trigger as Trigger2 } from "@dxos/async";
-import { log as log3 } from "@dxos/log";
+import { log as log4 } from "@dxos/log";
 import { schema as schema3 } from "@dxos/protocols";
 import { createProtoRpcPeer as createProtoRpcPeer2 } from "@dxos/rpc";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-extension.ts";
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-extension.ts";
 var TestExtension = class {
   constructor(callbacks = {}) {
     this.callbacks = callbacks;
@@ -732,11 +860,11 @@ var TestExtension = class {
   }
   async onOpen(context) {
     var _a, _b;
-    log3("onOpen", {
+    log4("onOpen", {
       localPeerId: context.localPeerId,
       remotePeerId: context.remotePeerId
     }, {
-      F: __dxlog_file3,
+      F: __dxlog_file4,
       L: 33,
       S: this,
       C: (f, a) => f(...a)
@@ -771,10 +899,10 @@ var TestExtension = class {
   }
   async onClose(err) {
     var _a, _b, _c;
-    log3("onClose", {
+    log4("onClose", {
       err
     }, {
-      F: __dxlog_file3,
+      F: __dxlog_file4,
       L: 67,
       S: this,
       C: (f, a) => f(...a)
@@ -790,7 +918,207 @@ var TestExtension = class {
     const res = await asyncTimeout2(this._rpc.rpc.TestService.testCall({
       data: message
     }), 1500);
-    invariant4(res.data === message);
+    invariant5(res.data === message);
+  }
+  /**
+  * Force-close the connection.
+  */
+  async closeConnection(err) {
+    var _a;
+    (_a = this.extensionContext) == null ? void 0 : _a.close(err);
+  }
+};
+
+// packages/core/mesh/teleport/src/testing/test-extension-with-streams.ts
+import assert from "@dxos/node-std/assert";
+import { randomBytes } from "@dxos/node-std/crypto";
+import { Trigger as Trigger3 } from "@dxos/async";
+import { log as log5 } from "@dxos/log";
+import { schema as schema4 } from "@dxos/protocols";
+import { createProtoRpcPeer as createProtoRpcPeer3 } from "@dxos/rpc";
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-extension-with-streams.ts";
+var TestExtensionWithStreams = class {
+  constructor(callbacks = {}) {
+    this.callbacks = callbacks;
+    this.open = new Trigger3();
+    this.closed = new Trigger3();
+    this._streams = /* @__PURE__ */ new Map();
+  }
+  get remotePeerId() {
+    var _a;
+    return (_a = this.extensionContext) == null ? void 0 : _a.remotePeerId;
+  }
+  async _openStream(streamTag, interval = 5, chunkSize = 2048) {
+    assert(!this._streams.has(streamTag), `Stream already exists: ${streamTag}`);
+    const networkStream = await this.extensionContext.createStream(streamTag, {
+      contentType: "application/x-test-stream"
+    });
+    const streamEntry = {
+      networkStream,
+      bytesSent: 0,
+      bytesReceived: 0,
+      sendErrors: 0,
+      receiveErrors: 0,
+      startTimestamp: Date.now()
+    };
+    const pushChunk = () => {
+      streamEntry.timer = setTimeout(() => {
+        const chunk = randomBytes(chunkSize);
+        if (!networkStream.write(chunk, "binary", (err) => {
+          if (!err) {
+            streamEntry.bytesSent += chunk.length;
+          } else {
+            streamEntry.sendErrors += 1;
+          }
+        })) {
+          networkStream.once("drain", pushChunk);
+        } else {
+          process.nextTick(pushChunk);
+        }
+      }, interval);
+    };
+    pushChunk();
+    this._streams.set(streamTag, streamEntry);
+    networkStream.on("data", (data) => {
+      streamEntry.bytesReceived += data.length;
+    });
+    networkStream.on("error", (err) => {
+      streamEntry.receiveErrors += 1;
+    });
+    networkStream.on("close", () => {
+      networkStream.removeAllListeners();
+    });
+  }
+  _closeStream(streamTag) {
+    assert(this._streams.has(streamTag), `Stream does not exist: ${streamTag}`);
+    const stream = this._streams.get(streamTag);
+    clearTimeout(stream.timer);
+    const { bytesSent, bytesReceived, sendErrors, receiveErrors, startTimestamp } = stream;
+    stream.networkStream.destroy();
+    this._streams.delete(streamTag);
+    return {
+      bytesSent,
+      bytesReceived,
+      sendErrors,
+      receiveErrors,
+      runningTime: Date.now() - (startTimestamp != null ? startTimestamp : 0)
+    };
+  }
+  async onOpen(context) {
+    var _a, _b;
+    log5("onOpen", {
+      localPeerId: context.localPeerId,
+      remotePeerId: context.remotePeerId
+    }, {
+      F: __dxlog_file5,
+      L: 111,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this.extensionContext = context;
+    this._rpc = createProtoRpcPeer3({
+      port: await context.createPort("rpc", {
+        contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
+      }),
+      requested: {
+        TestServiceWithStreams: schema4.getService("example.testing.rpc.TestServiceWithStreams")
+      },
+      exposed: {
+        TestServiceWithStreams: schema4.getService("example.testing.rpc.TestServiceWithStreams")
+      },
+      handlers: {
+        TestServiceWithStreams: {
+          requestTestStream: async (request) => {
+            const { data: streamTag, streamLoadInterval, streamLoadChunkSize } = request;
+            await this._openStream(streamTag, streamLoadInterval, streamLoadChunkSize);
+            return {
+              data: streamTag
+            };
+          },
+          closeTestStream: async (request) => {
+            const streamTag = request.data;
+            const { bytesSent, bytesReceived, sendErrors, receiveErrors, runningTime } = this._closeStream(streamTag);
+            return {
+              data: streamTag,
+              bytesSent,
+              bytesReceived,
+              sendErrors,
+              receiveErrors,
+              runningTime
+            };
+          }
+        }
+      },
+      timeout: 2e3
+    });
+    await this._rpc.open();
+    await ((_b = (_a = this.callbacks).onOpen) == null ? void 0 : _b.call(_a));
+    this.open.wake();
+  }
+  async onClose(err) {
+    var _a, _b, _c;
+    log5("onClose", {
+      err
+    }, {
+      F: __dxlog_file5,
+      L: 162,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await ((_b = (_a = this.callbacks).onClose) == null ? void 0 : _b.call(_a));
+    this.closed.wake();
+    for (const [streamTag, stream] of Object.entries(this._streams)) {
+      log5("closing stream", {
+        streamTag
+      }, {
+        F: __dxlog_file5,
+        L: 166,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      clearTimeout(stream.interval);
+      stream.networkStream.destroy();
+    }
+    await ((_c = this._rpc) == null ? void 0 : _c.close());
+  }
+  async addNewStream(streamLoadInterval, streamLoadChunkSize, streamTag) {
+    await this.open.wait({
+      timeout: 1500
+    });
+    if (!streamTag) {
+      streamTag = `stream-${randomBytes(4).toString("hex")}`;
+    }
+    const { data } = await this._rpc.rpc.TestServiceWithStreams.requestTestStream({
+      data: streamTag,
+      streamLoadInterval,
+      streamLoadChunkSize
+    });
+    assert(data === streamTag);
+    await this._openStream(streamTag, streamLoadInterval, streamLoadChunkSize);
+    return streamTag;
+  }
+  async closeStream(streamTag) {
+    await this.open.wait({
+      timeout: 1500
+    });
+    const { data, bytesSent, bytesReceived, sendErrors, receiveErrors, runningTime } = await this._rpc.rpc.TestServiceWithStreams.closeTestStream({
+      data: streamTag
+    });
+    assert(data === streamTag);
+    const local = this._closeStream(streamTag);
+    return {
+      streamTag,
+      stats: {
+        local,
+        remote: {
+          bytesSent,
+          bytesReceived,
+          sendErrors,
+          receiveErrors,
+          runningTime
+        }
+      }
+    };
   }
   /**
   * Force-close the connection.
@@ -807,6 +1135,10 @@ export {
   encodeFrame,
   Muxer,
   Teleport,
-  TestExtension
+  TestBuilder,
+  TestPeer,
+  TestConnection,
+  TestExtension,
+  TestExtensionWithStreams
 };
-//# sourceMappingURL=chunk-7TGKNWZQ.mjs.map
+//# sourceMappingURL=chunk-HCC6HY7F.mjs.map