@seriousme/opifex 1.2.1 → 1.4.0

package/dist/persistence/memory/memoryPersistence.js

@@ -0,0 +1,117 @@
+import { Trie, } from "../deps.js";
+import { assert } from "../../utils/mod.js";
+const maxPacketId = 0xffff;
+export class MemoryStore {
+    clientId;
+    packetId;
+    pendingIncoming;
+    pendingOutgoing;
+    pendingAckOutgoing;
+    subscriptions;
+    constructor(clientId) {
+        this.packetId = 0;
+        this.pendingIncoming = new Map();
+        this.pendingOutgoing = new Map();
+        this.pendingAckOutgoing = new Set();
+        this.subscriptions = new Map();
+        this.clientId = clientId;
+    }
+    nextId() {
+        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 {
+    clientList;
+    retained;
+    trie;
+    constructor() {
+        this.clientList = new Map();
+        this.retained = new Map();
+        this.trie = new Trie(true);
+    }
+    registerClient(clientId, handler, clean) {
+        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) {
+        const client = this.clientList.get(clientId);
+        if (client) {
+            this.unsubscribeAll(client.store);
+            this.clientList.delete(clientId);
+        }
+    }
+    subscribe(store, topicFilter, qos) {
+        const clientId = store.clientId;
+        if (!store.subscriptions.has(topicFilter)) {
+            store.subscriptions.set(topicFilter, qos);
+            this.trie.add(topicFilter, { clientId, qos });
+        }
+    }
+    unsubscribe(store, topicFilter) {
+        const clientId = store.clientId;
+        const qos = store.subscriptions.get(topicFilter);
+        if (qos) {
+            store.subscriptions.delete(topicFilter);
+            this.trie.remove(topicFilter, { clientId, qos });
+        }
+    }
+    unsubscribeAll(store) {
+        for (const [topicFilter, _qos] of store.subscriptions) {
+            this.unsubscribe(store, topicFilter);
+        }
+    }
+    publish(topic, packet) {
+        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) {
+        const retainedTrie = 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/dist/persistence/persistence.js

@@ -0,0 +1 @@
+export {};

package/dist/persistence/store.js

@@ -0,0 +1 @@
+export {};

package/dist/server/context.js

@@ -0,0 +1,100 @@
+import { logger, MqttConn, PacketNameByType, PacketType, } from "./deps.js";
+export const SysPrefix = "$";
+export const utf8Encoder = new TextEncoder();
+/**
+ * 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;
+    conn;
+    mqttConn;
+    persistence;
+    handlers;
+    static clientList = new Map();
+    store;
+    will;
+    timer;
+    constructor(persistence, conn, handlers) {
+        this.persistence = persistence;
+        this.connected = false;
+        this.conn = conn;
+        this.mqttConn = new MqttConn({ conn });
+        this.handlers = handlers;
+    }
+    async send(packet) {
+        logger.debug("Sending", PacketNameByType[packet.type]);
+        logger.debug(JSON.stringify(packet, null, 2));
+        await this.mqttConn.send(packet);
+    }
+    connect(clientId, clean) {
+        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) {
+        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) {
+        this.persistence.deregisterClient(clientId);
+    }
+    close(executewill = true) {
+        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();
+        }
+    }
+    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, payload, retain = false) {
+        const packet = {
+            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/dist/server/deps.js

@@ -0,0 +1,5 @@
+export { MqttConn } from "../mqttConn/mqttConn.js";
+export { MemoryPersistence } from "../persistence/memory/memoryPersistence.js";
+export { AuthenticationResult, PacketNameByType, PacketType, } from "../mqttPacket/mod.js";
+export { Timer } from "../timer/timer.js";
+export { logger } from "../utils/mod.js";

package/dist/server/handlers/handleConnect.js

@@ -0,0 +1,46 @@
+import { AuthenticationResult, logger, PacketType, Timer, } from "../deps.js";
+function isAuthenticated(ctx, packet) {
+    if (ctx.handlers.isAuthenticated) {
+        return ctx.handlers.isAuthenticated(ctx, packet.clientId || "", packet.username || "", packet.password || new Uint8Array(0));
+    }
+    return AuthenticationResult.ok;
+}
+function validateConnect(ctx, packet) {
+    if (packet.protocolLevel !== 4) {
+        return AuthenticationResult.unacceptableProtocol;
+    }
+    return isAuthenticated(ctx, packet);
+}
+export function handleConnect(ctx, packet) {
+    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/dist/server/handlers/handleDisconnect.js

@@ -0,0 +1,4 @@
+export function handleDisconnect(ctx) {
+    ctx.will = undefined;
+    ctx.close();
+}

package/dist/server/handlers/handlePacket.js

@@ -0,0 +1,58 @@
+import { PacketNameByType, PacketType, } from "../deps.js";
+import { handleConnect } from "./handleConnect.js";
+import { handlePingreq } from "./handlePingreq.js";
+import { handlePublish } from "./handlePublish.js";
+import { handlePuback } from "./handlePuback.js";
+import { handlePubrec } from "./handlePubrec.js";
+import { handlePubrel } from "./handlePubrel.js";
+import { handlePubcomp } from "./handlePubcomp.js";
+import { handleSubscribe } from "./handleSubscribe.js";
+import { handleUnsubscribe } from "./handleUnsubscribe.js";
+import { handleDisconnect } from "./handleDisconnect.js";
+import { logger } from "../deps.js";
+export async function handlePacket(ctx, packet) {
+    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);
+                break;
+            case PacketType.puback:
+                handlePuback(ctx, packet);
+                break;
+            case PacketType.pubrel:
+                await handlePubrel(ctx, packet);
+                break;
+            case PacketType.pubrec:
+                await handlePubrec(ctx, packet);
+                break;
+            case PacketType.pubcomp:
+                handlePubcomp(ctx, packet);
+                break;
+            case PacketType.subscribe:
+                await handleSubscribe(ctx, packet);
+                break;
+            case PacketType.unsubscribe:
+                await handleUnsubscribe(ctx, packet);
+                break;
+            case PacketType.disconnect:
+                handleDisconnect(ctx);
+                break;
+            default:
+                throw new Error(`Received unexpected ${PacketNameByType[packet.type]} packet after connect`);
+        }
+        ctx.timer?.reset();
+    }
+}

package/dist/server/handlers/handlePingreq.js

@@ -0,0 +1,6 @@
+import { PacketType } from "../deps.js";
+export async function handlePingreq(ctx) {
+    await ctx.send({
+        type: PacketType.pingres,
+    });
+}

package/dist/server/handlers/handlePuback.js

@@ -0,0 +1,8 @@
+// A PUBACK Packet is the response to a PUBLISH Packet with QoS level 1.
+export function handlePuback(ctx, packet) {
+    // qos 1 only
+    const id = packet.id;
+    if (ctx.store?.pendingOutgoing.has(id)) {
+        ctx.store.pendingOutgoing.delete(id);
+    }
+}

package/dist/server/handlers/handlePubcomp.js

@@ -0,0 +1,8 @@
+// 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, packet) {
+    const id = packet.id;
+    if (ctx.store?.pendingAckOutgoing.has(id)) {
+        ctx.store.pendingAckOutgoing.delete(id);
+    }
+}

package/dist/server/handlers/handlePublish.js

@@ -0,0 +1,40 @@
+import { SysPrefix } from "../context.js";
+import { PacketType } from "../deps.js";
+function authorizedToPublish(ctx, topic) {
+    if (topic.startsWith(SysPrefix)) {
+        return false;
+    }
+    if (ctx.handlers.isAuthorizedToPublish) {
+        return ctx.handlers.isAuthorizedToPublish(ctx, topic);
+    }
+    return true;
+}
+export async function handlePublish(ctx, packet) {
+    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/dist/server/handlers/handlePubrec.js

@@ -0,0 +1,15 @@
+import { PacketType } from "../deps.js";
+// qos 2
+// Discard message, Store PUBREC received <Packet Identifier>
+// send PUBREL <Packet Identifier>
+export async function handlePubrec(ctx, packet) {
+    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/dist/server/handlers/handlePubrel.js

@@ -0,0 +1,18 @@
+import { PacketType } from "../deps.js";
+// qos 2 only
+// Method A, Initiate onward delivery of the Application Message1  then discard message
+// Send PUBCOMP <Packet Identifier>
+export async function handlePubrel(ctx, packet) {
+    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,
+            });
+        }
+    }
+}

package/dist/server/handlers/handleSubscribe.js

@@ -0,0 +1,33 @@
+import { PacketType, } from "../deps.js";
+const SubscriptionFailure = 0x80;
+function authorizedToSubscribe(ctx, topicFilter) {
+    if (ctx.handlers.isAuthorizedToSubscribe) {
+        return ctx.handlers.isAuthorizedToSubscribe(ctx, topicFilter);
+    }
+    return true;
+}
+export async function handleSubscribe(ctx, packet) {
+    //  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 = [];
+    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/dist/server/handlers/handleUnsubscribe.js

@@ -0,0 +1,12 @@
+import { PacketType } from "../deps.js";
+export async function handleUnsubscribe(ctx, packet) {
+    for (const topic of packet.topicFilters) {
+        if (ctx.store) {
+            ctx.persistence.unsubscribe(ctx.store, topic);
+        }
+    }
+    await ctx.send({
+        type: PacketType.unsuback,
+        id: packet.id,
+    });
+}