@seriousme/opifex 2.1.0 → 2.3.0

package/deno/tlsServer.test.ts

@@ -3,8 +3,9 @@ import assert from "node:assert/strict";
 import { TcpClient } from "./tcpClient.ts";
 import { TlsServer } from "./tlsServer.ts";
 import { logger, LogLevel } from "../utils/mod.ts";
-import type { PublishPacket, QoS } from "../mqttPacket/mod.ts";
-import { delay, generateLocalhostCerts } from "../dev_utils/mod.ts";
+import { generateLocalhostCerts } from "../dev_utils/mod.ts";
+import { testClient } from "../dev_utils/testClient.ts";
+import { MqttServer } from "../server/mod.ts";
 
 logger.level(LogLevel.info);
 
@@ -36,62 +37,17 @@ test("Deno: Test pubSub using client and server", async () => {
   logger.verbose("client parameters: ", params);
 
   const client = new TcpClient();
-
-  await client.connect(params);
-  assert(true, "Client connected to server");
-
-  const publishSet: { topic: string; qos: QoS }[] = [
-    { topic: "t0@q0", qos: 0 },
-    { topic: "t1@q0", qos: 0 },
-    { topic: "t2@q0", qos: 0 },
-    { topic: "t0@q1", qos: 1 },
-    { topic: "t1@q1", qos: 1 },
-    { topic: "t2@q1", qos: 1 },
-    { topic: "t0@q2", qos: 2 },
-    { topic: "t1@q2", qos: 2 },
-    { topic: "t2@q2", qos: 2 },
-  ];
-
-  const subscriptions = publishSet.map((item) => ({
-    topicFilter: item.topic,
-    qos: item.qos,
-  }));
-  await client.subscribe({
-    subscriptions,
-  });
-
-  // the IIFE ensures message reception runs in parallel
-  logger.verbose("Start receiving");
-  const received: PublishPacket[] = [];
-  (async () => {
-    for await (const item of client.messages()) {
-      logger.verbose("Receiving:", item.topic, "--", item.qos);
-      received.push(item);
-    }
-  })();
-  // end of IIFE
-  for (const item of publishSet) {
-    logger.verbose("Publishing:", item.topic, "--", item.qos);
-    await client.publish({
-      topic: item.topic,
-      qos: item.qos,
-      payload: new Uint8Array([0x01]),
-    });
-  }
-
-  await delay(100);
-  logger.verbose("Disconnect client");
-  await client.disconnect();
-
-  logger.verbose("Check completeness");
-  for (const item of publishSet) {
-    const found = received.find((f) =>
-      f.topic == item.topic && f.qos === item.qos
-    );
-    logger.verbose("Found:", item.topic, "--", item.qos);
-    assert(found, `${item.topic} -- ${item.qos}`);
-  }
+  await testClient(client, params);
 
   logger.verbose("Stop server");
-  server.stop();
+  await server.stop();
+});
+
+test("Deno: Passing a mqttServer works", () => {
+  const mqttServer = new MqttServer({});
+  const server = new TlsServer(
+    { hostname: "localhost", port: 0, key, cert },
+    mqttServer,
+  );
+  assert(server.mqttServer === mqttServer);
 });

package/deno/tlsServer.ts

@@ -6,22 +6,28 @@
 
 import { MqttServer } from "../server/mod.ts";
 import type { MqttServerOptions } from "../server/mod.ts";
