@seriousme/opifex 1.1.0

package/persistence/memory/memoryPersistence.ts

@@ -0,0 +1,156 @@
+import {
+  type ClientId,
+  type PacketId,
+  type PublishPacket,
+  type QoS,
+  type Topic,
+  type TopicFilter,
+  Trie,
+} from "../deps.ts";
+
+import type {
+  Client,
+  Handler,
+  IPersistence,
+  RetainStore,
+} from "../persistence.ts";
+import type { IStore, PacketStore, SubscriptionStore } from "../store.ts";
+import { assert } from "../../utils/mod.ts";
+
+const maxPacketId = 0xffff;
+// const maxQueueLength = 0xffff;
+
+type ClientSubscription = {
+  clientId: ClientId;
+  qos: QoS;
+};
+
+export class MemoryStore implements IStore {
+  clientId: ClientId;
+  private packetId: PacketId;
+  pendingIncoming: PacketStore;
+  pendingOutgoing: PacketStore;
+  pendingAckOutgoing: Set<PacketId>;
+  subscriptions: SubscriptionStore;
+
+  constructor(clientId: ClientId) {
+    this.packetId = 0;
+    this.pendingIncoming = new Map();
+    this.pendingOutgoing = new Map();
+    this.pendingAckOutgoing = new Set();
+    this.subscriptions = new Map();
+    this.clientId = clientId;
+  }
+
+  nextId(): PacketId {
+    const currentId = this.packetId;
+    do {
+      this.packetId++;
+      if (this.packetId > maxPacketId) {
+        this.packetId = 0;
+      }
+    } while (
+      (this.pendingOutgoing.has(this.packetId) ||
+        this.pendingAckOutgoing.has(this.packetId)) &&
+      this.packetId !== currentId
+    );
+    assert(this.packetId !== currentId, "No unused packetId available");
+    return this.packetId;
+  }
+}
+
+export class MemoryPersistence implements IPersistence {
+  clientList: Map<ClientId, Client>;
+  retained: RetainStore;
+  private trie: Trie<ClientSubscription>;
+
+  constructor() {
+    this.clientList = new Map();
+    this.retained = new Map();
+    this.trie = new Trie(true);
+  }
+
+  registerClient(clientId: ClientId, handler: Handler, clean: boolean): IStore {
+    const existingClient = this.clientList.get(clientId);
+    const store = !clean && existingClient
+      ? existingClient.store
+      : new MemoryStore(clientId);
+    this.clientList.set(clientId, { store, handler });
+    return store;
+  }
+
+  deregisterClient(clientId: ClientId): void {
+    const client = this.clientList.get(clientId);
+    if (client) {
+      this.unsubscribeAll(client.store);
+      this.clientList.delete(clientId);
+    }
+  }
+
+  subscribe(store: IStore, topicFilter: TopicFilter, qos: QoS): void {
+    const clientId = store.clientId;
+    if (!store.subscriptions.has(topicFilter)) {
+      store.subscriptions.set(topicFilter, qos);
+      this.trie.add(topicFilter, { clientId, qos });
+    }
+  }
+
+  unsubscribe(store: IStore, topicFilter: TopicFilter): void {
+    const clientId = store.clientId;
+    const qos = store.subscriptions.get(topicFilter);
+    if (qos) {
+      store.subscriptions.delete(topicFilter);
+      this.trie.remove(topicFilter, { clientId, qos });
+    }
+  }
+
+  private unsubscribeAll(store: IStore) {
+    for (const [topicFilter, _qos] of store.subscriptions) {
+      this.unsubscribe(store, topicFilter);
+    }
+  }
+
+  publish(topic: Topic, packet: PublishPacket): void {
+    if (packet.retain) {
+      this.retained.set(packet.topic, packet);
+      if (packet.payload === undefined) {
+        this.retained.delete(packet.topic);
+      }
+    }
+
+    // dedup clients
+    const clients = new Map();
+    for (const { clientId, qos } of this.trie.match(topic)) {
+      const prevQos = clients.get(clientId);
+      if (!prevQos || prevQos < qos) {
+        clients.set(clientId, qos);
+      }
+    }
+
+    // publish the message to all clients
+    for (const [clientId, qos] of clients) {
+      const newPacket = Object.assign({}, packet);
+      newPacket.retain = false;
+      newPacket.qos = qos;
+      //  logger.debug(`publish ${topic} to client ${clientId}`);
+      const client = this.clientList.get(clientId);
+      client?.handler(packet);
+    }
+  }
+
+  handleRetained(clientId: ClientId): void {
+    const retainedTrie: Trie<ClientId> = new Trie();
+    const client = this.clientList.get(clientId);
+    const store = client?.store;
+    if (store) {
+      for (const [topicFilter, _qos] of store.subscriptions) {
+        retainedTrie.add(topicFilter, clientId);
+      }
+      for (const [topic, packet] of this.retained) {
+        if (retainedTrie.match(topic).length > 0) {
+          client?.handler(packet);
+        }
+      }
+    }
+  }
+}

