@seriousme/opifex 1.11.3 → 2.1.0

package/deno/tlsServer.test.ts

@@ -0,0 +1,97 @@
+import { test } from "node:test";
+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";
+
+logger.level(LogLevel.info);
+
+const { key, cert, caCert } = generateLocalhostCerts();
+
+test("Deno: Test pubSub using client and server", async () => {
+  const server = new TlsServer(
+    { hostname: "localhost", port: 0, key, cert },
+    {},
+  );
+  server.start();
+
+  assert.deepStrictEqual(
+    server.port !== undefined,
+    true,
+    "server runs a a random port",
+  );
+  logger.verbose("server running on: ", {
+    port: server.port,
+    address: server.address,
+  });
+
+  const params = {
+    url: new URL(`mqtts://localhost:${server.port}`),
+    numberOfRetries: 0,
+    caCerts: [caCert],
+  };
+
+  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}`);
+  }
+
+  logger.verbose("Stop server");
+  server.stop();
+});

package/deno/tlsServer.ts

@@ -0,0 +1,58 @@
+/**
+ * This module provides a Deno specific implementation of a TCP socket listener
+ * it uses the platform agnostic MqttServer class
+ *  @module
+ */
+
+import { MqttServer } from "../server/mod.ts";
+import type { MqttServerOptions } from "../server/mod.ts";
+
+/**
+ * TLS server that wraps a MqttServer, see the /examples folder
+ */
+export class TlsServer {
+  private listener: Deno.TlsListener;
+  private mqttServer: MqttServer;
+  /**
+   * Create a new TLS server
+   */
+  constructor(
+    serverOptions: Deno.ListenTlsOptions & Deno.TlsCertifiedKeyPem,
+    mqttOptions: MqttServerOptions,
+  ) {
+    this.listener = Deno.listenTls(serverOptions);
+    this.mqttServer = new MqttServer(mqttOptions);
+  }
+
+  /**
+   * Start listening
+   */
+  async start(): Promise<void> {
+    for await (const conn of this.listener) {
+      this.mqttServer.serve(conn);
+    }
+  }
+
+  /**
+   * Stop listening
+   */
+  stop(): void {
+    this.mqttServer.close();
+    this.listener.close();
+  }
+  /**
+   * The port number the server is listening on
+   */
+  // deno-coverage-ignore-start
+  get port(): number | undefined {
+    return this.listener.addr.port;
+  }
+
+  /**
+   * The address the server is listening on
+   */
+  get address(): string | undefined {
+    return this.listener.addr.hostname;
+  }
+  // deno-coverage-ignore-stop
+}

package/deno/wsServer.test.ts

@@ -0,0 +1,93 @@
+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";
+
+logger.level(LogLevel.info);
+
+test("Deno: Test pubSub using client and server over webSockets", async () => {
+  const server = new WsServer(
+    { hostname: "localhost", port: 0 },
+    {},
+  );
+  server.start();
+
+  assert.deepStrictEqual(
+    server.port !== undefined,
+    true,
+    "Http server runs a a random port",
+  );
+  logger.verbose("server running on: ", {
+    port: server.port,
+    address: server.address,
+  });
+
+  const params = {
+    url: new URL(`ws://localhost:${server.port}`),
+    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}`);
+  }
+
+  logger.verbose("Stop server");
+  server.stop();
+});

package/deno/wsServer.ts

@@ -0,0 +1,96 @@
+/*
+ * 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";
+
+/**
+ * WebSocket server that wraps a MqttServer, see the /examples folder
+ */
+export class WsServer {
+  private server?: Deno.HttpServer;
+  private mqttServer: MqttServer;
+  private listenOptions: Deno.ServeOptions & {
+    port: number;
+    hostname?: string;
+  };
+
+  /**
+   * Create a new WebSocket server
+   */
+  constructor(
+    serverOptions: Deno.ServeOptions & { port: number; hostname?: string },
+    mqttOptions: MqttServerOptions,
+  ) {
+    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");
+  }
+
+  /**
+   * 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;
+    });
+
+    await this.server.finished;
+  }
+
+  /**
+   * Stop listening
+   */
+  stop(): void {
+    this.mqttServer.close(true);
+    if (this.server) {
+      this.server.shutdown();
+    }
+  }
+
+  /**
+   * The port number the server is listening on
+   */
+  get port(): number | undefined {
+    // deno-coverage-ignore-start
+    if (this.server?.addr.transport === "tcp") {
+      return this.server.addr.port;
+    }
+    return undefined;
+    // deno-coverage-ignore-stop
+  }
+
+  /**
+   * The address the server is listening on
+   */
+  get address(): string | undefined {
+    // deno-coverage-ignore-start
+    if (this.server?.addr.transport === "tcp") {
+      return this.server.addr.hostname;
+    }
+    return undefined;
+    // deno-coverage-ignore-stop
+  }
+}

package/dev_utils/generateCert.ts

@@ -0,0 +1,95 @@
+import forge from "node-forge";
+
+/**
+ * Generates a minimal, in-memory TLS certificate bundle for localhost development.
+ * Includes Root CA, Server Certificate, and Server Private Key with SAN support (IPv4 & IPv6).
+ */
+export function generateLocalhostCerts(): {
+  caCert: string;
+  key: string;
+  cert: string;
+  fullChain: string;
+} {
+  // Generate the keypairs
+  // 2048-bit RSA is used here for fast generation during local development/testing
+  const caKeys = forge.pki.rsa.generateKeyPair(2048);
+  const serverKeys = forge.pki.rsa.generateKeyPair(2048);
+
+  // Create root CA
+  const caCert = forge.pki.createCertificate();
+  caCert.publicKey = caKeys.publicKey;
+  caCert.serialNumber = "01";
+  caCert.validity.notBefore = new Date();
+  caCert.validity.notAfter = new Date();
+  caCert.validity.notAfter.setFullYear(
+    caCert.validity.notBefore.getFullYear() + 1,
+  ); // Valid for 1 year
+
+  // Hardcoded CA Attributes
+  const caAttrs = [{ name: "commonName", value: "Local Dev Root CA" }];
+  caCert.setSubject(caAttrs);
+  caCert.setIssuer(caAttrs); // Self-signed: issuer equals subject
+
+  // Critical for CA: Define basic constraints to flag this certificate as a trusted issuer
+  caCert.setExtensions([
+    { name: "basicConstraints", cA: true, critical: true },
+    {
+      name: "keyUsage",
+      keyCertSign: true,
+      digitalSignature: true,
+      critical: true,
+    },
+  ]);
+
+  // Sign the CA certificate using its own private key
+  caCert.sign(caKeys.privateKey, forge.md.sha256.create());
+
+  // Create server certificate for localhost, valid for a year
+  const serverCert = forge.pki.createCertificate();
+  serverCert.publicKey = serverKeys.publicKey;
+  serverCert.serialNumber = "02"; // Unique serial number within this CA scope
+  serverCert.validity.notBefore = new Date();
+  serverCert.validity.notAfter = new Date();
+  serverCert.validity.notAfter.setFullYear(
+    serverCert.validity.notBefore.getFullYear() + 1,
+  );
+
+  // Hardcoded Server Attributes
+  serverCert.setSubject([{ name: "commonName", value: "localhost" }]);
+  serverCert.setIssuer(caCert.subject.attributes); // Issued by our custom Root CA
+
+  // Critical for Modern TLS: X509v3 Extensions containing Subject Alternative Names (SAN)
+  // Ensures compatibility with strict TLS parsers (like Deno/rustls, Go, Node.js, and modern browsers)
+  serverCert.setExtensions([
+    { name: "basicConstraints", cA: false, critical: true },
+    {
+      name: "keyUsage",
+      digitalSignature: true,
+      keyEncipherment: true,
+      critical: true,
+    },
+    {
+      name: "subjectAltName",
+      altNames: [
+        { type: 2, value: "localhost" }, // type 2 = DNS
+        { type: 7, ip: "127.0.0.1" }, // type 7 = IPv4 loopback
+        { type: 7, ip: "::1" }, // type 7 = IPv6 loopback
+      ],
+    },
+  ]);
+
+  // Sign the server certificate using the Root CA's private key
+  serverCert.sign(caKeys.privateKey, forge.md.sha256.create());
+
+  // convert data to PEM
+  const caCertPem = forge.pki.certificateToPem(caCert);
+  const serverCertPem = forge.pki.certificateToPem(serverCert);
+  const serverKeyPem = forge.pki.privateKeyToPem(serverKeys.privateKey);
+
+  return {
+    caCert: caCertPem,
+    key: serverKeyPem,
+    cert: serverCertPem,
+    fullChain: `${serverCertPem}\n${caCertPem}`, // Full certificate chain (Server + CA)
+  };
+}

package/dev_utils/mockConn.ts

@@ -0,0 +1,36 @@
+class Uint8Writer implements WritableStreamDefaultWriter {
+  private buff: Uint8Array;
+  private pos: number;
+  closed = Promise.resolve(undefined);
+  close = () => Promise.resolve();
+  abort = () => Promise.resolve();
+  ready = Promise.resolve(undefined);
+  releaseLock = () => {};
+  desiredSize = 20;
+
+  constructor(
+    buff: Uint8Array,
+  ) {
+    this.buff = buff;
+    this.pos = 0;
+  }
+  write(chunk: Uint8Array): Promise<void> {
+    this.buff.set(chunk, this.pos);
+    this.pos += chunk.length;
+    return Promise.resolve();
+  }
+}
+
+export function createMockSockConn(
+  readerBuffs: Uint8Array[],
+  writerBuf: Uint8Array,
+  close = () => {},
+) {
+  const readable = ReadableStream.from(readerBuffs);
+  const writable = new WritableStream(new Uint8Writer(writerBuf));
+  return {
+    readable,
+    writable,
+    close,
+  };
+}

package/dev_utils/mockServer.ts

@@ -0,0 +1,28 @@
+import { createWebStreamPair } from "./webStreamPair.ts";
+import { MqttConn } from "../mqttConn/mqttConn.ts";
+import { Context, MqttServer } from "../server/mod.ts";
+import { handlers } from "./test-handlers.ts";
+import type { MqttServerOptions } from "../server/mod.ts";
+
+export function startMockServer(opts: MqttServerOptions = {}): {
+  mqttConn: MqttConn;
+  mqttServer: MqttServer;
+} {
+  const serverOpts = { handlers, ...opts };
+  // start with a fresh clientlist
+  Context.clientList.clear();
+  // create a new MQTT server
+
+  const mqttServer = new MqttServer(serverOpts);
+  const { input, output } = createWebStreamPair();
+  const mqttConn = new MqttConn({ conn: output });
+  mqttServer.serve(input);
+  return { mqttConn, mqttServer };
+}
+
+export function addMockClient(mqttServer: MqttServer): MqttConn {
+  const { input, output } = createWebStreamPair();
+  const mqttConn = new MqttConn({ conn: output });
+  mqttServer.serve(input);
+  return mqttConn;
+}

package/dev_utils/mod.ts

@@ -1,3 +1,30 @@
-export { makeDummyQueueSockConn, makeDummySockConn } from "./dummyConn.ts";
-export { createWebSocketPair } from "./socketPair.ts";
-export { resolveAsap, resolveNextTick, runAsap } from "./timers.ts";
+export { createMockSockConn } from "./mockConn.ts";
+export { createWebStreamPair } from "./webStreamPair.ts";
+export {
+  delay,
+  resolveAsap,
+  resolveNextTick,
+  runAsap,
+  withTimeout,
+} from "./timers.ts";
+export { addMockClient, startMockServer } from "./mockServer.ts";
+export {
+  auth,
+  checkNoPacket,
+  connect,
+  connect5,
+  disconnect,
+  disconnect5,
+  nextPacketWithTimeOut,
+  ping,
+  publish,
+  publish5,
+  receiveMessages,
+  receiveMessages5,
+  subscribe,
+  subscribe5,
+  unsubscribe,
+  unsubscribe5,
+} from "./packetHelpers.ts";
+export { generateLocalhostCerts } from "./generateCert.ts";
+export { handlers, isAuthenticatedBroker } from "./test-handlers.ts";