@seriousme/opifex 1.1.0

package/server/handlers/handleSubscribe.ts

@@ -0,0 +1,47 @@
+import type { Context } from "../context.ts";
+import {
+  PacketType,
+  type SubscribePacket,
+  type Subscription,
+  type Topic,
+} from "../deps.ts";
+
+const SubscriptionFailure = 0x80;
+function authorizedToSubscribe(ctx: Context, topicFilter: Topic) {
+  if (ctx.handlers.isAuthorizedToSubscribe) {
+    return ctx.handlers.isAuthorizedToSubscribe(ctx, topicFilter);
+  }
+  return true;
+}
+
+export async function handleSubscribe(
+  ctx: Context,
+  packet: SubscribePacket,
+): Promise<void> {
+  //  The order of return codes in the SUBACK Packet MUST match the order of
+  //  Topic Filters in the SUBSCRIBE Packet [MQTT-3.9.3-1].
+
+  const validSubscriptions: Subscription[] = [];
+  const returnCodes = packet.subscriptions.map((sub) => {
+    if (ctx.store) {
+      if (!authorizedToSubscribe(ctx, sub.topicFilter)) {
+        return SubscriptionFailure;
+      }
+      ctx.persistence.subscribe(ctx.store, sub.topicFilter, sub.qos);
+      validSubscriptions.push(sub);
+      return sub.qos;
+    }
+    return SubscriptionFailure; // failure
+  });
+
+  await ctx.send({
+    type: PacketType.suback,
+    id: packet.id,
+    returnCodes: returnCodes,
+  });
+
+  // send any retained messages that match these subscriptions
+  if (ctx.store) {
+    ctx.persistence.handleRetained(ctx.store.clientId);
+  }
+}

package/server/handlers/handleUnsubscribe.ts

@@ -0,0 +1,17 @@
+import type { Context } from "../context.ts";
+import { PacketType, type UnsubscribePacket } from "../deps.ts";
+
+export async function handleUnsubscribe(
+  ctx: Context,
+  packet: UnsubscribePacket,
+): Promise<void> {
+  for (const topic of packet.topicFilters) {
+    if (ctx.store) {
+      ctx.persistence.unsubscribe(ctx.store, topic);
+    }
+  }
+  await ctx.send({
+    type: PacketType.unsuback,
+    id: packet.id,
+  });
+}

package/server/mod.ts

@@ -0,0 +1,16 @@
+/**
+ *  This module provides an MQTT Server interface
+ *  see the /bin folder for examples
+ *  @module
+ */
+export { AuthenticationResult } from "./deps.ts";
+export type {
+  IPersistence,
+  SockConn,
+  TAuthenticationResult,
+  Topic,
+} from "./deps.ts";
+export { MqttServer } from "./server.ts";
+export type { MqttServerOptions } from "./server.ts";
+export { Context } from "./context.ts";
+export type { Handlers } from "./context.ts";

package/server/server.ts

@@ -0,0 +1,74 @@
+import { Context, type Handlers } from "./context.ts";
+import {
+  AuthenticationResult,
+  type IPersistence,
+  logger,
+  MemoryPersistence,
+  type SockConn,
+  type Topic,
+} from "./deps.ts";
+
+import { handlePacket } from "./handlers/handlePacket.ts";
+
+const defaultIsAuthenticated = (
+  _ctx: Context,
+  _clientId: string,
+  _username: string,
+  _password: Uint8Array,
+) => AuthenticationResult.ok;
+
+const defaultIsAuthorized = (_ctx: Context, _topic: Topic) => true;
+
+/**
+ * The options to configure the MqttServer
+ */
+export type MqttServerOptions = {
+  persistence?: IPersistence;
+  handlers?: Handlers;
+};
+
+/** The MqttServer class provides a MQTT server with configurable persistence and
+ * authentication/authorization handlers.
+ *
+ * The default handlers are:
+ *  - isAuthenticated: always returns ok
+ *  - isAuthorizedToPublish: always returns true
+ *  - isAuthorizedToSubscribe: always returns true
+ *
+ * To customize the handlers, pass in a Handlers object.
+ * To customize the persistence, pass in a Persistence object.
+ */
+
+export class MqttServer {
+  handlers: Handlers;
+  persistence: IPersistence;
+  constructor({
+    persistence,
+    handlers,
+  }: MqttServerOptions) {
+    this.persistence = persistence || new MemoryPersistence();
+    this.handlers = {
+      isAuthenticated: handlers?.isAuthenticated || defaultIsAuthenticated,
+      isAuthorizedToPublish: handlers?.isAuthorizedToPublish ||
+        defaultIsAuthorized,
+      isAuthorizedToSubscribe: handlers?.isAuthorizedToSubscribe ||
+        defaultIsAuthorized,
+    };
+  }
+
+  async serve(conn: SockConn): Promise<void> {
+    const ctx = new Context(this.persistence, conn, this.handlers);
+    if (conn.remoteAddr?.transport === "tcp") {
+      logger.debug(`socket connected from ${conn.remoteAddr.hostname}`);
+    }
+    try {
+      for await (const packet of ctx.mqttConn) {
+        handlePacket(ctx, packet);
+      }
+    } catch (err) {
+      logger.debug(`Error while serving:${err}`);
+    } finally {
+      ctx.close();
+    }
+  }
+}