package/persistence/persistence.ts

@@ -0,0 +1,24 @@
+import type { ClientId, PublishPacket, QoS, Topic } from "./deps.ts";
+import type { IStore } from "./store.ts";
+
+export type Handler = (packet: PublishPacket) => void;
+
+export type RetainStore = Map<Topic, PublishPacket>;
+
+export type Client = { store: IStore; handler: Handler };
+
+/**
+ * IPersistence is the interface for various types of Persistence
+ * to store messages and subscriptions
+ * @interface IPersistence
+ */
+export interface IPersistence {
+  clientList: Map<ClientId, Client>;
+  retained: RetainStore;
+  registerClient(clientId: ClientId, handler: Handler, clean: boolean): IStore;
+  deregisterClient(clientId: ClientId): void;
+  publish(topic: Topic, packet: PublishPacket): void;
+  subscribe(store: IStore, topic: Topic, qos: QoS): void;
+  unsubscribe(store: IStore, topic: Topic): void;
+  handleRetained(clientId: ClientId): void;
+}

package/persistence/store.ts

@@ -0,0 +1,14 @@
+import type { ClientId, PacketId, PublishPacket, QoS, Topic } from "./deps.ts";
+
+export type PacketStore = Map<PacketId, PublishPacket>;
+
+export type SubscriptionStore = Map<Topic, QoS>;
+
+export interface IStore {
+  clientId: ClientId;
+  pendingIncoming: PacketStore;
+  pendingOutgoing: PacketStore;
+  pendingAckOutgoing: Set<PacketId>;
+  subscriptions: SubscriptionStore;
+  nextId(): PacketId;
+}

package/server/context.ts

