@dxos/teleport 0.1.14

package/dist/lib/node/testing.cjs

@@ -0,0 +1,653 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/core/mesh/teleport/src/testing.ts
+var testing_exports = {};
+__export(testing_exports, {
+  TestBuilder: () => TestBuilder,
+  TestPeer: () => TestPeer
+});
+module.exports = __toCommonJS(testing_exports);
+var import_node_stream3 = require("node:stream");
+var import_keys2 = require("@dxos/keys");
+var import_log3 = require("@dxos/log");
+
+// packages/core/mesh/teleport/src/teleport.ts
+var import_node_assert3 = __toESM(require("node:assert"));
+var import_async2 = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_debug2 = require("@dxos/debug");
+var import_keys = require("@dxos/keys");
+var import_log2 = require("@dxos/log");
+var import_protocols2 = require("@dxos/protocols");
+var import_rpc = require("@dxos/rpc");
+var import_util = require("@dxos/util");
+
+// packages/core/mesh/teleport/src/muxing/framer.ts
+var import_node_assert = __toESM(require("node:assert"));
+var import_node_stream = require("node:stream");
+var varint = __toESM(require("varint"));
+var Framer = class {
+  constructor() {
+    this._stream = new import_node_stream.Duplex({
+      objectMode: false,
+      read: () => {
+      },
+      write: (chunk, encoding, callback) => {
+        (0, import_node_assert.default)(!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;
+        (0, import_node_assert.default)(!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
+var import_node_assert2 = __toESM(require("node:assert"));
+var import_node_stream2 = require("node:stream");
+var import_async = require("@dxos/async");
+var import_debug = require("@dxos/debug");
+var import_log = require("@dxos/log");
+var import_protocols = require("@dxos/protocols");
+var codec = import_protocols.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 import_async.Event();
+    this._framer.port.subscribe((msg) => {
+      this._handleCommand(codec.decode(msg));
+    });
+  }
+  createStream(tag, opts = {}) {
+    const channel = this._getOrCreateStream({
+      tag,
+      contentType: opts.contentType
+    });
+    (0, import_node_assert2.default)(!channel.push, `Channel already open: ${tag}`);
+    const stream = new import_node_stream2.Duplex({
+      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
+    });
+    (0, import_node_assert2.default)(!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) => {
+        (0, import_node_assert2.default)(!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;
+    (0, import_log.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) {
+      import_log.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 : (0, import_debug.failUndefined)();
+      if (!stream.push) {
+        import_log.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 import_context.Context({
+      onError: (err) => {
+        void this.destroy(err).catch(() => {
+          import_log2.log.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;
+    (0, import_node_assert3.default)(typeof initiator === "boolean");
+    (0, import_node_assert3.default)(import_keys.PublicKey.isPublicKey(localPeerId));
+    (0, import_node_assert3.default)(import_keys.PublicKey.isPublicKey(remotePeerId));
+    (0, import_node_assert3.default)(typeof initiator === "boolean");
+    this.initiator = initiator;
+    this.localPeerId = localPeerId;
+    this.remotePeerId = remotePeerId;
+    this._control.onExtensionRegistered.set(async (name) => {
+      (0, import_log2.log)("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)
+      });
+      (0, import_node_assert3.default)(!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) {
+        import_log2.log.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");
+    }
+    (0, import_log2.log)("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);
+    (0, import_async2.scheduleTask)(this._ctx, async () => {
+      try {
+        await this._control.registerExtension(name);
+      } catch (err) {
+        if (err instanceof import_rpc.RpcClosedError) {
+          return;
+        }
+        throw err;
+      }
+    });
+    if (this._remoteExtensions.has(name)) {
+      (0, import_async2.scheduleTask)(this._ctx, async () => {
+        await this._openExtension(name);
+      });
+    }
+  }
+  _setExtension(extensionName, extension) {
+    (0, import_node_assert3.default)(!extensionName.includes("/"), "Invalid extension name");
+    (0, import_node_assert3.default)(!this._extensions.has(extensionName), "Extension already exists");
+    this._extensions.set(extensionName, extension);
+  }
+  async _openExtension(extensionName) {
+    var _a;
+    (0, import_log2.log)("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 : (0, import_debug2.failUndefined)();
+    const context = {
+      initiator: this.initiator,
+      localPeerId: this.localPeerId,
+      remotePeerId: this.remotePeerId,
+      createPort: (channelName, opts) => {
+        (0, import_node_assert3.default)(!channelName.includes("/"), "Invalid channel name");
+        return this._muxer.createPort(`${extensionName}/${channelName}`, opts);
+      },
+      createStream: (channelName, opts) => {
+        (0, import_node_assert3.default)(!channelName.includes("/"), "Invalid channel name");
+        return this._muxer.createStream(`${extensionName}/${channelName}`, opts);
+      },
+      close: (err) => {
+        void (0, import_async2.runInContextAsync)(this._ctx, async () => {
+          await this.close(err);
+        });
+      }
+    };
+    await extension.onOpen(context);
+    (0, import_log2.log)("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([
+  import_async2.synchronized
+], Teleport.prototype, "destroy", null);
+var ControlExtension = class {
+  constructor(opts) {
+    this.opts = opts;
+    this._ctx = new import_context.Context({
+      onError: (err) => {
+        this._extensionContext.close(err);
+      }
+    });
+    this.onExtensionRegistered = new import_util.Callback();
+    this.onTimeout = new import_util.Callback();
+  }
+  async onOpen(extensionContext) {
+    this._extensionContext = extensionContext;
+    this._rpc = (0, import_rpc.createProtoRpcPeer)({
+      requested: {
+        Control: import_protocols2.schema.getService("dxos.mesh.teleport.control.ControlService")
+      },
+      exposed: {
+        Control: import_protocols2.schema.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();
+    (0, import_async2.scheduleTaskInterval)(this._ctx, async () => {
+      try {
+        await (0, import_async2.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 = import_keys2.PublicKey.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");
+    }
+    (0, import_node_stream3.pipeline)(this.teleport.stream, peer.teleport.stream, (err) => {
+      if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+        import_log3.log.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());
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestBuilder,
+  TestPeer
+});
+//# sourceMappingURL=testing.cjs.map