package/server/test/handleConnect.test.ts

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { makeDummyQueueSockConn } from "../../dev_utils/mod.ts";
+import {
+  type AnyPacket,
+  AuthenticationResult,
+  PacketType,
+} from "../../mqttPacket/mod.ts";
+import { AsyncQueue, nextTick } from "../../utils/mod.ts";
+import { MqttConn } from "../deps.ts";
+import { MqttServer } from "../mod.ts";
+import { handlers } from "./test-handlers.ts";
+
+const txtEncoder = new TextEncoder();
+// logger.level(LogLevel.debug);
+
+const connectPacket: AnyPacket = {
+  type: PacketType.connect,
+  protocolName: "MQTT",
+  protocolLevel: 4,
+  clientId: "testClient",
+  clean: true,
+  keepAlive: 0,
+  username: "IoTester_1",
+  password: txtEncoder.encode("strong_password"),
+  will: undefined,
+};
+
+const disconnectPacket: AnyPacket = {
+  type: PacketType.disconnect,
+};
+
+const mqttServer = new MqttServer({ handlers });
+
+function startServer(): {
+  reader: AsyncIterableIterator<AnyPacket>;
+  mqttConn: MqttConn;
+} {
+  const reader = new AsyncQueue<Uint8Array>();
+  const writer = new AsyncQueue<Uint8Array>();
+
+  const outputConn = makeDummyQueueSockConn(writer, reader);
+  const mqttConn = new MqttConn({ conn: outputConn });
+  const inputConn = makeDummyQueueSockConn(reader, writer, () => {
+    mqttConn.close();
+  });
+  mqttServer.serve(inputConn);
+  return { reader: mqttConn[Symbol.asyncIterator](), mqttConn };
+}
+
+test("Authentication with valid username and password works", async () => {
+  const { reader, mqttConn } = startServer();
+  mqttConn.send(connectPacket);
+  const { value: connack } = await reader.next();
+  assert.deepStrictEqual(
+    connack.type,
+    PacketType.connack,
+    "Expect Connack packet",
+  );
+  if (connack.type === PacketType.connack) {
+    assert.deepStrictEqual(
+      connack.returnCode,
+      AuthenticationResult.ok,
+      "Expected OK",
+    );
+  }
+  mqttConn.send(disconnectPacket);
+  await nextTick();
+  assert.deepStrictEqual(
+    mqttConn.isClosed,
+    true,
+    "Expected connection to be closed",
+  );
+});
+
+test("Authentication with invalid username fails", async () => {
+  const newPacket = Object.assign({}, connectPacket);
+  newPacket.username = "wrong";
+  const { reader, mqttConn } = startServer();
+  mqttConn.send(newPacket);
+  const { value: connack } = await reader.next();
+  assert.deepStrictEqual(
+    connack.type,
+    PacketType.connack,
+    "Expected Connack packet",
+  );
+  if (connack.type === PacketType.connack) {
+    assert.deepStrictEqual(
+      connack.returnCode,
+      AuthenticationResult.badUsernameOrPassword,
+      "Expected badUsernameOrPassword",
+    );
+  }
+  await nextTick();
+  assert.deepStrictEqual(
+    mqttConn.isClosed,
+    true,
+    "Expected connection to be closed",
+  );
+});
+
+test("Authentication with invalid password fails", async () => {
+  const newPacket = Object.assign({}, connectPacket);
+  newPacket.password = undefined;
+  const { reader, mqttConn } = startServer();
+  mqttConn.send(newPacket);
+  const { value: connack } = await reader.next();
+  assert.deepStrictEqual(
+    connack.type,
+    PacketType.connack,
+    "Expected Connack packet",
+  );
+  if (connack.type === PacketType.connack) {
+    assert.deepStrictEqual(
+      connack.returnCode,
+      AuthenticationResult.badUsernameOrPassword,
+      "Expected badUsernameOrPassword",
+    );
+  }
+  await nextTick();
+  assert.deepStrictEqual(
+    mqttConn.isClosed,
+    true,
+    "Expected connection to be closed",
+  );
+});

