pxt-common-packages 9.3.5 → 9.3.9

package/libs/mqtt/mqtt.ts

@@ -155,13 +155,20 @@ namespace mqtt {
          * Structure of an MQTT Control Packet
          * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc384800392
          */
-        function createPacket(byte1: number, variable: Buffer, payload?: Buffer): Buffer {
-            if (payload == null) payload = control.createBuffer(0);
-            const byte2: number[] = encodeRemainingLength(variable.length + payload.length);
+        function createPacketHeader(byte1: number, variable: Buffer, payloadSize: number): Buffer {
+            const byte2: number[] = encodeRemainingLength(variable.length + payloadSize);
             return strChr([byte1])
                 .concat(strChr(byte2))
                 .concat(variable)
-                .concat(payload)
+        }
+
+        /**
+         * Structure of an MQTT Control Packet
+         * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc384800392
+         */
+        function createPacket(byte1: number, variable: Buffer, payload?: Buffer): Buffer {
+            if (payload == null) payload = control.createBuffer(0);
+            return createPacketHeader(byte1, variable, payload.length).concat(payload)
         }
 
         /**
@@ -208,17 +215,17 @@ namespace mqtt {
         }
 
         /**
-         * PUBLISH - Publish message
+         * PUBLISH - Publish message header - doesn't include "payload"
          * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc384800410
          */
-        export function createPublish(topic: string, message: Buffer, qos: number, retained: boolean) {
+        export function createPublishHeader(topic: string, payloadSize: number, qos: number, retained: boolean) {
             let byte1: number = ControlPacketType.Publish << 4 | (qos << 1);
             byte1 |= (retained) ? 1 : 0;
 
             const pid = strChr(getBytes(Constants.FixedPackedId));
             const variable = (qos === 0) ? pack(topic) : pack(topic).concat(pid);
 
-            return createPacket(byte1, variable, message);
+            return createPacketHeader(byte1, variable, payloadSize);
         }
 
         export function parsePublish(cmd: number, payload: Buffer): IMessage {
@@ -309,12 +316,25 @@ namespace mqtt {
         }
     }
 
+    export enum Status {
+        Disconnected = 0,
+        Connecting = 1,
+        Connected = 2,
+        Sending = 3,
+    }
+
     export class Client extends EventEmitter {
-        public logPriority: ConsolePriority;
+        public logPriority = ConsolePriority.Debug
+        public tracePriority = -1 as ConsolePriority;
+
         private log(msg: string) {
             console.add(this.logPriority, `mqtt: ${msg}`);
         }
 
+        private trace(msg: string) {
+            console.add(this.tracePriority, `mqtt: ${msg}`);
+        }
+
         public opt: IConnectionOptions;
 
         private net: net.Net;
@@ -325,7 +345,11 @@ namespace mqtt {
 
         private buf: Buffer;
 
-        public connected: boolean;
+        public status = Status.Disconnected
+
+        get connected() {
+            return this.status >= Status.Connected
+        }
 
         private mqttHandlers: MQTTHandler[];
 
@@ -334,8 +358,6 @@ namespace mqtt {
 
             this.wdId = Constants.Uninitialized;
             this.piId = Constants.Uninitialized;
-            this.logPriority = ConsolePriority.Debug;
-            this.connected = false;
             opt.port = opt.port || 8883;
             opt.clientId = opt.clientId;
 
@@ -385,15 +407,19 @@ namespace mqtt {
                 this.piId = Constants.Uninitialized;
             }
 
-            if (this.sct) {
-                //this.sct.removeAllListeners('connect');
-                //this.sct.removeAllListeners('data');
-                //this.sct.removeAllListeners('close');
-                this.sct.close();
+            const s = this.sct
+            if (s) {
+                this.sct = null
+                s.close()
             }
+
+            this.status = Status.Disconnected
         }
 
         public connect(): void {
+            if (this.status != Status.Disconnected)
+                return
+            this.status = Status.Connecting
             this.log(`Connecting to ${this.opt.host}:${this.opt.port}`);
             if (this.wdId === Constants.Uninitialized) {
                 this.wdId = setInterval(() => {
@@ -413,7 +439,7 @@ namespace mqtt {
                 this.send(Protocol.createConnect(this.opt));
             });
             this.sct.onMessage((msg: Buffer) => {
-                this.log("incoming " + msg.length + " bytes")
+                this.trace("incoming " + msg.length + " bytes")
                 this.handleMessage(msg);
             });
             this.sct.onError(() => {
@@ -423,21 +449,63 @@ namespace mqtt {
             this.sct.onClose(() => {
                 this.log('Close.');
                 this.emit('disconnected');
-                this.connected = false;
+                this.status = Status.Disconnected
+                this.sct = null;
             });
             this.sct.connect();
         }
 
+        private canSend() {
+            let cnt = 0
+            while (true) {
+                if (this.status == Status.Connected) {
+                    this.status = Status.Sending
+                    return true
+                }
+                if (cnt++ < 100 && this.status == Status.Sending)
+                    pause(20)
+                else {
+                    this.log("drop pkt")
+                    return false
+                }
+            }
+        }
+
+        private doneSending() {
+            this.trace("done send")
+            if (this.status == Status.Sending)
+                this.status = Status.Connected
+        }
+
         // Publish a message
         public publish(topic: string, message?: string | Buffer, qos: number = Constants.DefaultQos, retained: boolean = false): void {
             const buf = typeof message == "string" ? control.createBufferFromUTF8(message) : message
-            this.log(`publish: ${topic}`)
-            this.send(Protocol.createPublish(topic, buf, qos, retained));
+            message = null
+            if (this.startPublish(topic, buf ? buf.length : 0, qos, retained)) {
+                if (buf)
+                    this.send(buf);
+                this.doneSending()
+            }
+        }
+
+        public startPublish(topic: string, messageLen: number, qos: number = Constants.DefaultQos, retained: boolean = false) {
+            if (!this.canSend()) return false
+            this.trace(`publish: ${topic} ${messageLen}b`)
+            this.send(Protocol.createPublishHeader(topic, messageLen, qos, retained));
+            return true
+        }
+
+        public continuePublish(data: Buffer) {
+            this.send(data)
+        }
+
+        public finishPublish() {
+            this.doneSending()
         }
 
         private subscribeCore(topic: string, handler: (msg: IMessage) => void, qos: number = Constants.DefaultQos): MQTTHandler {
             this.log(`subscribe: ${topic}`)
-            this.send(Protocol.createSubscribe(topic, qos));
+            this.send1(Protocol.createSubscribe(topic, qos));
             if (handler) {
                 if (topic[topic.length - 1] == "#")
                     topic = topic.slice(0, topic.length - 1)
@@ -474,8 +542,8 @@ namespace mqtt {
 
         private send(data: Buffer): void {
             if (this.sct) {
-                //this.log("send: " + data[0] + " / " + data.length + " bytes")
-                this.log("send: " + data[0] + " / " + data.length + " bytes: " + data.toHex())
+                this.trace("send: " + data[0] + " / " + data.length + " bytes")
+                // this.log("send: " + data[0] + " / " + data.length + " bytes: " + data.toHex())
                 this.sct.send(data);
             }
         }
@@ -518,17 +586,18 @@ namespace mqtt {
                     if (returnCode === ConnectReturnCode.Accepted) {
                         this.log('MQTT connection accepted.');
                         this.emit('connected');
-                        this.connected = true;
+                        this.status = Status.Connected;
                         this.piId = setInterval(() => this.ping(), Constants.PingInterval * 1000);
                     } else {
                         const connectionError: string = Client.describe(returnCode);
                         this.log('MQTT connection error: ' + connectionError);
                         this.emit('error', connectionError);
+                        this.disconnect()
                     }
                     break;
                 case ControlPacketType.Publish:
                     const message: IMessage = Protocol.parsePublish(cmd, payload);
-                    this.log(`incoming: ${message.topic}`)
+                    this.trace(`incoming: ${message.topic}`)
                     let handled = false
                     let cleanup = false
                     if (this.mqttHandlers) {
@@ -548,7 +617,7 @@ namespace mqtt {
                         this.emit('receive', message);
                     if (message.qos > 0) {
                         setTimeout(() => {
-                            this.send(Protocol.createPubAck(message.pid || 0));
+                            this.send1(Protocol.createPubAck(message.pid || 0));
                         }, 0);
                     }
                     break;
@@ -564,8 +633,15 @@ namespace mqtt {
                 this.handleMessage(data.slice(payloadEnd))
         }
 
+        private send1(msg: Buffer) {
+            if (this.canSend()) {
+                this.send(msg)
+                this.doneSending()
+            }
+        }
+
         private ping() {
-            this.send(Protocol.createPingReq());
+            this.send1(Protocol.createPingReq());
             this.emit('debug', 'Sent: Ping request.');
         }
     }