@gdyfe/rop-client
Version:
1,320 lines (1,160 loc) • 112 kB
JavaScript
var rop = (function () {
'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var EventEmitter = (function () {
function EventEmitter() {
this.event = {};
this.maxListeners = 10;
}
EventEmitter.prototype.on = function (type, listener) {
if (this.event[type]) {
if (this.event[type].length >= this.maxListeners) {
console.error('同一监听器最多允许被十个对象监听，否则可能造成内存泄漏.\n');
return;
}
this.event[type].push(listener);
}
else {
this.event[type] = [listener];
}
};
EventEmitter.prototype.emit = function (type) {
var _this = this;
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
if (this.event[type]) {
this.event[type].map(function (fn) { return fn.apply(_this, args); });
}
};
EventEmitter.prototype.removeListener = function (type) {
if (this.event[type]) {
delete this.event[type];
console.log(this.event);
}
};
EventEmitter.prototype.removeAllListener = function () {
this.event = {};
};
return EventEmitter;
}());
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var pahoMqtt = createCommonjsModule(function (module, exports) {
/*******************************************************************************
* Copyright (c) 2013 IBM Corp.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v1.0 which accompany this distribution.
*
* The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Andrew Banks - initial API and implementation and initial documentation
*******************************************************************************/
// Only expose a single object name in the global namespace.
// Everything must go through this module. Global Paho module
// only has a single public function, client, which returns
// a Paho client object given connection details.
/**
* Send and receive messages using web browsers.
* <p>
* This programming interface lets a JavaScript client application use the MQTT V3.1 or
* V3.1.1 protocol to connect to an MQTT-supporting messaging server.
*
* The function supported includes:
* <ol>
* <li>Connecting to and disconnecting from a server. The server is identified by its host name and port number.
* <li>Specifying options that relate to the communications link with the server,
* for example the frequency of keep-alive heartbeats, and whether SSL/TLS is required.
* <li>Subscribing to and receiving messages from MQTT Topics.
* <li>Publishing messages to MQTT Topics.
* </ol>
* <p>
* The API consists of two main objects:
* <dl>
* <dt><b>{@link Paho.Client}</b></dt>
* <dd>This contains methods that provide the functionality of the API,
* including provision of callbacks that notify the application when a message
* arrives from or is delivered to the messaging server,
* or when the status of its connection to the messaging server changes.</dd>
* <dt><b>{@link Paho.Message}</b></dt>
* <dd>This encapsulates the payload of the message along with various attributes
* associated with its delivery, in particular the destination to which it has
* been (or is about to be) sent.</dd>
* </dl>
* <p>
* The programming interface validates parameters passed to it, and will throw
* an Error containing an error message intended for developer use, if it detects
* an error with any parameter.
* <p>
* Example:
*
* <code><pre>
var client = new Paho.MQTT.Client(location.hostname, Number(location.port), "clientId");
client.onConnectionLost = onConnectionLost;
client.onMessageArrived = onMessageArrived;
client.connect({onSuccess:onConnect});
function onConnect() {
// Once a connection has been made, make a subscription and send a message.
console.log("onConnect");
client.subscribe("/World");
var message = new Paho.MQTT.Message("Hello");
message.destinationName = "/World";
client.send(message);
};
function onConnectionLost(responseObject) {
if (responseObject.errorCode !== 0)
console.log("onConnectionLost:"+responseObject.errorMessage);
};
function onMessageArrived(message) {
console.log("onMessageArrived:"+message.payloadString);
client.disconnect();
};
* </pre></code>
* @namespace Paho
*/
/* jshint shadow:true */
(function ExportLibrary(root, factory) {
{
module.exports = factory();
}
})(commonjsGlobal, function LibraryFactory(){
var PahoMQTT = (function (global) {
// Private variables below, these are only visible inside the function closure
// which is used to define the module.
var version = "@VERSION@-@BUILDLEVEL@";
/**
* @private
*/
var localStorage = global.localStorage || (function () {
var data = {};
return {
setItem: function (key, item) { data[key] = item; },
getItem: function (key) { return data[key]; },
removeItem: function (key) { delete data[key]; },
};
})();
/**
* Unique message type identifiers, with associated
* associated integer values.
* @private
*/
var MESSAGE_TYPE = {
CONNECT: 1,
CONNACK: 2,
PUBLISH: 3,
PUBACK: 4,
PUBREC: 5,
PUBREL: 6,
PUBCOMP: 7,
SUBSCRIBE: 8,
SUBACK: 9,
UNSUBSCRIBE: 10,
UNSUBACK: 11,
PINGREQ: 12,
PINGRESP: 13,
DISCONNECT: 14
};
// Collection of utility methods used to simplify module code
// and promote the DRY pattern.
/**
* Validate an object's parameter names to ensure they
* match a list of expected variables name for this option
* type. Used to ensure option object passed into the API don't
* contain erroneous parameters.
* @param {Object} obj - User options object
* @param {Object} keys - valid keys and types that may exist in obj.
* @throws {Error} Invalid option parameter found.
* @private
*/
var validate = function(obj, keys) {
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
if (keys.hasOwnProperty(key)) {
if (typeof obj[key] !== keys[key])
throw new Error(format(ERROR.INVALID_TYPE, [typeof obj[key], key]));
} else {
var errorStr = "Unknown property, " + key + ". Valid properties are:";
for (var validKey in keys)
if (keys.hasOwnProperty(validKey))
errorStr = errorStr+" "+validKey;
throw new Error(errorStr);
}
}
}
};
/**
* Return a new function which runs the user function bound
* to a fixed scope.
* @param {function} User function
* @param {object} Function scope
* @return {function} User function bound to another scope
* @private
*/
var scope = function (f, scope) {
return function () {
return f.apply(scope, arguments);
};
};
/**
* Unique message type identifiers, with associated
* associated integer values.
* @private
*/
var ERROR = {
OK: {code:0, text:"AMQJSC0000I OK."},
CONNECT_TIMEOUT: {code:1, text:"AMQJSC0001E Connect timed out."},
SUBSCRIBE_TIMEOUT: {code:2, text:"AMQJS0002E Subscribe timed out."},
UNSUBSCRIBE_TIMEOUT: {code:3, text:"AMQJS0003E Unsubscribe timed out."},
PING_TIMEOUT: {code:4, text:"AMQJS0004E Ping timed out."},
INTERNAL_ERROR: {code:5, text:"AMQJS0005E Internal error. Error Message: {0}, Stack trace: {1}"},
CONNACK_RETURNCODE: {code:6, text:"AMQJS0006E Bad Connack return code:{0} {1}."},
SOCKET_ERROR: {code:7, text:"AMQJS0007E Socket error:{0}."},
SOCKET_CLOSE: {code:8, text:"AMQJS0008I Socket closed."},
MALFORMED_UTF: {code:9, text:"AMQJS0009E Malformed UTF data:{0} {1} {2}."},
UNSUPPORTED: {code:10, text:"AMQJS0010E {0} is not supported by this browser."},
INVALID_STATE: {code:11, text:"AMQJS0011E Invalid state {0}."},
INVALID_TYPE: {code:12, text:"AMQJS0012E Invalid type {0} for {1}."},
INVALID_ARGUMENT: {code:13, text:"AMQJS0013E Invalid argument {0} for {1}."},
UNSUPPORTED_OPERATION: {code:14, text:"AMQJS0014E Unsupported operation."},
INVALID_STORED_DATA: {code:15, text:"AMQJS0015E Invalid data in local storage key={0} value={1}."},
INVALID_MQTT_MESSAGE_TYPE: {code:16, text:"AMQJS0016E Invalid MQTT message type {0}."},
MALFORMED_UNICODE: {code:17, text:"AMQJS0017E Malformed Unicode string:{0} {1}."},
BUFFER_FULL: {code:18, text:"AMQJS0018E Message buffer is full, maximum buffer size: {0}."},
};
/** CONNACK RC Meaning. */
var CONNACK_RC = {
0:"Connection Accepted",
1:"Connection Refused: unacceptable protocol version",
2:"Connection Refused: identifier rejected",
3:"Connection Refused: server unavailable",
4:"Connection Refused: bad user name or password",
5:"Connection Refused: not authorized"
};
/**
* Format an error message text.
* @private
* @param {error} ERROR value above.
* @param {substitutions} [array] substituted into the text.
* @return the text with the substitutions made.
*/
var format = function(error, substitutions) {
var text = error.text;
if (substitutions) {
var field,start;
for (var i=0; i<substitutions.length; i++) {
field = "{"+i+"}";
start = text.indexOf(field);
if(start > 0) {
var part1 = text.substring(0,start);
var part2 = text.substring(start+field.length);
text = part1+substitutions[i]+part2;
}
}
}
return text;
};
//MQTT protocol and version 6 M Q I s d p 3
var MqttProtoIdentifierv3 = [0x00,0x06,0x4d,0x51,0x49,0x73,0x64,0x70,0x03];
//MQTT proto/version for 311 4 M Q T T 4
var MqttProtoIdentifierv4 = [0x00,0x04,0x4d,0x51,0x54,0x54,0x04];
/**
* Construct an MQTT wire protocol message.
* @param type MQTT packet type.
* @param options optional wire message attributes.
*
* Optional properties
*
* messageIdentifier: message ID in the range [0..65535]
* payloadMessage: Application Message - PUBLISH only
* connectStrings: array of 0 or more Strings to be put into the CONNECT payload
* topics: array of strings (SUBSCRIBE, UNSUBSCRIBE)
* requestQoS: array of QoS values [0..2]
*
* "Flag" properties
* cleanSession: true if present / false if absent (CONNECT)
* willMessage: true if present / false if absent (CONNECT)
* isRetained: true if present / false if absent (CONNECT)
* userName: true if present / false if absent (CONNECT)
* password: true if present / false if absent (CONNECT)
* keepAliveInterval: integer [0..65535] (CONNECT)
*
* @private
* @ignore
*/
var WireMessage = function (type, options) {
this.type = type;
for (var name in options) {
if (options.hasOwnProperty(name)) {
this[name] = options[name];
}
}
};
WireMessage.prototype.encode = function() {
// Compute the first byte of the fixed header
var first = ((this.type & 0x0f) << 4);
/*
* Now calculate the length of the variable header + payload by adding up the lengths
* of all the component parts
*/
var remLength = 0;
var topicStrLength = [];
var destinationNameLength = 0;
var willMessagePayloadBytes;
// if the message contains a messageIdentifier then we need two bytes for that
if (this.messageIdentifier !== undefined)
remLength += 2;
switch(this.type) {
// If this a Connect then we need to include 12 bytes for its header
case MESSAGE_TYPE.CONNECT:
switch(this.mqttVersion) {
case 3:
remLength += MqttProtoIdentifierv3.length + 3;
break;
case 4:
remLength += MqttProtoIdentifierv4.length + 3;
break;
}
remLength += UTF8Length(this.clientId) + 2;
if (this.willMessage !== undefined) {
remLength += UTF8Length(this.willMessage.destinationName) + 2;
// Will message is always a string, sent as UTF-8 characters with a preceding length.
willMessagePayloadBytes = this.willMessage.payloadBytes;
if (!(willMessagePayloadBytes instanceof Uint8Array))
willMessagePayloadBytes = new Uint8Array(payloadBytes);
remLength += willMessagePayloadBytes.byteLength +2;
}
if (this.userName !== undefined)
remLength += UTF8Length(this.userName) + 2;
if (this.password !== undefined)
remLength += UTF8Length(this.password) + 2;
break;
// Subscribe, Unsubscribe can both contain topic strings
case MESSAGE_TYPE.SUBSCRIBE:
first |= 0x02; // Qos = 1;
for ( var i = 0; i < this.topics.length; i++) {
topicStrLength[i] = UTF8Length(this.topics[i]);
remLength += topicStrLength[i] + 2;
}
remLength += this.requestedQos.length; // 1 byte for each topic's Qos
// QoS on Subscribe only
break;
case MESSAGE_TYPE.UNSUBSCRIBE:
first |= 0x02; // Qos = 1;
for ( var i = 0; i < this.topics.length; i++) {
topicStrLength[i] = UTF8Length(this.topics[i]);
remLength += topicStrLength[i] + 2;
}
break;
case MESSAGE_TYPE.PUBREL:
first |= 0x02; // Qos = 1;
break;
case MESSAGE_TYPE.PUBLISH:
if (this.payloadMessage.duplicate) first |= 0x08;
first = first |= (this.payloadMessage.qos << 1);
if (this.payloadMessage.retained) first |= 0x01;
destinationNameLength = UTF8Length(this.payloadMessage.destinationName);
remLength += destinationNameLength + 2;
var payloadBytes = this.payloadMessage.payloadBytes;
remLength += payloadBytes.byteLength;
if (payloadBytes instanceof ArrayBuffer)
payloadBytes = new Uint8Array(payloadBytes);
else if (!(payloadBytes instanceof Uint8Array))
payloadBytes = new Uint8Array(payloadBytes.buffer);
break;
}
// Now we can allocate a buffer for the message
var mbi = encodeMBI(remLength); // Convert the length to MQTT MBI format
var pos = mbi.length + 1; // Offset of start of variable header
var buffer = new ArrayBuffer(remLength + pos);
var byteStream = new Uint8Array(buffer); // view it as a sequence of bytes
//Write the fixed header into the buffer
byteStream[0] = first;
byteStream.set(mbi,1);
// If this is a PUBLISH then the variable header starts with a topic
if (this.type == MESSAGE_TYPE.PUBLISH)
pos = writeString(this.payloadMessage.destinationName, destinationNameLength, byteStream, pos);
// If this is a CONNECT then the variable header contains the protocol name/version, flags and keepalive time
else if (this.type == MESSAGE_TYPE.CONNECT) {
switch (this.mqttVersion) {
case 3:
byteStream.set(MqttProtoIdentifierv3, pos);
pos += MqttProtoIdentifierv3.length;
break;
case 4:
byteStream.set(MqttProtoIdentifierv4, pos);
pos += MqttProtoIdentifierv4.length;
break;
}
var connectFlags = 0;
if (this.cleanSession)
connectFlags = 0x02;
if (this.willMessage !== undefined ) {
connectFlags |= 0x04;
connectFlags |= (this.willMessage.qos<<3);
if (this.willMessage.retained) {
connectFlags |= 0x20;
}
}
if (this.userName !== undefined)
connectFlags |= 0x80;
if (this.password !== undefined)
connectFlags |= 0x40;
byteStream[pos++] = connectFlags;
pos = writeUint16 (this.keepAliveInterval, byteStream, pos);
}
// Output the messageIdentifier - if there is one
if (this.messageIdentifier !== undefined)
pos = writeUint16 (this.messageIdentifier, byteStream, pos);
switch(this.type) {
case MESSAGE_TYPE.CONNECT:
pos = writeString(this.clientId, UTF8Length(this.clientId), byteStream, pos);
if (this.willMessage !== undefined) {
pos = writeString(this.willMessage.destinationName, UTF8Length(this.willMessage.destinationName), byteStream, pos);
pos = writeUint16(willMessagePayloadBytes.byteLength, byteStream, pos);
byteStream.set(willMessagePayloadBytes, pos);
pos += willMessagePayloadBytes.byteLength;
}
if (this.userName !== undefined)
pos = writeString(this.userName, UTF8Length(this.userName), byteStream, pos);
if (this.password !== undefined)
pos = writeString(this.password, UTF8Length(this.password), byteStream, pos);
break;
case MESSAGE_TYPE.PUBLISH:
// PUBLISH has a text or binary payload, if text do not add a 2 byte length field, just the UTF characters.
byteStream.set(payloadBytes, pos);
break;
// case MESSAGE_TYPE.PUBREC:
// case MESSAGE_TYPE.PUBREL:
// case MESSAGE_TYPE.PUBCOMP:
// break;
case MESSAGE_TYPE.SUBSCRIBE:
// SUBSCRIBE has a list of topic strings and request QoS
for (var i=0; i<this.topics.length; i++) {
pos = writeString(this.topics[i], topicStrLength[i], byteStream, pos);
byteStream[pos++] = this.requestedQos[i];
}
break;
case MESSAGE_TYPE.UNSUBSCRIBE:
// UNSUBSCRIBE has a list of topic strings
for (var i=0; i<this.topics.length; i++)
pos = writeString(this.topics[i], topicStrLength[i], byteStream, pos);
break;
// Do nothing.
}
return buffer;
};
function decodeMessage(input,pos) {
var startingPos = pos;
var first = input[pos];
var type = first >> 4;
var messageInfo = first &= 0x0f;
pos += 1;
// Decode the remaining length (MBI format)
var digit;
var remLength = 0;
var multiplier = 1;
do {
if (pos == input.length) {
return [null,startingPos];
}
digit = input[pos++];
remLength += ((digit & 0x7F) * multiplier);
multiplier *= 128;
} while ((digit & 0x80) !== 0);
var endPos = pos+remLength;
if (endPos > input.length) {
return [null,startingPos];
}
var wireMessage = new WireMessage(type);
switch(type) {
case MESSAGE_TYPE.CONNACK:
var connectAcknowledgeFlags = input[pos++];
if (connectAcknowledgeFlags & 0x01)
wireMessage.sessionPresent = true;
wireMessage.returnCode = input[pos++];
break;
case MESSAGE_TYPE.PUBLISH:
var qos = (messageInfo >> 1) & 0x03;
var len = readUint16(input, pos);
pos += 2;
var topicName = parseUTF8(input, pos, len);
pos += len;
// If QoS 1 or 2 there will be a messageIdentifier
if (qos > 0) {
wireMessage.messageIdentifier = readUint16(input, pos);
pos += 2;
}
var message = new Message(input.subarray(pos, endPos));
if ((messageInfo & 0x01) == 0x01)
message.retained = true;
if ((messageInfo & 0x08) == 0x08)
message.duplicate = true;
message.qos = qos;
message.destinationName = topicName;
wireMessage.payloadMessage = message;
break;
case MESSAGE_TYPE.PUBACK:
case MESSAGE_TYPE.PUBREC:
case MESSAGE_TYPE.PUBREL:
case MESSAGE_TYPE.PUBCOMP:
case MESSAGE_TYPE.UNSUBACK:
wireMessage.messageIdentifier = readUint16(input, pos);
break;
case MESSAGE_TYPE.SUBACK:
wireMessage.messageIdentifier = readUint16(input, pos);
pos += 2;
wireMessage.returnCode = input.subarray(pos, endPos);
break;
}
return [wireMessage,endPos];
}
function writeUint16(input, buffer, offset) {
buffer[offset++] = input >> 8; //MSB
buffer[offset++] = input % 256; //LSB
return offset;
}
function writeString(input, utf8Length, buffer, offset) {
offset = writeUint16(utf8Length, buffer, offset);
stringToUTF8(input, buffer, offset);
return offset + utf8Length;
}
function readUint16(buffer, offset) {
return 256*buffer[offset] + buffer[offset+1];
}
/**
* Encodes an MQTT Multi-Byte Integer
* @private
*/
function encodeMBI(number) {
var output = new Array(1);
var numBytes = 0;
do {
var digit = number % 128;
number = number >> 7;
if (number > 0) {
digit |= 0x80;
}
output[numBytes++] = digit;
} while ( (number > 0) && (numBytes<4) );
return output;
}
/**
* Takes a String and calculates its length in bytes when encoded in UTF8.
* @private
*/
function UTF8Length(input) {
var output = 0;
for (var i = 0; i<input.length; i++)
{
var charCode = input.charCodeAt(i);
if (charCode > 0x7FF)
{
// Surrogate pair means its a 4 byte character
if (0xD800 <= charCode && charCode <= 0xDBFF)
{
i++;
output++;
}
output +=3;
}
else if (charCode > 0x7F)
output +=2;
else
output++;
}
return output;
}
/**
* Takes a String and writes it into an array as UTF8 encoded bytes.
* @private
*/
function stringToUTF8(input, output, start) {
var pos = start;
for (var i = 0; i<input.length; i++) {
var charCode = input.charCodeAt(i);
// Check for a surrogate pair.
if (0xD800 <= charCode && charCode <= 0xDBFF) {
var lowCharCode = input.charCodeAt(++i);
if (isNaN(lowCharCode)) {
throw new Error(format(ERROR.MALFORMED_UNICODE, [charCode, lowCharCode]));
}
charCode = ((charCode - 0xD800)<<10) + (lowCharCode - 0xDC00) + 0x10000;
}
if (charCode <= 0x7F) {
output[pos++] = charCode;
} else if (charCode <= 0x7FF) {
output[pos++] = charCode>>6 & 0x1F | 0xC0;
output[pos++] = charCode & 0x3F | 0x80;
} else if (charCode <= 0xFFFF) {
output[pos++] = charCode>>12 & 0x0F | 0xE0;
output[pos++] = charCode>>6 & 0x3F | 0x80;
output[pos++] = charCode & 0x3F | 0x80;
} else {
output[pos++] = charCode>>18 & 0x07 | 0xF0;
output[pos++] = charCode>>12 & 0x3F | 0x80;
output[pos++] = charCode>>6 & 0x3F | 0x80;
output[pos++] = charCode & 0x3F | 0x80;
}
}
return output;
}
function parseUTF8(input, offset, length) {
var output = "";
var utf16;
var pos = offset;
while (pos < offset+length)
{
var byte1 = input[pos++];
if (byte1 < 128)
utf16 = byte1;
else
{
var byte2 = input[pos++]-128;
if (byte2 < 0)
throw new Error(format(ERROR.MALFORMED_UTF, [byte1.toString(16), byte2.toString(16),""]));
if (byte1 < 0xE0) // 2 byte character
utf16 = 64*(byte1-0xC0) + byte2;
else
{
var byte3 = input[pos++]-128;
if (byte3 < 0)
throw new Error(format(ERROR.MALFORMED_UTF, [byte1.toString(16), byte2.toString(16), byte3.toString(16)]));
if (byte1 < 0xF0) // 3 byte character
utf16 = 4096*(byte1-0xE0) + 64*byte2 + byte3;
else
{
var byte4 = input[pos++]-128;
if (byte4 < 0)
throw new Error(format(ERROR.MALFORMED_UTF, [byte1.toString(16), byte2.toString(16), byte3.toString(16), byte4.toString(16)]));
if (byte1 < 0xF8) // 4 byte character
utf16 = 262144*(byte1-0xF0) + 4096*byte2 + 64*byte3 + byte4;
else // longer encodings are not supported
throw new Error(format(ERROR.MALFORMED_UTF, [byte1.toString(16), byte2.toString(16), byte3.toString(16), byte4.toString(16)]));
}
}
}
if (utf16 > 0xFFFF) // 4 byte character - express as a surrogate pair
{
utf16 -= 0x10000;
output += String.fromCharCode(0xD800 + (utf16 >> 10)); // lead character
utf16 = 0xDC00 + (utf16 & 0x3FF); // trail character
}
output += String.fromCharCode(utf16);
}
return output;
}
/**
* Repeat keepalive requests, monitor responses.
* @ignore
*/
var Pinger = function(client, keepAliveInterval) {
this._client = client;
this._keepAliveInterval = keepAliveInterval*1000;
this.isReset = false;
var pingReq = new WireMessage(MESSAGE_TYPE.PINGREQ).encode();
var doTimeout = function (pinger) {
return function () {
return doPing.apply(pinger);
};
};
/** @ignore */
var doPing = function() {
if (!this.isReset) {
this._client._trace("Pinger.doPing", "Timed out");
this._client._disconnected( ERROR.PING_TIMEOUT.code , format(ERROR.PING_TIMEOUT));
} else {
this.isReset = false;
this._client._trace("Pinger.doPing", "send PINGREQ");
this._client.socket.send(pingReq);
this.timeout = setTimeout(doTimeout(this), this._keepAliveInterval);
}
};
this.reset = function() {
this.isReset = true;
clearTimeout(this.timeout);
if (this._keepAliveInterval > 0)
this.timeout = setTimeout(doTimeout(this), this._keepAliveInterval);
};
this.cancel = function() {
clearTimeout(this.timeout);
};
};
/**
* Monitor request completion.
* @ignore
*/
var Timeout = function(client, timeoutSeconds, action, args) {
if (!timeoutSeconds)
timeoutSeconds = 30;
var doTimeout = function (action, client, args) {
return function () {
return action.apply(client, args);
};
};
this.timeout = setTimeout(doTimeout(action, client, args), timeoutSeconds * 1000);
this.cancel = function() {
clearTimeout(this.timeout);
};
};
/**
* Internal implementation of the Websockets MQTT V3.1 client.
*
* @name Paho.ClientImpl @constructor
* @param {String} host the DNS nameof the webSocket host.
* @param {Number} port the port number for that host.
* @param {String} clientId the MQ client identifier.
*/
var ClientImpl = function (uri, host, port, path, clientId) {
// Check dependencies are satisfied in this browser.
if (!("WebSocket" in global && global.WebSocket !== null)) {
throw new Error(format(ERROR.UNSUPPORTED, ["WebSocket"]));
}
if (!("ArrayBuffer" in global && global.ArrayBuffer !== null)) {
throw new Error(format(ERROR.UNSUPPORTED, ["ArrayBuffer"]));
}
this._trace("Paho.Client", uri, host, port, path, clientId);
this.host = host;
this.port = port;
this.path = path;
this.uri = uri;
this.clientId = clientId;
this._wsuri = null;
// Local storagekeys are qualified with the following string.
// The conditional inclusion of path in the key is for backward
// compatibility to when the path was not configurable and assumed to
// be /mqtt
this._localKey=host+":"+port+(path!="/mqtt"?":"+path:"")+":"+clientId+":";
// Create private instance-only message queue
// Internal queue of messages to be sent, in sending order.
this._msg_queue = [];
this._buffered_msg_queue = [];
// Messages we have sent and are expecting a response for, indexed by their respective message ids.
this._sentMessages = {};
// Messages we have received and acknowleged and are expecting a confirm message for
// indexed by their respective message ids.
this._receivedMessages = {};
// Internal list of callbacks to be executed when messages
// have been successfully sent over web socket, e.g. disconnect
// when it doesn't have to wait for ACK, just message is dispatched.
this._notify_msg_sent = {};
// Unique identifier for SEND messages, incrementing
// counter as messages are sent.
this._message_identifier = 1;
// Used to determine the transmission sequence of stored sent messages.
this._sequence = 0;
// Load the local state, if any, from the saved version, only restore state relevant to this client.
for (var key in localStorage)
if ( key.indexOf("Sent:"+this._localKey) === 0 || key.indexOf("Received:"+this._localKey) === 0)
this.restore(key);
};
// Messaging Client public instance members.
ClientImpl.prototype.host = null;
ClientImpl.prototype.port = null;
ClientImpl.prototype.path = null;
ClientImpl.prototype.uri = null;
ClientImpl.prototype.clientId = null;
// Messaging Client private instance members.
ClientImpl.prototype.socket = null;
/* true once we have received an acknowledgement to a CONNECT packet. */
ClientImpl.prototype.connected = false;
/* The largest message identifier allowed, may not be larger than 2**16 but
* if set smaller reduces the maximum number of outbound messages allowed.
*/
ClientImpl.prototype.maxMessageIdentifier = 65536;
ClientImpl.prototype.connectOptions = null;
ClientImpl.prototype.hostIndex = null;
ClientImpl.prototype.onConnected = null;
ClientImpl.prototype.onConnectionLost = null;
ClientImpl.prototype.onMessageDelivered = null;
ClientImpl.prototype.onMessageArrived = null;
ClientImpl.prototype.traceFunction = null;
ClientImpl.prototype._msg_queue = null;
ClientImpl.prototype._buffered_msg_queue = null;
ClientImpl.prototype._connectTimeout = null;
/* The sendPinger monitors how long we allow before we send data to prove to the server that we are alive. */
ClientImpl.prototype.sendPinger = null;
/* The receivePinger monitors how long we allow before we require evidence that the server is alive. */
ClientImpl.prototype.receivePinger = null;
ClientImpl.prototype._reconnectInterval = 1; // Reconnect Delay, starts at 1 second
ClientImpl.prototype._reconnecting = false;
ClientImpl.prototype._reconnectTimeout = null;
ClientImpl.prototype.disconnectedPublishing = false;
ClientImpl.prototype.disconnectedBufferSize = 5000;
ClientImpl.prototype.receiveBuffer = null;
ClientImpl.prototype._traceBuffer = null;
ClientImpl.prototype._MAX_TRACE_ENTRIES = 100;
ClientImpl.prototype.connect = function (connectOptions) {
var connectOptionsMasked = this._traceMask(connectOptions, "password");
this._trace("Client.connect", connectOptionsMasked, this.socket, this.connected);
if (this.connected)
throw new Error(format(ERROR.INVALID_STATE, ["already connected"]));
if (this.socket)
throw new Error(format(ERROR.INVALID_STATE, ["already connected"]));
if (this._reconnecting) {
// connect() function is called while reconnect is in progress.
// Terminate the auto reconnect process to use new connect options.
this._reconnectTimeout.cancel();
this._reconnectTimeout = null;
this._reconnecting = false;
}
this.connectOptions = connectOptions;
this._reconnectInterval = 1;
this._reconnecting = false;
if (connectOptions.uris) {
this.hostIndex = 0;
this._doConnect(connectOptions.uris[0]);
} else {
this._doConnect(this.uri);
}
};
ClientImpl.prototype.subscribe = function (filter, subscribeOptions) {
this._trace("Client.subscribe", filter, subscribeOptions);
if (!this.connected)
throw new Error(format(ERROR.INVALID_STATE, ["not connected"]));
var wireMessage = new WireMessage(MESSAGE_TYPE.SUBSCRIBE);
wireMessage.topics = filter.constructor === Array ? filter : [filter];
if (subscribeOptions.qos === undefined)
subscribeOptions.qos = 0;
wireMessage.requestedQos = [];
for (var i = 0; i < wireMessage.topics.length; i++)
wireMessage.requestedQos[i] = subscribeOptions.qos;
if (subscribeOptions.onSuccess) {
wireMessage.onSuccess = function(grantedQos) {subscribeOptions.onSuccess({invocationContext:subscribeOptions.invocationContext,grantedQos:grantedQos});};
}
if (subscribeOptions.onFailure) {
wireMessage.onFailure = function(errorCode) {subscribeOptions.onFailure({invocationContext:subscribeOptions.invocationContext,errorCode:errorCode, errorMessage:format(errorCode)});};
}
if (subscribeOptions.timeout) {
wireMessage.timeOut = new Timeout(this, subscribeOptions.timeout, subscribeOptions.onFailure,
[{invocationContext:subscribeOptions.invocationContext,
errorCode:ERROR.SUBSCRIBE_TIMEOUT.code,
errorMessage:format(ERROR.SUBSCRIBE_TIMEOUT)}]);
}
// All subscriptions return a SUBACK.
this._requires_ack(wireMessage);
this._schedule_message(wireMessage);
};
/** @ignore */
ClientImpl.prototype.unsubscribe = function(filter, unsubscribeOptions) {
this._trace("Client.unsubscribe", filter, unsubscribeOptions);
if (!this.connected)
throw new Error(format(ERROR.INVALID_STATE, ["not connected"]));
var wireMessage = new WireMessage(MESSAGE_TYPE.UNSUBSCRIBE);
wireMessage.topics = filter.constructor === Array ? filter : [filter];
if (unsubscribeOptions.onSuccess) {
wireMessage.callback = function() {unsubscribeOptions.onSuccess({invocationContext:unsubscribeOptions.invocationContext});};
}
if (unsubscribeOptions.timeout) {
wireMessage.timeOut = new Timeout(this, unsubscribeOptions.timeout, unsubscribeOptions.onFailure,
[{invocationContext:unsubscribeOptions.invocationContext,
errorCode:ERROR.UNSUBSCRIBE_TIMEOUT.code,
errorMessage:format(ERROR.UNSUBSCRIBE_TIMEOUT)}]);
}
// All unsubscribes return a SUBACK.
this._requires_ack(wireMessage);
this._schedule_message(wireMessage);
};
ClientImpl.prototype.send = function (message) {
this._trace("Client.send", message);
var wireMessage = new WireMessage(MESSAGE_TYPE.PUBLISH);
wireMessage.payloadMessage = message;
if (this.connected) {
// Mark qos 1 & 2 message as "ACK required"
// For qos 0 message, invoke onMessageDelivered callback if there is one.
// Then schedule the message.
if (message.qos > 0) {
this._requires_ack(wireMessage);
} else if (this.onMessageDelivered) {
this._notify_msg_sent[wireMessage] = this.onMessageDelivered(wireMessage.payloadMessage);
}
this._schedule_message(wireMessage);
} else {
// Currently disconnected, will not schedule this message
// Check if reconnecting is in progress and disconnected publish is enabled.
if (this._reconnecting && this.disconnectedPublishing) {
// Check the limit which include the "required ACK" messages
var messageCount = Object.keys(this._sentMessages).length + this._buffered_msg_queue.length;
if (messageCount > this.disconnectedBufferSize) {
throw new Error(format(ERROR.BUFFER_FULL, [this.disconnectedBufferSize]));
} else {
if (message.qos > 0) {
// Mark this message as "ACK required"
this._requires_ack(wireMessage);
} else {
wireMessage.sequence = ++this._sequence;
// Add messages in fifo order to array, by adding to start
this._buffered_msg_queue.unshift(wireMessage);
}
}
} else {
throw new Error(format(ERROR.INVALID_STATE, ["not connected"]));
}
}
};
ClientImpl.prototype.disconnect = function () {
this._trace("Client.disconnect");
if (this._reconnecting) {
// disconnect() function is called while reconnect is in progress.
// Terminate the auto reconnect process.
this._reconnectTimeout.cancel();
this._reconnectTimeout = null;
this._reconnecting = false;
}
if (!this.socket)
throw new Error(format(ERROR.INVALID_STATE, ["not connecting or connected"]));
var wireMessage = new WireMessage(MESSAGE_TYPE.DISCONNECT);
// Run the disconnected call back as soon as the message has been sent,
// in case of a failure later on in the disconnect processing.
// as a consequence, the _disconected call back may be run several times.
this._notify_msg_sent[wireMessage] = scope(this._disconnected, this);
this._schedule_message(wireMessage);
};
ClientImpl.prototype.getTraceLog = function () {
if ( this._traceBuffer !== null ) {
this._trace("Client.getTraceLog", new Date());
this._trace("Client.getTraceLog in flight messages", this._sentMessages.length);
for (var key in this._sentMessages)
this._trace("_sentMessages ",key, this._sentMessages[key]);
for (var key in this._receivedMessages)
this._trace("_receivedMessages ",key, this._receivedMessages[key]);
return this._traceBuffer;
}
};
ClientImpl.prototype.startTrace = function () {
if ( this._traceBuffer === null ) {
this._traceBuffer = [];
}
this._trace("Client.startTrace", new Date(), version);
};
ClientImpl.prototype.stopTrace = function () {
delete this._traceBuffer;
};
ClientImpl.prototype._doConnect = function (wsurl) {
// When the socket is open, this client will send the CONNECT WireMessage using the saved parameters.
if (this.connectOptions.useSSL) {
var uriParts = wsurl.split(":");
uriParts[0] = "wss";
wsurl = uriParts.join(":");
}
this._wsuri = wsurl;
this.connected = false;
if (this.connectOptions.mqttVersion < 4) {
this.socket = new WebSocket(wsurl, ["mqttv3.1"]);
} else {
this.socket = new WebSocket(wsurl, ["mqtt"]);
}
this.socket.binaryType = "arraybuffer";
this.socket.onopen = scope(this._on_socket_open, this);
this.socket.onmessage = scope(this._on_socket_message, this);
this.socket.onerror = scope(this._on_socket_error, this);
this.socket.onclose = scope(this._on_socket_close, this);
this.sendPinger = new Pinger(this, this.connectOptions.keepAliveInterval);
this.receivePinger = new Pinger(this, this.connectOptions.keepAliveInterval);
if (this._connectTimeout) {
this._connectTimeout.cancel();
this._connectTimeout = null;
}
this._connectTimeout = new Timeout(this, this.connectOptions.timeout, this._disconnected, [ERROR.CONNECT_TIMEOUT.code, format(ERROR.CONNECT_TIMEOUT)]);
};
// Schedule a new message to be sent over the WebSockets
// connection. CONNECT messages cause WebSocket connection
// to be started. All other messages are queued internally
// until this has happened. When WS connection starts, process
// all outstanding messages.
ClientImpl.prototype._schedule_message = function (message) {
// Add messages in fifo order to array, by adding to start
this._msg_queue.unshift(message);
// Process outstanding messages in the queue if we have an open socket, and have received CONNACK.
if (this.connected) {
this._process_queue();
}
};
ClientImpl.prototype.store = function(prefix, wireMessage) {
var storedMessage = {type:wireMessage.type, messageIdentifier:wireMessage.messageIdentifier, version:1};
switch(wireMessage.type) {
case MESSAGE_TYPE.PUBLISH:
if(wireMessage.pubRecReceived)
storedMessage.pubRecReceived = true;
// Convert the payload to a hex string.
storedMessage.payloadMessage = {};
var hex = "";
var messageBytes = wireMessage.payloadMessage.payloadBytes;
for (var i=0; i<messageBytes.length; i++) {
if (messageBytes[i] <= 0xF)
hex = hex+"0"+messageBytes[i].toString(16);
else
hex = hex+messageBytes[i].toString(16);
}
storedMessage.payloadMessage.payloadHex = hex;
storedMessage.payloadMessage.qos = wireMessage.payloadMessage.qos;
storedMessage.payloadMessage.destinationName = wireMessage.payloadMessage.destinationName;
if (wireMessage.payloadMessage.duplicate)
storedMessage.payloadMessage.duplicate = true;
if (wireMessage.payloadMessage.retained)
storedMessage.payloadMessage.retained = true;
// Add a sequence number to sent messages.
if ( prefix.indexOf("Sent:") === 0 ) {
if ( wireMessage.sequence === undefined )
wireMessage.sequence = ++this._sequence;
storedMessage.sequence = wireMessage.sequence;
}
break;
default:
throw Error(format(ERROR.INVALID_STORED_DATA, [prefix+this._localKey+wireMessage.messageIdentifier, storedMessage]));
}
localStorage.setItem(prefix+this._localKey+wireMessage.messageIdentifier, JSON.stringify(storedMessage));
};
ClientImpl.prototype.restore = function(key) {
var value = localStorage.getItem(key);
var storedMessage = JSON.parse(value);
var wireMessage = new WireMessage(storedMessage.type, storedMessage);
switch(storedMessage.type) {
case MESSAGE_TYPE.PUBLISH:
// Replace the payload message with a Message object.
var hex = storedMessage.payloadMessage.payloadHex;
var buffer = new ArrayBuffer((hex.length)/2);
var byteStream = new Uint8Array(buffer);
var i = 0;
while (hex.length >= 2) {
var x = parseInt(hex.substring(0, 2), 16);
hex = hex.substring(2, hex.length);
byteStream[i++] = x;
}
var payloadMessage = new Message(byteStream);
payloadMessage.qos = storedMessage.payloadMessage.qos;
payloadMessage.destinationName = storedMessage.payloadMessage.destinationName;
if (storedMessage.payloadMessage.duplicate)
payloadMessage.duplicate = true;
if (storedMessage.payloadMessage.retained)
payloadMessage.retained = true;
wireMessage.payloadMessage = payloadMessage;
break;
default:
throw Error(format(ERROR.INVALID_STORED_DATA, [key, value]));
}
if (key.indexOf("Sent:"+this._localKey) === 0) {
wireMessage.payloadMessage.duplicate = true;
this._sentMessages[wireMessage.messageIdentifier] = wireMessage;
} else if (key.indexOf("Received:"+this._localKey) === 0) {
this._receivedMessages[wireMessage.messageIdentifier] = wireMessage;
}
};
ClientImpl.prototype._process_queue = function () {
var message = null;
// Send all queued messages down socket connection
while ((message = this._msg_queue.pop())) {
this._socket_send(message);
// Notify listeners that message was successfully sent
if (this._notify_msg_sent[message]) {
this._notify_msg_sent[message]();
delete this._notify_msg_sent[message];
}
}
};
/**
* Expect an ACK response for this message. Add message to the set of in progress
* messages and set an unused identifier in this message.
* @ignore
*/
ClientImpl.prototype._requires_ack = function (wireMessage) {
var messageCount = Object.keys(this._sentMessages).length;
if (messageCount > this.maxMessageIdentifier)
throw Error ("Too many messages:"+messageCount);
while(this._sentMessages[this._message_identifier] !== undefined) {
this._message_identifier++;
}
wireMessage.messageIdentifier = this._message_identifier;
this._sentMessages[wireMessage.messageIdentifier] = wireMessage;
if (wireMessage.type === MESSAGE_TYPE.PUBLISH) {
this.store("Sent:", wireMessage);
}
if (this._message_identifier === this.maxMessageIdentifier) {
this._message_identifier = 1;
}
};
/**
* Called when the underlying websocket has been opened.
* @ignore
*/
ClientImpl.prototype._on_socket_open = function () {
// Create the CONNECT message object.
var wireMessage = new WireMessage(MESSAGE_TYPE.CONNECT, this.connectOptions);
wireMessage.clientId = this.clientId;
this._socket_send(wireMessage);
};
/**
* Called when the underlying websocket has received a complete packet.
* @ignore
*/
ClientImpl.prototype._on_socket_message = function (event) {
this._trace("Client._on_socket_message", event.data);
var messages = this._deframeMessages(event.data);
for (var i = 0; i < messages.length; i+=1) {
this._handleMessage(messages[i]);
}
};
ClientImpl.prototype._deframeMessages = function(data) {
var byteArray = new Uint8Array(data);
var messages = [];
if (this.receiveBuffer) {
var newData = new Uint8Array(this.receiveBuffer.length+byteArray.length);
newData.set(this.receiveBuffer);
newData.set(byteArray,this.receiveBuffer.length);
byteArray = newData;
delete this.receiveBuffer;
}
try {
var offset = 0;
while(offset < byteArray.length) {
var result = decodeMessage(byteArray,offset);
var wireMessage = result[0];
offset = result[1];
if (wireMessage !== null) {
messages.push(wireMessage);
} else {
break;
}
}
if (offset < byteArray.length) {
this.receiveBuffer = byteArray.subarray(offset);
}
} catch (error) {
var errorStack = ((error.hasOwnProperty("stack") == "undefined") ? error.stack.toString() : "No Error Stack Available");
this._disconnected(ERROR.INTERNAL_ERROR.code , format(ERROR.INTERNAL_ERROR, [error.message,errorStack]));
return;
}
return messages;
};
ClientImpl.prototype._handleMessage = function(w