@@ -0,0 +1,157 @@
+import {
+  type AnyPacket,
+  type IPersistence,
+  type IStore,
+  logger,
+  MqttConn,
+  PacketNameByType,
+  PacketType,
+  type PublishPacket,
+  type SockConn,
+  type TAuthenticationResult,
+  type Timer,
+  type Topic,
+} from "./deps.ts";
+
+export type ClientId = string;
+
+export const SysPrefix = "$";
+
+export const utf8Encoder = new TextEncoder();
+
+/**
+ * Handlers are hooks that the server will call
+ * and let you influence the servers behaviour.
+ * The following handlers can be configured:
+ *  - isAuthenticated()
+ *  - isAuthorizedToPublish()
+ *  - isAuthorizedToSubscribe()
+ */
+export type Handlers = {
+  isAuthenticated?(
+    ctx: Context,
+    clientId: ClientId,
+    username: string,
+    password: Uint8Array,
+  ): TAuthenticationResult;
+  isAuthorizedToPublish?(ctx: Context, topic: Topic): boolean;
+  isAuthorizedToSubscribe?(ctx: Context, topic: Topic): boolean;
+};
+
+/**
+ * The Context class is used to maintain state of a MQTT connection
+ * It handles:
+ *  - connect/disconnect including broadcasting of these events
+ *  - publish
+ *  - persistence
+ *  - the will
+ */
+
+export class Context {
+  connected: boolean;
+  conn: SockConn;
+  mqttConn: MqttConn;
+  persistence: IPersistence;
+  handlers: Handlers;
+  static clientList: Map<ClientId, Context> = new Map();
+  store?: IStore;
+  will?: PublishPacket;
+  timer?: Timer;
+
+  constructor(persistence: IPersistence, conn: SockConn, handlers: Handlers) {
+    this.persistence = persistence;
+    this.connected = false;
+    this.conn = conn;
+    this.mqttConn = new MqttConn({ conn });
+    this.handlers = handlers;
+  }
+
+  async send(packet: AnyPacket): Promise<void> {
+    logger.debug("Sending", PacketNameByType[packet.type]);
+    logger.debug(JSON.stringify(packet, null, 2));
+    await this.mqttConn.send(packet);
+  }
+
+  connect(clientId: string, clean: boolean): void {
+    logger.debug("Connecting", clientId);
+    const existingSession = Context.clientList.get(clientId);
+    if (existingSession) {
+      existingSession.close(false);
+    }
+    this.store = this.persistence.registerClient(
+      clientId,
+      this.doPublish.bind(this),
+      clean,
+    );
+
+    this.connected = true;
+    this.broadcast("$SYS/connect/clients", clientId);
+    logger.debug("Connected", clientId);
+  }
+
+  doPublish(packet: PublishPacket): void {
+    const qos = packet.qos || 0;
+    if (qos === 0) {
+      packet.id = 0;
+      this.send(packet);
+      return;
+    }
+    if (this.store) {
+      packet.id = this.store.nextId();
+      this.store.pendingOutgoing.set(packet.id, packet);
+      this.send(packet);
+    }
+  }
+
+  clean(clientId: string) {
+    this.persistence.deregisterClient(clientId);
+  }
+
+  close(executewill = true): void {
+    if (this.connected) {
+      logger.debug(
+        `Closing ${this.store?.clientId} while mqttConn is ${
+          this.mqttConn.isClosed ? "" : "not "
+        }closed`,
+      );
+      this.connected = false;
+      if (typeof this.timer === "object") {
+        this.timer.clear();
+      }
+      if (this.store) {
+        this.broadcast("$SYS/disconnect/clients", this.store.clientId);
+      }
+      if (executewill) {
+        this.handleWill();
+      }
+    }
+    if (!this.mqttConn.isClosed) {
+      this.mqttConn.close();
+    }
+  }
+
+  private handleWill() {
+    if (this.will) {
+      if (
+        !this.will.topic.startsWith(SysPrefix) &&
+        this.handlers.isAuthorizedToPublish &&
+        this.handlers.isAuthorizedToPublish(this, this.will.topic)
+      ) {
+        this.persistence.publish(this.will.topic, this.will);
+      }
+    }
+  }
+
+  broadcast(topic: Topic, payload: string, retain = false): void {
+    const packet: PublishPacket = {
+      type: PacketType.publish,
+      topic,
+      retain,
+      payload: utf8Encoder.encode(payload),
+    };
+    if (packet.retain === true) {
+      this.persistence.retained.set(packet.topic, packet);
+    }
+    this.persistence.publish(packet.topic, packet);
+  }
+}

package/server/deps.ts

@@ -0,0 +1,37 @@
+export type { SockConn } from "../socket/socket.ts";
+export { MqttConn } from "../mqttConn/mqttConn.ts";
+export type { IPersistence } from "../persistence/persistence.ts";
+export type { IStore } from "../persistence/store.ts";
+export { MemoryPersistence } from "../persistence/memory/memoryPersistence.ts";
+export type {
+  AnyPacket,
+  ClientId,
+  ConnackPacket,
+  ConnectPacket,
+  DisconnectPacket,
+  PacketId,
+  PingreqPacket,
+  PingresPacket,
+  PubackPacket,
+  PubcompPacket,
+  PublishPacket,
+  PubrecPacket,
+  PubrelPacket,
+  QoS,
+  SubackPacket,
+  SubscribePacket,
+  Subscription,
+  TAuthenticationResult,
+  Topic,
+  TopicFilter,
+  UnsubackPacket,
+  UnsubscribePacket,
+} from "../mqttPacket/mod.ts";
+
+export {
+  AuthenticationResult,
+  PacketNameByType,
+  PacketType,
+} from "../mqttPacket/mod.ts";
+export { Timer } from "../timer/timer.ts";
+export { logger } from "../utils/mod.ts";

package/server/handlers/handleConnect.ts

