@seriousme/opifex 2.2.0 → 2.4.0

package/deno/tcpServer.test.ts

@@ -2,8 +2,10 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import { TcpClient } from "./tcpClient.ts";
 import { TcpServer } from "./tcpServer.ts";
-import { delay, logger, LogLevel } from "../utils/mod.ts";
-import type { ProtocolLevel, PublishPacket, QoS } from "../mqttPacket/mod.ts";
+import { logger, LogLevel } from "../utils/mod.ts";
+import type { ProtocolLevel } from "../mqttPacket/mod.ts";
+import { testClient } from "../dev_utils/testClient.ts";
+import { MqttServer } from "../server/mod.ts";
 
 logger.level(LogLevel.info);
 
@@ -24,64 +26,10 @@ test("Deno: Test pubSub using client and server", async () => {
   };
 
   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: Test subscription persistence after reconnect", async () => {
@@ -99,51 +47,14 @@ test("Deno: Test subscription persistence after reconnect", async () => {
   };
 
   const client = new TcpClient();
-  const testTopic = "test/topic";
-  const received: PublishPacket[] = [];
-
-  // First connection and subscription
-  await client.connect(params);
-  await client.subscribe({
-    subscriptions: [{
-      topicFilter: testTopic,
-      qos: 0,
-    }],
-  });
-
-  // Start receiving messages
-  (async () => {
-    for await (const item of client.messages()) {
-      received.push(item);
-    }
-  })();
+  await testClient(client, params);
 
-  // Disconnect client
-  await client.disconnect();
-  await delay(100);
-
-  // Reconnect client
-  await client.connect(params);
-  await delay(100);
-
-  // Publish test message
-  await client.publish({
-    topic: testTopic,
-    qos: 0,
-    payload: new Uint8Array([0x01]),
-  });
-
-  await delay(100);
-  logger.verbose("Disconnect client");
-  await client.disconnect();
-
-  // Verify message was received
-  assert.equal(received.length, 1, "Should receive one message");
-  assert.equal(
-    received[0].topic,
-    testTopic,
-    "Should receive message on subscribed topic",
-  );
+  logger.verbose("Stop server");
+  await server.stop();
+});
 
-  server.stop();
+test("Deno: Passing a mqttServer works", () => {
+  const mqttServer = new MqttServer({});
+  const server = new TcpServer({ port: 0 }, mqttServer);
+  assert(server.mqttServer === mqttServer);
 });

package/deno/tcpServer.ts

@@ -5,24 +5,30 @@
  */
 
 import { MqttServer } from "../server/mod.ts";
+import { denoConnToNext } from "./denoConnToNext.ts";
 import type { MqttServerOptions } from "../server/mod.ts";
 
 /**
  * TCP server that wraps a MqttServer, see the /examples folder
  */
 export class TcpServer {
+  /** the MqttServer instance used by the server */
+  readonly mqttServer: MqttServer;
   private listener: Deno.Listener<Deno.Conn>;
-  private mqttServer: MqttServer;
 
   /**
    * Create a new TCP server
    */
   constructor(
     serverOptions: Deno.TcpListenOptions,
-    mqttOptions: MqttServerOptions,
+    mqttOptions: MqttServerOptions | MqttServer,
   ) {
     this.listener = Deno.listen(serverOptions);
-    this.mqttServer = new MqttServer(mqttOptions);
+    if (mqttOptions instanceof MqttServer) {
+      this.mqttServer = mqttOptions;
+    } else {
+      this.mqttServer = new MqttServer(mqttOptions);
+    }
   }
 
   /**
@@ -30,15 +36,17 @@ export class TcpServer {
    */
   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(true);
+  async stop(opts = { closeMqtt: true }): Promise<void> {
+    if (opts.closeMqtt) {
+      await this.mqttServer.close();
+    }
     this.listener.close();
   }
 

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

@@ -5,66 +5,116 @@
 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,
+  maxBufferSize: number | undefined,
+) {
+  const conn = await webSocketToNext(socket, remoteAddr, maxBufferSize);
+  mqttServer.serve(conn);
+  logger.debug("serving mqtt");
+}
+
+export function mqttOverWS(
+  mqttServer: MqttServer,
+  pathName: string,
+  next: RequestHandler,
+  opts?: {
+    maxBufferSize?: number | undefined;
+  },
+): 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, opts?.maxBufferSize);
+      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;
+  private maxBufferSize: number | undefined;
 
   /**
    * Create a new WebSocket server
    */
   constructor(
-    serverOptions: Deno.ServeOptions & { port: number; hostname?: string },
-    mqttOptions: MqttServerOptions,
+    serverOptions: Deno.ServeOptions & {
+      port: number;
+      hostname?: string;
+      pathName?: string;
+      maxBufferSize?: number;
+    },
+    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, maxBufferSize, ...listenOptions } = serverOptions;
+    this.listenOptions = listenOptions;
+    this.pathName = pathName ?? "/mqtt";
+    this.maxBufferSize = maxBufferSize;
+    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,
+      { maxBufferSize: this.maxBufferSize },
+    );
+    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/WebStreamEndpoint.ts

@@ -0,0 +1,5 @@
+export interface WebStreamEndpoint {
+  readable: ReadableStream<Uint8Array>;
+  writable: WritableStream<Uint8Array>;
+  close: () => void;
+}

package/dev_utils/asyncStreamEndpoint.ts

@@ -0,0 +1,5 @@
+export interface AsyncStreamEndpoint {
+  readable: AsyncIterable<Uint8Array>;
+  write: (chunk: Uint8Array) => Promise<void>;
+  close: () => void;
+}

package/dev_utils/asyncStreamPair.ts

@@ -0,0 +1,109 @@
+/**
+ *  Duplex AsyncStream
+ */
+
+import type { AsyncStreamEndpoint } from "./asyncStreamEndpoint.ts";
+/**
+ * Internal 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: AsyncStreamEndpoint;
+  output: AsyncStreamEndpoint;
+} {
+  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,
+    },
+  };
+}