+import { denoConnToNext } from "./denoConnToNext.ts";
 
 /**
  * TLS server that wraps a MqttServer, see the /examples folder
  */
 export class TlsServer {
+  /** the MqttServer instance used by the server */
+  readonly mqttServer: MqttServer;
   private listener: Deno.TlsListener;
-  private mqttServer: MqttServer;
   /**
    * Create a new TLS server
    */
   constructor(
     serverOptions: Deno.ListenTlsOptions & Deno.TlsCertifiedKeyPem,
-    mqttOptions: MqttServerOptions,
+    mqttOptions: MqttServerOptions | MqttServer,
   ) {
     this.listener = Deno.listenTls(serverOptions);
-    this.mqttServer = new MqttServer(mqttOptions);
+    if (mqttOptions instanceof MqttServer) {
+      this.mqttServer = mqttOptions;
+    } else {
+      this.mqttServer = new MqttServer(mqttOptions);
+    }
   }
 
   /**
@@ -29,15 +35,17 @@ export class TlsServer {
    */
   async start(): Promise<void> {
     for await (const conn of this.listener) {
-      this.mqttServer.serve(conn);
+      this.mqttServer.serve(denoConnToNext(conn));
     }
   }
 
   /**
    * Stop listening
    */
-  stop(): void {
-    this.mqttServer.close();
+  async stop(opts = { closeMqtt: true }): Promise<void> {
+    if (opts.closeMqtt) {
+      await this.mqttServer.close();
+    }
     this.listener.close();
   }
   /**

package/deno/wsServer.test.ts

@@ -2,8 +2,9 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import { WsClient } from "../web/wsClient.ts";
 import { WsServer } from "./wsServer.ts";
-import { delay, logger, LogLevel } from "../utils/mod.ts";
-import type { PublishPacket, QoS } from "../mqttPacket/mod.ts";
+import { logger, LogLevel } from "../utils/mod.ts";
+import { testClient } from "../dev_utils/testClient.ts";
+import { MqttServer } from "../server/mod.ts";
 
 logger.level(LogLevel.info);
 
@@ -25,69 +26,22 @@ test("Deno: Test pubSub using client and server over webSockets", async () => {
   });
 
   const params = {
-    url: new URL(`ws://localhost:${server.port}`),
+    url: new URL(`ws://localhost:${server.port}/mqtt`),
     numberOfRetries: 0,
   };
 
-  logger.verbose("client parameters: ", params);
-
   const client = new WsClient();
-  client.onConnected = () => logger.verbose("Client connected to server");
-
-  await client.connect(params);
-
-  const publishSet: { topic: string; qos: QoS }[] = [
-    { topic: "t0@q0", qos: 0 },
-    { topic: "t1@q0", qos: 0 },
-    { topic: "t2@q0", qos: 0 },
-    { topic: "t0@q1", qos: 1 },
-    { topic: "t1@q1", qos: 1 },
-    { topic: "t2@q1", qos: 1 },
-    { topic: "t0@q2", qos: 2 },
-    { topic: "t1@q2", qos: 2 },
-    { topic: "t2@q2", qos: 2 },
-  ];
-
-  const subscriptions = publishSet.map((item) => ({
-    topicFilter: item.topic,
-    qos: item.qos,
-  }));
-  await client.subscribe({
-    subscriptions,
-  });
-
-  // the IIFE ensures message reception runs in parallel
-  logger.verbose("Start receiving");
-  const received: PublishPacket[] = [];
-  (async () => {
-    for await (const item of client.messages()) {
-      logger.verbose("Receiving:", item.topic, "--", item.qos);
-      received.push(item);
-    }
-  })();
-  // end of IIFE
-  for (const item of publishSet) {
-    logger.verbose("Publishing:", item.topic, "--", item.qos);
-    await client.publish({
-      topic: item.topic,
-      qos: item.qos,
-      payload: new Uint8Array([0x01]),
-    });
-  }
-
-  await delay(100);
-  logger.verbose("Disconnect client");
-  await client.disconnect();
-
-  logger.verbose("Check completeness");
-  for (const item of publishSet) {
-    const found = received.find((f) =>
-      f.topic == item.topic && f.qos === item.qos
-    );
-    logger.verbose("Found:", item.topic, "--", item.qos);
-    assert(found, `${item.topic} -- ${item.qos}`);
-  }
+  await testClient(client, params);
 
   logger.verbose("Stop server");
-  server.stop();
+  await server.stop();
+});
+
+test("Deno: Passing a mqttServer works", () => {
+  const mqttServer = new MqttServer({});
+  const server = new WsServer(
+    { hostname: "localhost", port: 0 },
+    mqttServer,
+  );
+  assert(server.mqttServer === mqttServer);
 });

package/deno/wsServer.ts

@@ -1,70 +1,112 @@
-/*
- * this a Deno specific implementation of a WebSocket server
- *  @module
+/**
+ * This a Deno specific implementation of a WebSocket server
+ * @module
  */
 import { MqttServer } from "../server/mod.ts";
 import type { MqttServerOptions } from "../server/mod.ts";
 import { logger } from "../utils/logger.ts";
-import { wrapWebSocket } from "../web/wrapWebSocket.ts";
-import type { HostnamePort } from "../web/wrapWebSocket.ts";
+import { webSocketToNext } from "../web/webSocketToNext.ts";
+import type { NetAddr } from "../connNext/connNext.ts";
+
+/** for those who want wrap their own websockets */
+export { webSocketToNext };
+export type RequestHandler = (
+  req: Request,
+  info: Deno.ServeHandlerInfo<NetAddr>,
+) => Response | Promise<Response>;
+
+export const pageNotFound: RequestHandler = (_req, _info) => {
+  return new Response("Page not found", { status: 404 });
+};
+
+async function handleWsClient(
+  socket: WebSocket,
+  mqttServer: MqttServer,
+  remoteAddr: NetAddr,
+) {
+  const conn = await webSocketToNext(socket, remoteAddr);
+  mqttServer.serve(conn);
+  logger.debug("serving mqtt");
+}
+
+export function mqttOverWS(
+  mqttServer: MqttServer,
+  pathName: string,
+  next: RequestHandler,
+): RequestHandler {
+  const wsRequestHandler: RequestHandler = (req, info) => {
+    const url = new URL(req.url);
+    if (url.pathname === pathName) {
+      if (req.headers.get("upgrade") !== "websocket") {
+        return new Response("Expected WebSocket connection.", { status: 426 });
+      }
+      logger.debug("starting upgrade to websocket");
+      const remoteAddr = info.remoteAddr;
+      const { socket, response } = Deno.upgradeWebSocket(req);
+      logger.debug("upgraded to websocket");
+      // do not await on purpose
+      handleWsClient(socket, mqttServer, remoteAddr);
+      return response;
+    }
+    return next(req, info);
+  };
+  return wsRequestHandler;
+}
 
 /**
  * WebSocket server that wraps a MqttServer, see the /examples folder
  */
 export class WsServer {
+  /** the MqttServer instance used by the server */
+  readonly mqttServer: MqttServer;
   private server?: Deno.HttpServer;
-  private mqttServer: MqttServer;
   private listenOptions: Deno.ServeOptions & {
     port: number;
     hostname?: string;
   };
+  private pathName: string;
 
   /**
    * Create a new WebSocket server
    */
   constructor(
-    serverOptions: Deno.ServeOptions & { port: number; hostname?: string },
-    mqttOptions: MqttServerOptions,
+    serverOptions: Deno.ServeOptions & {
+      port: number;
+      hostname?: string;
+      pathName?: string;
+    },
+    mqttOptions: MqttServerOptions | MqttServer,
   ) {
-    this.listenOptions = serverOptions;
-    this.mqttServer = new MqttServer(mqttOptions);
-  }
-
-  private async handleWsClient(socket: WebSocket, remoteAddr: HostnamePort) {
-    const conn = await wrapWebSocket(socket, remoteAddr);
-    logger.debug("created conn");
-    this.mqttServer.serve(conn);
-    logger.debug("serving mqtt");
+    const { pathName, ...listenOptions } = serverOptions;
+    this.listenOptions = listenOptions;
+    this.pathName = pathName ?? "/mqtt";
+    if (mqttOptions instanceof MqttServer) {
+      this.mqttServer = mqttOptions;
+    } else {
+      this.mqttServer = new MqttServer(mqttOptions);
+    }
   }
 
   /**
    * Start listening
    */
   async start(): Promise<void> {
-    this.server = Deno.serve(this.listenOptions, (req, info) => {
-      const { hostname, port } = info.remoteAddr;
-      logger.debug(
-        `Server received http connection from ${hostname}:${port}`,
-      );
-
-      if (req.headers.get("upgrade") !== "websocket") {
-        return new Response("Expected WebSocket connection.", { status: 426 });
-      }
-      logger.debug("starting upgrade to websocket");
-      const { socket, response } = Deno.upgradeWebSocket(req);
-      logger.debug("upgraded to websocket");
-      this.handleWsClient(socket, { hostname, port });
-      return response;
-    });
-
+    const requestHandler = mqttOverWS(
+      this.mqttServer,
+      this.pathName,
+      pageNotFound,
+    );
+    this.server = Deno.serve(this.listenOptions, requestHandler);
     await this.server.finished;
   }
 
   /**
    * Stop listening
    */
-  stop(): void {
-    this.mqttServer.close(true);
+  async stop(opts = { closeMqtt: true }): Promise<void> {
+    if (opts.closeMqtt) {
+      await this.mqttServer.close();
+    }
     if (this.server) {
       this.server.shutdown();
     }

package/dev_utils/asyncStreamPair.ts

@@ -0,0 +1,114 @@
+/**
+ *  Duplex AsyncStream
+ */
+
+export interface AsyncStreamPairEndpoint {
+  readable: AsyncIterable<Uint8Array>;
+  write: (chunk: Uint8Array) => Promise<void>;
+  close: () => void;
+}
+
+/**
+ * Interne push/pull queue to support AsyncIterable iteration.
+ */
+class AsyncQueue<T> implements AsyncIterable<T> {
+  private queue: T[] = [];
+  private resolvers: Array<(value: IteratorResult<T>) => void> = [];
+  private closed = false;
+  private error: unknown = null;
+
+  push(value: T): void {
+    if (this.closed) return;
+
+    if (this.resolvers.length > 0) {
+      const resolve = this.resolvers.shift()!;
+      resolve({ value, done: false });
+    } else {
+      this.queue.push(value);
+    }
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+
+    while (this.resolvers.length > 0) {
+      const resolve = this.resolvers.shift()!;
+      if (this.error) {
+        resolve(Promise.reject(this.error) as unknown as IteratorResult<T>);
+      } else {
+        resolve({ value: undefined, done: true });
+      }
+    }
+  }
+
+  abort(reason: unknown): void {
+    this.error = reason;
+    this.close();
+  }
+
+  async *[Symbol.asyncIterator](): AsyncIterator<T> {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift()!;
+      } else if (this.closed) {
+        if (this.error) {
+          throw this.error;
+        }
+        return;
+      } else {
+        const nextResult = await new Promise<IteratorResult<T>>((resolve) => {
+          this.resolvers.push(resolve);
+        });
+
+        if (nextResult.done) {
+          if (this.error) {
+            throw this.error;
+          }
+          return;
+        }
+
+        yield nextResult.value;
+      }
+    }
+  }
+}
+
+export function createAsyncStreamPair(): {
+  input: AsyncStreamPairEndpoint;
+  output: AsyncStreamPairEndpoint;
+} {
+  const queueA = new AsyncQueue<Uint8Array>();
+  const queueB = new AsyncQueue<Uint8Array>();
+
+  let closed = false;
+
+  const closeBoth = () => {
+    if (!closed) {
+      closed = true;
+      queueA.close();
+      queueB.close();
+    }
+  };
+
+  return {
+    input: {
+      readable: queueA,
+      write: (chunk: Uint8Array): Promise<void> => {
+        if (closed) throw new Error("Stream is closed");
+        queueB.push(chunk);
+        return Promise.resolve();
+      },
+      close: closeBoth,
+    },
+    output: {
+      readable: queueB,
+      write: (chunk: Uint8Array): Promise<void> => {
+        if (closed) throw new Error("Stream is closed");
+        queueA.push(chunk);
+        return Promise.resolve();
+      },
+      close: closeBoth,
+    },
+  };
+}

package/dev_utils/asyncStreamToNext.ts

@@ -0,0 +1,171 @@
+import type { ConnAddr, ConnNext } from "../connNext/connNext.ts";
+import { createAsyncStreamPair } from "./asyncStreamPair.ts";
+import type { AsyncStreamPairEndpoint } from "./asyncStreamPair.ts";
+
+/** wrapper class */
+export class AsyncStreamConnNextWrapper {
+  closed: boolean;
+  private endPoint: AsyncStreamPairEndpoint;
+  private leftover: Uint8Array = new Uint8Array(0);
+  private reader: AsyncIterator<Uint8Array>;
+
+  /** Create a new Endpoint*/
+  constructor(endPoint: AsyncStreamPairEndpoint) {
+    this.endPoint = endPoint;
+    this.closed = false;
+    this.reader = endPoint.readable[Symbol.asyncIterator]();
+  }
+
+  /**
+   * Writes data chunk to the underlying AsyncStream
+   */ async write(chunk: Uint8Array): Promise<void> {
+    if (this.closed) {
+      return Promise.reject(new Error("Pipe closed"));
+    }
+    try {
+      await this.endPoint.write(chunk);
+      return;
+    } catch (err) {
+      this.closed = true;
+      throw err;
+    }
+  }
+
+  /**
+   * Reads data from the stream.
+   * If `length` is provided, waits until exact number of bytes are buffered.
+   */
+  async read(length?: number): Promise<Uint8Array | null> {
+    if (this.closed || (length !== undefined && length < 0)) {
+      return null;
+    }
+
+    if (length === 0) {
+      return new Uint8Array(0);
+    }
+
+    // Helper to fetch the next chunk from the underlying iterable
+    const fetchNextChunk = async (): Promise<Uint8Array | null> => {
+      const { value, done } = await this.reader.next();
+      if (done) {
+        this.closed = true;
+        return null;
+      }
+      return value;
+    };
+
+    // Unbounded read (length === undefined)
+    if (length === undefined) {
+      if (this.leftover.length > 0) {
+        const result = this.leftover;
+        this.leftover = new Uint8Array(0);
+        return result;
+      }
+      return await fetchNextChunk();
+    }
+
+    // Exact length read
+    const bytesRequested = length;
+    const result = new Uint8Array(bytesRequested);
+    let bytesAccumulated = 0;
+
+    // Use leftover data first if available
+    if (this.leftover.length > 0) {
+      const take = Math.min(this.leftover.length, bytesRequested);
+      result.set(this.leftover.subarray(0, take), bytesAccumulated);
+      bytesAccumulated += take;
+      this.leftover = this.leftover.subarray(take);
+    }
+
+    // Read remaining required bytes
+    while (bytesAccumulated < bytesRequested) {
+      const value = await fetchNextChunk();
+
+      if (value === null) {
+        // Stream ended before collecting required bytes
+        if (bytesAccumulated === 0) return null;
+        return result.subarray(0, bytesAccumulated);
+      }
+
+      const needed = bytesRequested - bytesAccumulated;
+
+      if (value.length <= needed) {
+        result.set(value, bytesAccumulated);
+        bytesAccumulated += value.length;
+      } else {
+        result.set(value.subarray(0, needed), bytesAccumulated);
+        bytesAccumulated += needed;
+        this.leftover = value.subarray(needed);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Closes the reader, writer, and underlying AsyncStream pair endpoint.
+   */
+  close(): void {
+    if (!this.closed) {
+      this.closed = true;
+      try {
+        this.endPoint.close();
+      } catch (_err) { /* swallow */ }
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      const chunk = await this.read();
+      if (chunk === null) {
+        break;
+      }
+      yield chunk;
+    }
+  }
+}
+
+/**
+ * Creates a pair of cross-connected ConnNext sockets backed by AsyncStreams.
+ * Offers the exact same API as `createConnNextPair`.
+ */
+export function createConnNextPair(): {
+  input: ConnNext;
+  output: ConnNext;
+} {
+  const { input: asyncInput, output: asyncOutput } = createAsyncStreamPair();
+
+  const mockAddr: ConnAddr = {
+    transport: "tcp",
+    hostname: "127.0.0.1",
+    port: 1883,
+  };
+
+  const inputWrapper = new AsyncStreamConnNextWrapper(asyncInput);
+  const outputWrapper = new AsyncStreamConnNextWrapper(asyncOutput);
+
+  const input: ConnNext = {
+    remoteAddr: mockAddr,
+    localAddr: mockAddr,
+    read: (length) => inputWrapper.read(length),
+    write: (data) => inputWrapper.write(data),
+    [Symbol.asyncIterator]: () => inputWrapper[Symbol.asyncIterator](),
+    close: () => {
+      inputWrapper.close();
+      outputWrapper.close();
+    },
+  };
+
+  const output: ConnNext = {
+    remoteAddr: mockAddr,
+    localAddr: mockAddr,
+    read: (length) => outputWrapper.read(length),
+    write: (data) => outputWrapper.write(data),
+    [Symbol.asyncIterator]: () => outputWrapper[Symbol.asyncIterator](),
+    close: () => {
+      outputWrapper.close();
+      inputWrapper.close();
+    },
+  };
+
+  return { input, output };
+}