@@ -0,0 +1,73 @@
+import type { Context } from "../context.ts";
+import {
+  AuthenticationResult,
+  type ConnectPacket,
+  logger,
+  PacketType,
+  type TAuthenticationResult,
+  Timer,
+} from "../deps.ts";
+
+function isAuthenticated(
+  ctx: Context,
+  packet: ConnectPacket,
+): TAuthenticationResult {
+  if (ctx.handlers.isAuthenticated) {
+    return ctx.handlers.isAuthenticated(
+      ctx,
+      packet.clientId || "",
+      packet.username || "",
+      packet.password || new Uint8Array(0),
+    );
+  }
+  return AuthenticationResult.ok;
+}
+
+function validateConnect(
+  ctx: Context,
+  packet: ConnectPacket,
+): TAuthenticationResult {
+  if (packet.protocolLevel !== 4) {
+    return AuthenticationResult.unacceptableProtocol;
+  }
+  return isAuthenticated(ctx, packet);
+}
+
+export function handleConnect(ctx: Context, packet: ConnectPacket): void {
+  const clientId = packet.clientId || `Opifex-${crypto.randomUUID()}`;
+  const returnCode = validateConnect(ctx, packet);
+  // connect is ok
+  if (returnCode === AuthenticationResult.ok) {
+    if (packet.will) {
+      ctx.will = {
+        type: PacketType.publish,
+        qos: packet.will.qos,
+        retain: packet.will.retain,
+        topic: packet.will.topic,
+        payload: packet.will.payload,
+      };
+    }
+
+    ctx.connect(clientId, packet.clean || false);
+
+    const keepAlive = packet.keepAlive || 0;
+    if (keepAlive > 0) {
+      logger.debug(`Setting keepalive to ${keepAlive * 1500} ms`);
+      ctx.timer = new Timer(() => {
+        ctx.close();
+      }, Math.floor(keepAlive * 1500));
+    }
+  }
+
+  const sessionPresent = false;
+
+  ctx.send({
+    type: PacketType.connack,
+    sessionPresent,
+    returnCode,
+  });
+
+  if (returnCode !== AuthenticationResult.ok) {
+    ctx.close();
+  }
+}

package/server/handlers/handleDisconnect.ts

@@ -0,0 +1,6 @@
+import type { Context } from "../context.ts";
+
+export function handleDisconnect(ctx: Context): void {
+  ctx.will = undefined;
+  ctx.close();
+}

package/server/handlers/handlePacket.ts

@@ -0,0 +1,78 @@
+import type { Context } from "../context.ts";
+import {
+  type AnyPacket,
+  PacketNameByType,
+  PacketType,
+  type PubackPacket,
+  type PubcompPacket,
+  type PublishPacket,
+  type PubrecPacket,
+  type PubrelPacket,
+  type SubscribePacket,
+  type UnsubscribePacket,
+} from "../deps.ts";
+import { handleConnect } from "./handleConnect.ts";
+import { handlePingreq } from "./handlePingreq.ts";
+import { handlePublish } from "./handlePublish.ts";
+import { handlePuback } from "./handlePuback.ts";
+import { handlePubrec } from "./handlePubrec.ts";
+import { handlePubrel } from "./handlePubrel.ts";
+import { handlePubcomp } from "./handlePubcomp.ts";
+import { handleSubscribe } from "./handleSubscribe.ts";
+import { handleUnsubscribe } from "./handleUnsubscribe.ts";
+import { handleDisconnect } from "./handleDisconnect.ts";
+import { logger } from "../deps.ts";
+
+export async function handlePacket(
+  ctx: Context,
+  packet: AnyPacket,
+): Promise<void> {
+  logger.debug("handling", PacketNameByType[packet.type]);
+  logger.debug(JSON.stringify(packet, null, 2));
+  if (!ctx.connected) {
+    if (packet.type === PacketType.connect) {
+      handleConnect(ctx, packet);
+    } else {
+      throw new Error(
+        `Received ${PacketNameByType[packet.type]} packet before connect`,
+      );
+    }
+  } else {
+    switch (packet.type) {
+      case PacketType.pingreq:
+        await handlePingreq(ctx);
+        break;
+      case PacketType.publish:
+        await handlePublish(ctx, packet as PublishPacket);
+        break;
+      case PacketType.puback:
+        handlePuback(ctx, packet as PubackPacket);
+        break;
+      case PacketType.pubrel:
+        await handlePubrel(ctx, packet as PubrelPacket);
+        break;
+      case PacketType.pubrec:
+        await handlePubrec(ctx, packet as PubrecPacket);
+        break;
+      case PacketType.pubcomp:
+        handlePubcomp(ctx, packet as PubcompPacket);
+        break;
+      case PacketType.subscribe:
+        await handleSubscribe(ctx, packet as SubscribePacket);
+        break;
+      case PacketType.unsubscribe:
+        await handleUnsubscribe(ctx, packet as UnsubscribePacket);
+        break;
+      case PacketType.disconnect:
+        handleDisconnect(ctx);
+        break;
+      default:
+        throw new Error(
+          `Received unexpected ${
+            PacketNameByType[packet.type]
+          } packet after connect`,
+        );
+    }
+    ctx.timer?.reset();
+  }
+}

package/server/handlers/handlePingreq.ts

