@dxos/teleport 0.1.14

package/dist/lib/browser/testing.mjs

@@ -0,0 +1,621 @@
+// packages/core/mesh/teleport/src/testing.ts
+import { pipeline } from "@dxos/node-std/stream";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log3 } from "@dxos/log";
+
+// packages/core/mesh/teleport/src/teleport.ts
+import assert3 from "@dxos/node-std/assert";
+import { asyncTimeout, scheduleTaskInterval, runInContextAsync, synchronized, scheduleTask } from "@dxos/async";
+import { Context } 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 } from "@dxos/protocols";
+import { createProtoRpcPeer, RpcClosedError } from "@dxos/rpc";
+import { Callback } from "@dxos/util";
+
+// packages/core/mesh/teleport/src/muxing/framer.ts
+import assert from "@dxos/node-std/assert";
+import { Duplex } from "@dxos/node-std/stream";
+import * as varint from "varint";
+var Framer = class {
+  constructor() {
+    this._stream = new Duplex({
+      objectMode: false,
+      read: () => {
+      },
+      write: (chunk, encoding, callback) => {
+        assert(!this._subscribeCb, "Internal Framer bug. Concurrent writes detected.");
+        if (this._buffer && this._buffer.length > 0) {
+          this._buffer = Buffer.concat([
+            this._buffer,
+            chunk
+          ]);
+        } else {
+          this._buffer = chunk;
+        }
+        if (this._messageCb) {
+          this._popFrames();
+          callback();
+        } else {
+          this._subscribeCb = () => {
+            this._popFrames();
+            this._subscribeCb = void 0;
+            callback();
+          };
+        }
+      }
+    });
+    this.port = {
+      send: (message) => {
+        this._stream.push(encodeLength(message.length));
+        this._stream.push(message);
+      },
+      subscribe: (callback) => {
+        var _a;
+        assert(!this._messageCb, "Rpc port already has a message listener.");
+        this._messageCb = callback;
+        (_a = this._subscribeCb) == null ? void 0 : _a.call(this);
+        return () => {
+          this._messageCb = void 0;
+        };
+      }
+    };
+  }
+  get stream() {
+    return this._stream;
+  }
+  _popFrames() {
+    let offset = 0;
+    while (offset < this._buffer.length) {
+      const frame = readFrame(this._buffer, offset);
+      if (!frame) {
+        break;
+      }
+      offset += frame.bytesConsumed;
+      this._messageCb(frame.payload);
+    }
+    if (offset < this._buffer.length) {
+      this._buffer = this._buffer.subarray(offset);
+    } else {
+      this._buffer = void 0;
+    }
+  }
+  destroy() {
+    this._stream.destroy();
+  }
+};
+var readFrame = (buffer, offset) => {
+  try {
+    const frameLength = varint.decode(buffer, offset);
+    const tagLength = varint.decode.bytes;
+    if (buffer.length < offset + tagLength + frameLength) {
+      return void 0;
+    }
+    const payload = buffer.subarray(offset + tagLength, offset + tagLength + frameLength);
+    return {
+      payload,
+      bytesConsumed: tagLength + frameLength
+    };
+  } catch (err) {
+    if (err instanceof RangeError) {
+      return void 0;
+    } else {
+      throw err;
+    }
+  }
+};
+var encodeLength = (length) => {
+  const res = varint.encode(length, Buffer.allocUnsafe(4)).subarray(0, varint.encode.bytes);
+  if (varint.encode.bytes > 4) {
+    throw new Error("Frame too large");
+  }
+  return res;
+};
+
+// packages/core/mesh/teleport/src/muxing/muxer.ts
+import assert2 from "@dxos/node-std/assert";
+import { Duplex as Duplex2 } from "@dxos/node-std/stream";
+import { Event } from "@dxos/async";
+import { failUndefined } from "@dxos/debug";
+import { log } from "@dxos/log";
+import { schema } from "@dxos/protocols";
+var codec = schema.getCodecForType("dxos.mesh.muxer.Command");
+var Muxer = class {
+  constructor() {
+    this._framer = new Framer();
+    this.stream = this._framer.stream;
+    this._channelsByLocalId = /* @__PURE__ */ new Map();
+    this._channelsByTag = /* @__PURE__ */ new Map();
+    this._nextId = 0;
+    this._destroyed = false;
+    this._destroying = false;
+    this.close = new Event();
+    this._framer.port.subscribe((msg) => {
+      this._handleCommand(codec.decode(msg));
+    });
+  }
+  createStream(tag, opts = {}) {
+    const channel = this._getOrCreateStream({
+      tag,
+      contentType: opts.contentType
+    });
+    assert2(!channel.push, `Channel already open: ${tag}`);
+    const stream = new Duplex2({
+      write: (data, encoding, callback) => {
+        this._sendData(channel, data);
+        callback();
+      },
+      read: () => {
+      }
+    });
+    channel.push = (data) => {
+      stream.push(data);
+    };
+    channel.destroy = (err) => {
+      stream.destroy(err);
+    };
+    this._sendCommand({
+      openChannel: {
+        id: channel.id,
+        tag: channel.tag,
+        contentType: channel.contentType
+      }
+    });
+    return stream;
+  }
+  createPort(tag, opts = {}) {
+    const channel = this._getOrCreateStream({
+      tag,
+      contentType: opts.contentType
+    });
+    assert2(!channel.push, `Channel already open: ${tag}`);
+    let inboundBuffer = [];
+    let callback;
+    channel.push = (data) => {
+      if (callback) {
+        callback(data);
+      } else {
+        inboundBuffer.push(data);
+      }
+    };
+    const port = {
+      send: (data) => {
+        this._sendData(channel, data);
+      },
+      subscribe: (cb) => {
+        assert2(!callback, "Only one subscriber is allowed");
+        callback = cb;
+        for (const data of inboundBuffer) {
+          cb(data);
+        }
+        inboundBuffer = [];
+      }
+    };
+    this._sendCommand({
+      openChannel: {
+        id: channel.id,
+        tag: channel.tag,
+        contentType: channel.contentType
+      }
+    });
+    return port;
+  }
+  destroy(err) {
+    if (this._destroying) {
+      return;
+    }
+    this._destroying = true;
+    this._sendCommand({
+      destroy: {
+        error: err == null ? void 0 : err.message
+      }
+    });
+    this._dispose();
+  }
+  _dispose(err) {
+    var _a;
+    if (this._destroyed) {
+      return;
+    }
+    this._destroyed = true;
+    this._framer.destroy();
+    for (const channel of this._channelsByTag.values()) {
+      (_a = channel.destroy) == null ? void 0 : _a.call(channel, err);
+    }
+    this.close.emit(err);
+    this._channelsByLocalId.clear();
+    this._channelsByTag.clear();
+  }
+  _handleCommand(cmd) {
+    var _a;
+    log("Received command", {
+      cmd
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/muxer.ts",
+      line: 194,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (this._destroyed || this._destroying) {
+      log.warn("Received command after destroy", {}, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/muxer.ts",
+        line: 197,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    if (cmd.openChannel) {
+      const channel = this._getOrCreateStream({
+        tag: cmd.openChannel.tag,
+        contentType: cmd.openChannel.contentType
+      });
+      channel.remoteId = cmd.openChannel.id;
+      for (const data of channel.buffer) {
+        this._sendCommand({
+          data: {
+            channelId: channel.remoteId,
+            data
+          }
+        });
+      }
+      channel.buffer = [];
+    } else if (cmd.data) {
+      const stream = (_a = this._channelsByLocalId.get(cmd.data.channelId)) != null ? _a : failUndefined();
+      if (!stream.push) {
+        log.warn("Received data for channel before it was opened", {
+          tag: stream.tag
+        }, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/muxer.ts",
+          line: 221,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        return;
+      }
+      stream.push(cmd.data.data);
+    } else if (cmd.destroy) {
+      this._dispose();
+    }
+  }
+  _sendCommand(cmd) {
+    Promise.resolve(this._framer.port.send(codec.encode(cmd))).catch((err) => {
+      this.destroy(err);
+    });
+  }
+  _getOrCreateStream(params) {
+    let channel = this._channelsByTag.get(params.tag);
+    if (!channel) {
+      channel = {
+        id: this._nextId++,
+        remoteId: null,
+        tag: params.tag,
+        contentType: params.contentType,
+        buffer: [],
+        push: null,
+        destroy: null
+      };
+      this._channelsByTag.set(channel.tag, channel);
+      this._channelsByLocalId.set(channel.id, channel);
+    }
+    return channel;
+  }
+  _sendData(channel, data) {
+    if (channel.remoteId === null) {
+      channel.buffer.push(data);
+    } else {
+      this._sendCommand({
+        data: {
+          channelId: channel.remoteId,
+          data
+        }
+      });
+    }
+  }
+};
+
+// packages/core/mesh/teleport/src/teleport.ts
+var __decorate = function(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")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Teleport = class {
+  constructor({ initiator, localPeerId, remotePeerId }) {
+    this._ctx = new Context({
+      onError: (err) => {
+        void this.destroy(err).catch(() => {
+          log2.error("Error during destroy", err, {
+            file: "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/teleport.ts",
+            line: 34,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        });
+      }
+    });
+    this._muxer = new Muxer();
+    this._control = new ControlExtension({
+      heartbeatInterval: 3e3,
+      heartbeatTimeout: 3e3
+    });
+    this._extensions = /* @__PURE__ */ new Map();
+    this._remoteExtensions = /* @__PURE__ */ new Set();
+    this._open = false;
+    assert3(typeof initiator === "boolean");
+    assert3(PublicKey.isPublicKey(localPeerId));
+    assert3(PublicKey.isPublicKey(remotePeerId));
+    assert3(typeof initiator === "boolean");
+    this.initiator = initiator;
+    this.localPeerId = localPeerId;
+    this.remotePeerId = remotePeerId;
+    this._control.onExtensionRegistered.set(async (name) => {
+      log2("remote extension", {
+        name
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/teleport.ts",
+        line: 61,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      assert3(!this._remoteExtensions.has(name), "Remote extension already exists");
+      this._remoteExtensions.add(name);
+      if (this._extensions.has(name)) {
+        try {
+          await this._openExtension(name);
+        } catch (err) {
+          await this.destroy(err);
+        }
+      }
+    });
+    {
+      this._muxer.stream.on("close", async () => {
+        await this.destroy();
+      });
+      this._muxer.stream.on("error", async (err) => {
+        await this.destroy(err);
+      });
+    }
+  }
+  get stream() {
+    return this._muxer.stream;
+  }
+  async open() {
+    this._setExtension("dxos.mesh.teleport.control", this._control);
+    await this._openExtension("dxos.mesh.teleport.control");
+    this._open = true;
+  }
+  async close(err) {
+    await this.destroy(err);
+  }
+  async destroy(err) {
+    if (this._ctx.disposed) {
+      return;
+    }
+    await this._ctx.dispose();
+    for (const extension of this._extensions.values()) {
+      try {
+        await extension.onClose(err);
+      } catch (err1) {
+        log2.catch(err1, {}, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/teleport.ts",
+          line: 117,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      }
+    }
+    this._muxer.destroy(err);
+  }
+  addExtension(name, extension) {
+    if (!this._open) {
+      throw new Error("Not open");
+    }
+    log2("addExtension", {
+      name
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/teleport.ts",
+      line: 129,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._setExtension(name, extension);
+    scheduleTask(this._ctx, async () => {
+      try {
+        await this._control.registerExtension(name);
+      } catch (err) {
+        if (err instanceof RpcClosedError) {
+          return;
+        }
+        throw err;
+      }
+    });
+    if (this._remoteExtensions.has(name)) {
+      scheduleTask(this._ctx, async () => {
+        await this._openExtension(name);
+      });
+    }
+  }
+  _setExtension(extensionName, extension) {
+    assert3(!extensionName.includes("/"), "Invalid extension name");
+    assert3(!this._extensions.has(extensionName), "Extension already exists");
+    this._extensions.set(extensionName, extension);
+  }
+  async _openExtension(extensionName) {
+    var _a;
+    log2("open extension", {
+      extensionName
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/teleport.ts",
+      line: 159,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const extension = (_a = this._extensions.get(extensionName)) != null ? _a : failUndefined2();
+    const context = {
+      initiator: this.initiator,
+      localPeerId: this.localPeerId,
+      remotePeerId: this.remotePeerId,
+      createPort: (channelName, opts) => {
+        assert3(!channelName.includes("/"), "Invalid channel name");
+        return this._muxer.createPort(`${extensionName}/${channelName}`, opts);
+      },
+      createStream: (channelName, opts) => {
+        assert3(!channelName.includes("/"), "Invalid channel name");
+        return this._muxer.createStream(`${extensionName}/${channelName}`, opts);
+      },
+      close: (err) => {
+        void runInContextAsync(this._ctx, async () => {
+          await this.close(err);
+        });
+      }
+    };
+    await extension.onOpen(context);
+    log2("extension opened", {
+      extensionName
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/teleport.ts",
+      line: 182,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+};
+__decorate([
+  synchronized
+], Teleport.prototype, "destroy", null);
+var ControlExtension = class {
+  constructor(opts) {
+    this.opts = opts;
+    this._ctx = new Context({
+      onError: (err) => {
+        this._extensionContext.close(err);
+      }
+    });
+    this.onExtensionRegistered = new Callback();
+    this.onTimeout = new Callback();
+  }
+  async onOpen(extensionContext) {
+    this._extensionContext = extensionContext;
+    this._rpc = createProtoRpcPeer({
+      requested: {
+        Control: schema2.getService("dxos.mesh.teleport.control.ControlService")
+      },
+      exposed: {
+        Control: schema2.getService("dxos.mesh.teleport.control.ControlService")
+      },
+      handlers: {
+        Control: {
+          registerExtension: async (request) => {
+            this.onExtensionRegistered.call(request.name);
+          },
+          heartbeat: async (request) => {
+          }
+        }
+      },
+      port: extensionContext.createPort("rpc", {
+        contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
+      })
+    });
+    await this._rpc.open();
+    scheduleTaskInterval(this._ctx, async () => {
+      try {
+        await asyncTimeout(this._rpc.rpc.Control.heartbeat(), this.opts.heartbeatTimeout);
+      } catch (err) {
+        this.onTimeout.call();
+      }
+    }, this.opts.heartbeatInterval);
+  }
+  async onClose(err) {
+    await this._ctx.dispose();
+    await this._rpc.close();
+  }
+  async registerExtension(name) {
+    await this._rpc.rpc.Control.registerExtension({
+      name
+    });
+  }
+};
+
+// packages/core/mesh/teleport/src/testing.ts
+var TestBuilder = class {
+  constructor() {
+    this._peers = new Array();
+  }
+  createPeer(peerId) {
+    const peer = new TestPeer(peerId);
+    this._peers.push(peer);
+    return peer;
+  }
+  async destroy() {
+    await Promise.all(this._peers.map((agent) => agent.destroy()));
+  }
+  async createPipedPeers({ peerId1, peerId2 } = {}) {
+    const peer1 = this.createPeer(peerId1);
+    const peer2 = this.createPeer(peerId2);
+    peer1.initializeTeleport({
+      initiator: true,
+      remotePeerId: peer2.peerId
+    });
+    peer2.initializeTeleport({
+      initiator: false,
+      remotePeerId: peer1.peerId
+    });
+    peer1.pipeline(peer2);
+    peer2.pipeline(peer1);
+    await Promise.all([
+      peer1.teleport.open(),
+      peer2.teleport.open()
+    ]);
+    return {
+      peer1,
+      peer2
+    };
+  }
+};
+var TestPeer = class {
+  constructor(peerId = PublicKey2.random()) {
+    this.peerId = peerId;
+  }
+  initializeTeleport({ initiator, remotePeerId }) {
+    if (this.teleport) {
+      return this;
+    }
+    this.teleport = new Teleport({
+      initiator,
+      localPeerId: this.peerId,
+      remotePeerId
+    });
+    return this;
+  }
+  pipeline(peer) {
+    if (!this.teleport || !peer.teleport) {
+      throw new Error("Teleport not initialized");
+    }
+    pipeline(this.teleport.stream, peer.teleport.stream, (err) => {
+      if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+        log3.catch(err, {}, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing.ts",
+          line: 67,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      }
+    });
+  }
+  async destroy() {
+    var _a;
+    await ((_a = this.teleport) == null ? void 0 : _a.destroy());
+  }
+};
+export {
+  TestBuilder,
+  TestPeer
+};
+//# sourceMappingURL=testing.mjs.map