package/server/test/test-handlers.ts

@@ -0,0 +1,52 @@
+import { AuthenticationResult, type Context, type Topic } from "../mod.ts";
+import { logger } from "../../utils/mod.ts";
+import type { TAuthenticationResult } from "../deps.ts";
+
+const utf8Decoder = new TextDecoder();
+const userTable = new Map();
+userTable.set("IoTester_1", "strong_password");
+userTable.set("IoTester_2", "strong_password");
+const strictUsername = new RegExp(/^[a-zA-Z0-9]{0,23}$/);
+
+function isAuthenticated(
+  _ctx: Context,
+  clientId: string,
+  username: string,
+  password: Uint8Array,
+): TAuthenticationResult {
+  const pwd = utf8Decoder.decode(password);
+  logger.debug(
+    `Verifying authentication of client '${clientId}' with username '${username}' and password '${pwd}'`,
+  );
+
+  if (!userTable.has(username)) {
+    if (!strictUsername.test(username)) {
+      return AuthenticationResult.badUsernameOrPassword;
+    }
+  }
+
+  const pass = userTable.get(username);
+  if (pwd === pass) {
+    return AuthenticationResult.ok;
+  }
+  return AuthenticationResult.badUsernameOrPassword;
+}
+
+function isAuthorizedToPublish(ctx: Context, topic: Topic): boolean {
+  logger.debug(
+    `Checking authorization of client '${ctx.store?.clientId}' to publish on topic '${topic}'`,
+  );
+  return true;
+}
+function isAuthorizedToSubscribe(ctx: Context, topic: Topic): boolean {
+  logger.debug(
+    `Checking authorization of client '${ctx.store?.clientId}' to subscribe to topic '${topic}'`,
+  );
+  return true;
+}
+
+export const handlers = {
+  isAuthenticated,
+  isAuthorizedToPublish,
+  isAuthorizedToSubscribe,
+};

package/socket/socket.ts

@@ -0,0 +1,59 @@
+export type SockAddr = NetAddr | UnixAddr | undefined;
+export interface NetAddr {
+  transport?: "tcp" | "udp";
+  hostname: string;
+  port: number;
+}
+
+export interface UnixAddr {
+  transport: "unix" | "unixpacket";
+  path: string;
+}
+
+export type SockConn = {
+  readable: ReadableStream<Uint8Array>;
+  writable: WritableStream<Uint8Array>;
+  closer: () => void;
+  localAddr?: SockAddr;
+  remoteAddr?: SockAddr;
+};
+
+export class Conn {
+  reader: ReadableStreamBYOBReader;
+  writer: WritableStreamDefaultWriter<Uint8Array>;
+  closed: boolean;
+  remoteAddr: SockAddr | undefined;
+  closer: () => void;
+
+  constructor(sockConn: SockConn) {
+    this.closed = false;
+    this.reader = sockConn.readable.getReader({ mode: "byob" });
+    this.writer = sockConn.writable.getWriter();
+    this.closer = sockConn.closer;
+    this.remoteAddr = sockConn.remoteAddr;
+  }
+
+  async read(buff: Uint8Array): Promise<number | null> {
+    const buff2 = new Uint8Array(buff.length);
+    const result = await this.reader.read(buff2);
+    if (!result.done) {
+      buff.set(result.value);
+    }
+    return result.value?.byteLength || null;
+  }
+
+  write(data: Uint8Array): Promise<number> {
+    if (this.closed) {
+      return Promise.reject();
+    }
+    this.writer.write(data);
+    return new Promise((resolve) => resolve(data.length));
+  }
+
+  close() {
+    if (!this.closed) {
+      this.closed = true;
+      this.closer();
+    }
+  }
+}