@@ -0,0 +1,8 @@
+import type { Context } from "../context.ts";
+import { PacketType } from "../deps.ts";
+
+export async function handlePingreq(ctx: Context): Promise<void> {
+  await ctx.send({
+    type: PacketType.pingres,
+  });
+}

package/server/handlers/handlePuback.ts

@@ -0,0 +1,12 @@
+import type { Context } from "../context.ts";
+import type { PubackPacket } from "../deps.ts";
+
+// A PUBACK Packet is the response to a PUBLISH Packet with QoS level 1.
+
+export function handlePuback(ctx: Context, packet: PubackPacket) {
+  // qos 1 only
+  const id = packet.id;
+  if (ctx.store?.pendingOutgoing.has(id)) {
+    ctx.store.pendingOutgoing.delete(id);
+  }
+}

package/server/handlers/handlePubcomp.ts

@@ -0,0 +1,12 @@
+import type { Context } from "../context.ts";
+import type { PubcompPacket } from "../deps.ts";
+
+// The PUBCOMP Packet is the response to a PUBREL Packet.
+// It is the fourth and final packet of the QoS 2 protocol exchange.
+
+export function handlePubcomp(ctx: Context, packet: PubcompPacket): void {
+  const id = packet.id;
+  if (ctx.store?.pendingAckOutgoing.has(id)) {
+    ctx.store.pendingAckOutgoing.delete(id);
+  }
+}

package/server/handlers/handlePublish.ts

@@ -0,0 +1,47 @@
+import { type Context, SysPrefix } from "../context.ts";
+import { PacketType, type PublishPacket, type Topic } from "../deps.ts";
+
+function authorizedToPublish(ctx: Context, topic: Topic) {
+  if (topic.startsWith(SysPrefix)) {
+    return false;
+  }
+  if (ctx.handlers.isAuthorizedToPublish) {
+    return ctx.handlers.isAuthorizedToPublish(ctx, topic);
+  }
+  return true;
+}
+
+export async function handlePublish(
+  ctx: Context,
+  packet: PublishPacket,
+): Promise<void> {
+  if (!authorizedToPublish(ctx, packet.topic)) {
+    return;
+  }
+
+  const qos = packet.qos || 0;
+  if (qos === 0) {
+    ctx.persistence.publish(packet.topic, packet);
+    return;
+  }
+
+  if (packet.id !== undefined) {
+    // qos 1
+    if (qos === 1) {
+      ctx.persistence.publish(packet.topic, packet);
+      await ctx.send({
+        type: PacketType.puback,
+        id: packet.id,
+      });
+      return;
+    }
+    // qos 2
+    if (ctx.store) {
+      ctx.store.pendingIncoming.set(packet.id, packet);
+      await ctx.send({
+        type: PacketType.pubrec,
+        id: packet.id,
+      });
+    }
+  }
+}

package/server/handlers/handlePubrec.ts

@@ -0,0 +1,20 @@
+import type { Context } from "../context.ts";
+import { PacketType, type PubrecPacket } from "../deps.ts";
+
+// qos 2
+// Discard message, Store PUBREC received <Packet Identifier>
+// send PUBREL <Packet Identifier>
+export async function handlePubrec(
+  ctx: Context,
+  packet: PubrecPacket,
+): Promise<void> {
+  const id = packet.id;
+  if (ctx.store?.pendingOutgoing.has(id)) {
+    ctx.store.pendingOutgoing.delete(id);
+    ctx.store.pendingAckOutgoing.add(id);
+    await ctx.send({
+      type: PacketType.pubrel,
+      id,
+    });
+  }
+}

package/server/handlers/handlePubrel.ts

@@ -0,0 +1,24 @@
+import type { Context } from "../context.ts";
+import { PacketType, type PubrelPacket } from "../deps.ts";
+
+// qos 2 only
+// Method A, Initiate onward delivery of the Application Message1  then discard message
+// Send PUBCOMP <Packet Identifier>
+
+export async function handlePubrel(
+  ctx: Context,
+  packet: PubrelPacket,
+): Promise<void> {
+  const id = packet.id;
+  if (ctx.store?.pendingIncoming.has(id)) {
+    const storedPacket = ctx.store.pendingIncoming.get(id);
+    if (storedPacket) {
+      ctx.persistence.publish(storedPacket.topic, storedPacket);
+      ctx.store.pendingIncoming.delete(id);
+      await ctx.send({
+        type: PacketType.pubcomp,
+        id,
+      });
+    }
+  }
+}