@seriousme/opifex 1.1.0

package/client/store/memoryStore.ts

@@ -0,0 +1,56 @@
+import { assert, type PacketId } from "./deps.ts";
+
+import {
+  type IStore,
+  maxPacketId,
+  type PacketStore,
+  type PendingAckOutgoing,
+  type pendingIncoming,
+  type PendingOutgoing,
+  type PendingOutgoingPackets,
+} from "./store.ts";
+
+export class MemoryStore implements IStore {
+  private packetId: PacketId;
+
+  pendingIncoming: PacketStore<pendingIncoming>;
+  pendingOutgoing: PacketStore<PendingOutgoing>;
+  pendingAckOutgoing: PacketStore<PendingAckOutgoing>;
+
+  constructor() {
+    this.packetId = 0;
+    this.pendingIncoming = new Map();
+    this.pendingOutgoing = new Map();
+    this.pendingAckOutgoing = new Map();
+  }
+
+  nextId(): PacketId {
+    const currentId = this.packetId;
+    do {
+      this.packetId++;
+      if (this.packetId > maxPacketId) {
+        this.packetId = 1;
+      }
+    } while (
+      (this.pendingIncoming.has(this.packetId) ||
+        this.pendingOutgoing.has(this.packetId) ||
+        this.pendingAckOutgoing.has(this.packetId)) &&
+      this.packetId !== currentId
+    );
+    assert(this.packetId !== currentId, "No unused packetId available");
+    return this.packetId;
+  }
+
+  async *pendingOutgoingPackets(): AsyncGenerator<
+    PendingOutgoingPackets,
+    void,
+    unknown
+  > {
+    for (const [_id, packet] of this.pendingAckOutgoing) {
+      yield packet;
+    }
+    for (const [_id, packet] of this.pendingOutgoing) {
+      yield packet;
+    }
+  }
+}

package/client/store/store.ts

@@ -0,0 +1,29 @@
+import type {
+  PacketId,
+  PublishPacket,
+  PubrelPacket,
+  SubscribePacket,
+  UnsubscribePacket,
+} from "./deps.ts";
+export const maxPacketId = 0xffff;
+
+export type PacketStore<T> = Map<PacketId, T>;
+
+export type pendingIncoming = PublishPacket;
+export type PendingOutgoing =
+  | PublishPacket
+  | SubscribePacket
+  | UnsubscribePacket;
+export type PendingAckOutgoing = PubrelPacket;
+export type PendingOutgoingPackets = PendingAckOutgoing | PendingOutgoing;
+
+export interface IStore {
+  pendingIncoming: PacketStore<pendingIncoming>;
+  pendingOutgoing: PacketStore<PendingOutgoing>;
+  pendingAckOutgoing: PacketStore<PendingAckOutgoing>;
+  pendingOutgoingPackets(): AsyncGenerator<
+    PendingOutgoing | PubrelPacket,
+    void,
+    unknown
+  >;
+}

package/deno/README.md