package/timer/timer.test.ts

@@ -0,0 +1,48 @@
+import { Timer } from "./timer.ts";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+function delay(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+test("timer should ring", async () => {
+  const wait = 50;
+  const start = Date.now();
+  let end = Date.now();
+  const _timer = new Timer(() => {
+    end = Date.now();
+  }, wait);
+  await delay(wait);
+  const timeDiff = end - start - wait;
+  assert.deepStrictEqual(timeDiff < 10, true);
+});
+
+test("snooze should work", async () => {
+  const wait = 50;
+  const quarterWait = Math.floor(wait / 4);
+  const halfWait = quarterWait * 2;
+  const start = Date.now();
+  let end = 0;
+  const timer = new Timer(() => {
+    end = Date.now();
+  }, wait);
+  await delay(halfWait);
+  assert.deepStrictEqual(end, 0);
+  timer.reset();
+  await delay(halfWait + quarterWait);
+  assert.deepStrictEqual(end, 0);
+  await delay(wait + halfWait);
+  const timeDiff = end - start - (wait + halfWait);
+  assert.deepStrictEqual(timeDiff < 15, true, `TimeDiff of ${timeDiff} < 15`);
+});
+
+test("clear should work", () => {
+  const wait = 50;
+  let end = 0;
+  const timer = new Timer(() => {
+    end = Date.now();
+  }, wait);
+  timer.clear();
+  assert.deepStrictEqual(end, 0);
+});

package/timer/timer.ts

@@ -0,0 +1,45 @@
+export class Timer {
+  readonly delay: number; // delay in microseconds
+  // deno-lint-ignore ban-types
+  private action: Function; // function to perform when timer expires
+  private timer = 0;
+  private end = 0;
+  private running = false;
+
+  // deno-lint-ignore ban-types
+  constructor(action: Function, delay: number, wait = false) {
+    this.delay = delay;
+    this.action = action;
+    if (!wait) {
+      this.reset();
+    }
+  }
+
+  private startTimer(delay: number): void {
+    this.running = true;
+    this.timer = setTimeout(() => this.ring(), delay);
+  }
+
+  private ring(): void {
+    const timeLeft = this.end - Date.now();
+    // check if delay has passed, else execute action
+    if (timeLeft > 0) {
+      this.startTimer(timeLeft);
+      return;
+    }
+    this.running = false;
+    this.action();
+  }
+
+  reset(): void {
+    this.end = Date.now() + this.delay;
+    if (!this.running) {
+      this.startTimer(this.delay);
+    }
+  }
+
+  clear(): void {
+    clearTimeout(this.timer);
+    this.running = false;
+  }
+}

package/trie/trie.test.ts

@@ -0,0 +1,147 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { Trie } from "./trie.ts";
+
+type Data = Array<[string, number]>;
+type Matches = Array<[string, number[]]>;
+type MatchResult = Array<number | object>;
+
+const includesAll = (arr: MatchResult, values: MatchResult) =>
+  values.every((v) => arr.includes(v));
+
+function doTest(data: Data, matches: Matches) {
+  const root = new Trie<number>();
+  for (const [key, value] of data) {
+    root.add(key, value);
+  }
+
+  for (const [match, result] of matches) {
+    assert.ok(includesAll(root.match(match), result), `${match} found`);
+  }
+}
+
+test("new should create new Trie object", () => {
+  const root = new Trie<number>();
+  assert.deepStrictEqual(typeof root, "object");
+  assert.deepStrictEqual(root instanceof Trie, true);
+});
+
+test("match() should find the correct nodes in the trie structure", () => {
+  const data: Data = [
+    ["foo", 1],
+    ["foo/bar", 2],
+    ["foo/bar/buzz", 3],
+    ["foo/bar/buzz", 4],
+  ];
+
+  const matches: Matches = [
+    ["", []],
+    ["foo", [1]],
+    ["foo/bar", [2]],
+    ["foo/bar/buzz", [3, 4]],
+    ["foo/bar/buzz/", []],
+    ["/foo/bar/buzz/", []],
+    ["$SYS/foo/bar/buzz/", []],
+  ];
+
+  doTest(data, matches);
+});
+
+test("wildCardOne works", () => {
+  const data: Data = [
+    ["foo", 1],
+    ["foo/+/buzz", 2],
+    ["foo/bar/buzz", 3],
+    ["foo/bar/buzz", 4],
+    ["+/+", 5],
+    ["/+", 6],
+    ["+", 7],
+  ];
+
+  const matches: Matches = [
+    ["", [7]],
+    ["foo", [1, 7]],
+    ["foo/bar", [5]],
+    ["foo/bar/buzz", [2, 3, 4]],
+    ["/foo/bar/buzz", []],
+    ["/finance", [5, 6]],
+  ];
+
+  doTest(data, matches);
+});
+
+test("wildCardSubtree works", () => {
+  const data: Data = [
+    ["foo", 1],
+    ["foo/#", 2],
+    ["foo/bar/buzz", 3],
+    ["foo/bar/#", 4],
+    ["#", 5],
+    ["/#", 6],
+  ];
+
+  const matches: Matches = [
+    ["", [5]],
+    ["foo", [1, 5]],
+    ["foo/bar", [2, 5]],
+    ["foo/bar/buzz", [2, 3, 4, 5]],
+    ["/foo/bar/buzz", [5, 6]],
+    ["/finance", [5, 6]],
+  ];
+
+  doTest(data, matches);
+});
+
+test("Overlapping wildcards work", () => {
+  const data: Data = [
+    ["foo/+/buzz", 1],
+    ["+/bar/buzz", 2],
+  ];
+
+  const matches: Matches = [["foo/bar/buzz", [1, 2]]];
+
+  doTest(data, matches);
+});
+
+test("Reserved prefixes are excluded from toplevel wildcards", () => {
+  const data: Data = [
+    ["+/bar/buzz", 1],
+    ["#", 2],
+    ["$SYS/#", 3],
+    ["$SYS/+/bar/buzz", 4],
+  ];
+
+  const matches: Matches = [
+    ["foo/bar/buzz", [1, 2]],
+    ["$SYS/foo/bar/buzz", [3, 4]],
+  ];
+
+  doTest(data, matches);
+});
+
+test("Removal works", () => {
+  const root = new Trie<number>();
+  root.add("foo/bar", 1);
+  root.add("foo/bar", 2);
+  assert.ok(includesAll(root.match("foo/bar"), [1, 2]), "two items found");
+  root.remove("foo/bar", 2);
+  assert.ok(includesAll(root.match("foo/bar"), [1]), "one item found");
+  root.remove("foo/bar", 1);
+  assert.deepStrictEqual(root.match("foo/bar").length, 0, "no items left");
+});
+
+test("Removal of object values works", () => {
+  type ComplexValue = { a: number; b: number; c: number };
+
+  const root = new Trie<ComplexValue>(true);
+  const c1: ComplexValue = { a: 1, b: 2, c: 3 };
+  const c2: ComplexValue = { a: 2, b: 4, c: 6 };
+  root.add("foo/bar", c1);
+  root.add("foo/bar", c2);
+  assert.ok(includesAll(root.match("foo/bar"), [c1, c2]), "two items found");
+  root.remove("foo/bar", c2);
+  assert.ok(includesAll(root.match("foo/bar"), [c1]), "one item found");
+  root.remove("foo/bar", { a: 1, b: 2, c: 3 });
+  assert.ok(includesAll(root.match("foo/bar"), []), "empty array");
+  assert.deepStrictEqual(root.match("foo/bar").length, 0, "matches left");
+});