@@ -0,0 +1,64 @@
+# Running Opifex server/client on Deno
+
+These instructions specifify how to run [Opifex](README.md) on Deno. To run
+Opifex on NodeJS see the [instructions](../node/README.md)
+
+## Playing around
+
+Make sure you have [Deno](https://deno.land) installed.
+
+### Server
+
+```bash
+deno run https://deno.land/x/opifex/bin/demoServer.ts
+```
+
+On the first invocation Deno will download all dependencies. It will then pop
+the question:
+
+```
+Deno requests net access to ":::1883". Run again with --allow-net to bypass this prompt.
+   Allow? [y/n (y = yes allow, n = no deny)]
+```
+
+After you select `yes` you should have a working MQTT server.
+
+### Client
+
+```bash
+deno run https://deno.land/x/opifex/bin/mqtt.ts
+```
+
+On the first invocation Deno will download all dependencies. It will then pop
+the question:
+
+```
+Deno requests net access to "localhost:1883". Run again with --allow-net to bypass this prompt.
+   Allow? [y/n (y = yes allow, n = no deny)]
+```
+
+## Local deployment
+
+If you want to use Deno locally then clone the repository, e.g. using:
+
+```bash
+git clone https://github.com/seriousme/opifex.git
+```
+
+and then use:
+
+```bash
+deno run -A bin/demoServer.ts
+```
+
+```bash
+deno run -A bin/mqtt.ts
+```
+
+## JSR.io
+
+Opifex is also available on [JSR.io](https://jsr.io/@seriousme/opifex).
+
+#Platform Native This folder also contains code to run the server using Deno
+sockets instead of NodeJS sockets. You can modify the import statements in the
+demo server/client to use these instead.

package/deno/client.ts

@@ -0,0 +1,48 @@
+import { Client } from "../client/client.ts";
+import { logger } from "../client/deps.ts";
+import { wrapDenoConn } from "./wrapDenoConn.ts";
+import type { SockConn } from "../client/deps.ts";
+
+export async function getCaCerts(filename: string | undefined) {
+  if (!filename) {
+    return;
+  }
+  const caCerts = await Deno.readTextFile(filename);
+  if (caCerts === "") {
+    return;
+  }
+  return [caCerts];
+}
+
+export class TcpClient extends Client {
+  protected async connectMQTT(hostname: string, port = 1883) {
+    logger.debug({ hostname, port });
+    return wrapDenoConn(await Deno.connect({ hostname, port }));
+  }
+
+  protected async connectMQTTS(
+    hostname: string,
+    port = 8883,
+    caCerts?: string[],
+  ) {
+    logger.debug({ hostname, port, caCerts });
+    return wrapDenoConn(await Deno.connectTls({ hostname, port, caCerts }));
+  }
+
+  protected override createConn(
+    protocol: string,
+    hostname: string,
+    port?: number,
+    caCerts?: string[],
+  ): Promise<SockConn> {
+    // if you need to support alternative connection types just
+    // overload this method in your subclass
+    if (protocol === "mqtts:") {
+      return this.connectMQTTS(hostname, port, caCerts);
+    }
+    if (protocol === "mqtt:") {
+      return this.connectMQTT(hostname, port);
+    }
+    throw `Unsupported protocol: ${protocol}`;
+  }
+}

package/deno/server.test.ts

@@ -0,0 +1,14 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { TcpServer } from "./server.ts";
+
+test("Deno testServer", () => {
+  const server = new TcpServer({ port: 0 }, {});
+  server.start();
+  assert.deepStrictEqual(
+    server.port !== undefined,
+    true,
+    "server runs a a random port",
+  );
+  server.stop();
+});

package/deno/server.ts

@@ -0,0 +1,31 @@
+import { MqttServer } from "../server/mod.ts";
+import type { MqttServerOptions } from "../server/mod.ts";
+import { wrapDenoConn } from "./wrapDenoConn.ts";
+
+export class TcpServer {
+  private listener: Deno.Listener<Deno.Conn>;
+  private mqttServer: MqttServer;
+  constructor(
+    serverOptions: Deno.TcpListenOptions,
+    mqttOptions: MqttServerOptions,
+  ) {
+    this.listener = Deno.listen(serverOptions);
+    this.mqttServer = new MqttServer(mqttOptions);
+  }
+
+  async start() {
+    for await (const conn of this.listener) {
+      this.mqttServer.serve(wrapDenoConn(conn));
+    }
+  }
+  stop() {
+    this.listener.close();
+  }
+
+  get port() {
+    if (this.listener.addr.transport === "tcp") {
+      return this.listener.addr.port;
+    }
+    return undefined;
+  }
+}

package/deno/wrapDenoConn.ts

@@ -0,0 +1,12 @@
+import type { SockConn } from "../socket/socket.ts";
+
+export function wrapDenoConn(denoConn: Deno.Conn) {
+  const conn: SockConn = {
+    readable: denoConn.readable,
+    writable: denoConn.writable,
+    closer: denoConn.close.bind(denoConn),
+    localAddr: denoConn.localAddr,
+    remoteAddr: denoConn.remoteAddr,
+  };
+  return conn;
+}

package/deno.json

@@ -0,0 +1,8 @@
+{
+  "name": "@seriousme/opifex",
+  "version": "1.1.0",
+  "exports": {
+    "./server": "./server/mod.ts",
+    "./client": "./client/mod.ts"
+  }
+}

package/deno.lock

@@ -0,0 +1,47 @@
+{
+  "version": "4",
+  "specifiers": {
+    "jsr:@std/assert@1.0.2": "1.0.2",
+    "jsr:@std/internal@^1.0.1": "1.0.1",
+    "npm:@types/node@*": "22.5.4",
+    "npm:@types/node@^22.8.6": "22.8.6"
+  },
+  "jsr": {
+    "@std/assert@1.0.2": {
+      "integrity": "ccacec332958126deaceb5c63ff8b4eaf9f5ed0eac9feccf124110435e59e49c",
+      "dependencies": [
+        "jsr:@std/internal"
+      ]
+    },
+    "@std/internal@1.0.1": {
+      "integrity": "6f8c7544d06a11dd256c8d6ba54b11ed870aac6c5aeafff499892662c57673e6"
+    }
+  },
+  "npm": {
+    "@types/node@22.5.4": {
+      "integrity": "sha512-FDuKUJQm/ju9fT/SeX/6+gBzoPzlVCzfzmGkwKvRHQVxi4BntVbyIwf6a4Xn62mrvndLiml6z/UBXIdEVjQLXg==",
+      "dependencies": [
+        "undici-types"
+      ]
+    },
+    "@types/node@22.8.6": {
+      "integrity": "sha512-tosuJYKrIqjQIlVCM4PEGxOmyg3FCPa/fViuJChnGeEIhjA46oy8FMVoF9su1/v8PNs2a8Q0iFNyOx0uOF91nw==",
+      "dependencies": [
+        "undici-types"
+      ]
+    },
+    "undici-types@6.19.8": {
+      "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw=="
+    }
+  },
+  "workspace": {
+    "dependencies": [
+      "jsr:@std/assert@1.0.2"
+    ],
+    "packageJson": {
+      "dependencies": [
+        "npm:@types/node@^22.8.6"
+      ]
+    }
+  }
+}

package/dev_utils/dummyConn.ts

@@ -0,0 +1,95 @@
+import type { AsyncQueue } from "../utils/mod.ts";
+
+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();
+  }
+}
+
+class Uint8QueuedWriter implements WritableStreamDefaultWriter {
+  private queue: AsyncQueue<Uint8Array>;
+  closed = Promise.resolve(undefined);
+  close = () => Promise.resolve();
+  abort = () => Promise.resolve();
+  ready = Promise.resolve(undefined);
+  releaseLock = () => {};
+  desiredSize = 20;
+
+  constructor(
+    queue: AsyncQueue<Uint8Array>,
+  ) {
+    this.queue = queue;
+  }
+  write(chunk: Uint8Array): Promise<void> {
+    this.queue.push(chunk);
+    return Promise.resolve();
+  }
+}
+
+function ReadableStreamFrom(
+  iterable: AsyncIterable<Uint8Array>,
+): ReadableStream {
+  if (!iterable || !(Symbol.asyncIterator in iterable)) {
+    throw new TypeError("Argument must be an asyncIterable");
+  }
+
+  return new ReadableStream({
+    type: "bytes",
+    async pull(controller) {
+      const iterator = iterable[Symbol.asyncIterator]();
+      const next = await iterator.next();
+
+      if (next.done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(next.value);
+    },
+  });
+}
+
+export function makeDummySockConn(
+  readerBuffs: Uint8Array[],
+  writerBuf: Uint8Array,
+  closer = () => {},
+) {
+  const readBlob = new Blob(readerBuffs);
+  const readable = readBlob.stream();
+  const writable = new WritableStream(new Uint8Writer(writerBuf));
+  return {
+    readable,
+    writable,
+    closer,
+  };
+}
+
+export function makeDummyQueueSockConn(
+  r: AsyncQueue<Uint8Array>,
+  w: AsyncQueue<Uint8Array>,
+  closer = () => {},
+) {
+  const readable = ReadableStreamFrom(r);
+  const writable = new WritableStream(new Uint8QueuedWriter(w));
+  return {
+    readable,
+    writable,
+    closer,
+  };
+}

package/dev_utils/mod.ts

@@ -0,0 +1 @@
+export { makeDummyQueueSockConn, makeDummySockConn } from "./dummyConn.ts";

package/mqttConn/mqttConn.test.ts

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { makeDummySockConn } from "../dev_utils/mod.ts";
+import { type AnyPacket, encode, PacketType } from "../mqttPacket/mod.ts";
+import { MqttConn, MqttConnError } from "./mqttConn.ts";
+
+const connectPacket: AnyPacket = {
+  type: PacketType.connect,
+  protocolName: "MQTT",
+  protocolLevel: 4,
+  clientId: "testClient",
+  clean: true,
+  keepAlive: 60,
+  username: undefined,
+  password: undefined,
+  will: undefined,
+};
+
+const publishPacket: AnyPacket = {
+  type: PacketType.publish,
+  topic: "hello",
+  payload: new Uint8Array([0x77, 0x6f, 0x72, 0x6c, 0x64]), // "world"
+  dup: false,
+  retain: false,
+  qos: 0,
+  id: 0,
+};
+
+const disconnectPacket: AnyPacket = {
+  type: PacketType.disconnect,
+};
+
+test("MqttConn should act as asyncIterator", async () => {
+  const connect = encode(connectPacket);
+  const publish = encode(publishPacket);
+  const disconnect = encode(disconnectPacket);
+
+  const conn = makeDummySockConn(
+    [connect, publish, disconnect],
+    new Uint8Array(),
+  );
+  const mqttConn = new MqttConn({ conn });
+
+  const packets = [];
+  for await (const packet of mqttConn) {
+    packets.push(packet);
+  }
+
+  assert.deepStrictEqual(packets.length, 3);
+  assert.deepStrictEqual(packets[0], connectPacket);
+  assert.deepStrictEqual(packets[1], publishPacket);
+  assert.deepStrictEqual(packets[2], disconnectPacket);
+});
+
+test("MqttConn should close on malformed length", async () => {
+  const conn = makeDummySockConn([new Uint8Array([1, 175])], new Uint8Array());
+  const mqttConn = new MqttConn({ conn });
+
+  const packets = [];
+  for await (const packet of mqttConn) {
+    packets.push(packet);
+  }
+
+  assert.deepStrictEqual(packets.length, 0);
+  assert.deepStrictEqual(mqttConn.isClosed, true);
+  assert.deepStrictEqual(mqttConn.reason, MqttConnError.UnexpectedEof);
+});
+
+test("MqttConn should close on failed packets", async () => {
+  const connect = encode(connectPacket);
+  const publish = encode(publishPacket);
+  const brokenPublish = publish.slice(0, 7);
+
+  const conn = makeDummySockConn([connect, brokenPublish], new Uint8Array());
+  const mqttConn = new MqttConn({ conn });
+
+  const packets = [];
+  for await (const packet of mqttConn) {
+    packets.push(packet);
+  }
+
+  assert.deepStrictEqual(packets.length, 1);
+  assert.deepStrictEqual(packets[0], connectPacket);
+  assert.deepStrictEqual(mqttConn.isClosed, true);
+  assert.deepStrictEqual(mqttConn.reason, MqttConnError.UnexpectedEof);
+});
+
+test("MqttConn should close on packets too large", async () => {
+  const connect = encode(connectPacket);
+
+  const conn = makeDummySockConn([connect], new Uint8Array());
+  const mqttConn = new MqttConn({ conn, maxPacketSize: 20 });
+  const packets = [];
+  for await (const packet of mqttConn) {
+    packets.push(packet);
+  }
+
+  assert.deepStrictEqual(packets.length, 0);
+  assert.deepStrictEqual(mqttConn.isClosed, true);
+  assert.deepStrictEqual(mqttConn.reason, MqttConnError.packetTooLarge);
+});
+
+test("MqttConn should be writable", async () => {
+  const connect = encode(connectPacket);
+  const writer = new Uint8Array(24);
+  const conn = makeDummySockConn([connect], writer);
+  const mqttConn = new MqttConn({ conn });
+  await mqttConn.send(connectPacket);
+  assert.deepStrictEqual(writer, connect);
+});

package/mqttConn/mqttConn.ts

@@ -0,0 +1,134 @@
+import {
+  type AnyPacket,
+  decodePayload,
+  encode,
+  getLengthDecoder,
+  type LengthDecoderResult,
+} from "../mqttPacket/mod.ts";
+
+import { assert } from "../utils/mod.ts";
+import type { SockConn } from "../socket/socket.ts";
+import { Conn } from "../socket/socket.ts";
+
+export const MqttConnError = {
+  invalidPacket: "Invalid Packet",
+  packetTooLarge: "Packet too large",
+  UnexpectedEof: "Unexpected EOF",
+} as const;
+
+export interface IMqttConn extends AsyncIterable<AnyPacket> {
+  readonly conn: Conn;
+  readonly isClosed: boolean;
+  readonly reason: string | undefined;
+  [Symbol.asyncIterator](): AsyncIterableIterator<AnyPacket>;
+  send(data: AnyPacket): Promise<void>;
+  close(): void;
+}
+
+async function readByte(conn: Conn): Promise<number> {
+  const buf = new Uint8Array(1);
+  const bytesRead = await conn.read(buf);
+  assert(bytesRead !== null, MqttConnError.UnexpectedEof);
+  assert(bytesRead !== 0, MqttConnError.UnexpectedEof);
+  return buf[0];
+}
+
+async function readFull(conn: Conn, buf: Uint8Array): Promise<void> {
+  let bytesRead = 0;
+  while (bytesRead < buf.length) {
+    const read = await conn.read(buf.subarray(bytesRead));
+    assert(read !== null, MqttConnError.UnexpectedEof);
+    assert(read !== 0, MqttConnError.UnexpectedEof);
+    bytesRead += read;
+  }
+}
+
+/** Read MQTT packet
+ * @throws `Error` if packet is invalid
+ */
+export async function readPacket(
+  conn: Conn,
+  maxPacketSize: number,
+): Promise<AnyPacket> {
+  // fixed header is 1 byte of type + flags
+  // + a maximum of 4 bytes to encode the remaining length
+  const decodeLength = getLengthDecoder();
+  const firstByte = await readByte(conn);
+  let result: LengthDecoderResult;
+  do {
+    const byte = await readByte(conn);
+    result = decodeLength(byte);
+  } while (!result.done);
+
+  const remainingLength = result.length;
+  assert(remainingLength < maxPacketSize - 1, MqttConnError.packetTooLarge);
+  const packetBuf = new Uint8Array(remainingLength);
+  // read the rest of the packet
+  await readFull(conn, packetBuf);
+  const packet = decodePayload(firstByte, packetBuf);
+  assert(packet !== null, MqttConnError.UnexpectedEof);
+  return packet;
+}
+
+export class MqttConn implements IMqttConn {
+  readonly conn: Conn;
+  private readonly maxPacketSize: number;
+  private _reason: string | undefined = undefined;
+  private _isClosed = false;
+
+  constructor({
+    conn,
+    maxPacketSize,
+  }: {
+    conn: SockConn;
+    maxPacketSize?: number;
+  }) {
+    this.conn = new Conn(conn);
+    this.maxPacketSize = maxPacketSize || 2 * 1024 * 1024;
+  }
+
+  get reason(): string | undefined {
+    return this._reason;
+  }
+
+  async *[Symbol.asyncIterator](): AsyncIterableIterator<AnyPacket> {
+    while (!this._isClosed) {
+      try {
+        yield await readPacket(this.conn, this.maxPacketSize);
+      } catch (err) {
+        if (err instanceof Error) {
+          if (err.name === "PartialReadError") {
+            err.message = MqttConnError.UnexpectedEof;
+          }
+          this._reason = err.message;
+        }
+        // packet too large, malformed packet or connection closed
+        this.close();
+        break;
+      }
+    }
+  }
+
+  async send(data: AnyPacket): Promise<void> {
+    try {
+      await this.conn.write(encode(data));
+    } catch {
+      this.close();
+    }
+  }
+
+  get isClosed(): boolean {
+    return this._isClosed;
+  }
+
+  close(): void {
+    if (this.isClosed) return;
+    try {
+      this.conn.close();
+    } catch (e) {
+      console.error(e);
+    } finally {
+      this._isClosed = true;
+    }
+  }
+}

package/mqttPacket/AuthenticationResult.ts

@@ -0,0 +1,16 @@
+/**
+ *  Possible MQTT authentication results
+ */
+
+export const AuthenticationResult = {
+  ok: 0,
+  unacceptableProtocol: 1,
+  rejectedUsername: 2,
+  serverUnavailable: 3,
+  badUsernameOrPassword: 4,
+  notAuthorized: 5,
+} as const;
+
+export const AuthenticationResultByNumber = Object.fromEntries(
+  Object.entries(AuthenticationResult).map(([k, v]) => [v, k]),
+);

package/mqttPacket/BitMask.ts

@@ -0,0 +1,10 @@
+export const BitMask = {
+  bit0: 2 ** 0,
+  bit1: 2 ** 1,
+  bit2: 2 ** 2,
+  bit3: 2 ** 3,
+  bit4: 2 ** 4,
+  bit5: 2 ** 5,
+  bit6: 2 ** 6,
+  bit7: 2 ** 7,
+} as const;