}, function(cb) {
if ((typeof that.opts.secure === 'undefined' || that.opts.allowNonSecure) && !that.opts.onlyHttp) {
var server = mqtt.createServer(serveWrap);
that.servers.push(server);
server.listen(that.opts.port, that.opts.host, cb);
} else {
cb();
}
}, function(cb) {
function Construct( sandbox, options ) {
_sandbox = sandbox;
logger.debug('Start module Embedded');
var port = options.port || 1883;
mqtt.createServer(function(client) {
var self = this;
logger.debug('MQTT Listening on port', port);
if (!self.clients) self.clients = {};
client.on('connect', function(packet) {
console.log('MQTT Client connected');
client.connack({returnCode: 0});
client.id = packet.clientId;
self.clients[client.id] = client;
});
client.on('publish', function(packet) {
console.log('MQTT Client publish', packet);
for (var k in self.clients) {
self.clients[k].publish({topic: packet.topic, payload: packet.payload});
}
});
client.on('subscribe', function(packet) {
var granted = [];
for (var i = 0; i < packet.subscriptions.length; i++) {
granted.push(packet.subscriptions[i].qos);
}
client.suback({granted: granted, messageId: packet.messageId});
});
client.on('pingreq', function(packet) {
client.pingresp();
});
client.on('disconnect', function(packet) {
client.stream.end();
});
client.on('close', function(err) {
delete self.clients[client.id];
});
client.on('error', function(err) {
client.stream.end();
console.log('error!');
});
}).listen( port );
}
/**
* Create a minimal MQTT broker based on the given specification ({@tutorial Service}).
* @param serviceSpec {object} {@tutorial service-spec-query}
* @constructor
*/
function MQTTService(serviceSpec) {
"use strict";
var self = this;
this.service = mqtt.createServer(function(client) {
client.on('connect', function(packet) {
if (self.receivedMsgHandler) {
self.receivedMsgHandler(client, packet, {event: 'connect'});
}
});
client.on('publish', function(packet) {
if (self.receivedMsgHandler) {
self.receivedMsgHandler(client, packet, {event: 'publish'});
}
});
client.on('subscribe', function(packet) {
if (self.receivedMsgHandler) {
self.receivedMsgHandler(client, packet, {event: 'subscribe'});
}
});
client.on('pingreq', function(packet) {
if (self.receivedMsgHandler) {
self.receivedMsgHandler(client, packet, {event: 'pingreq'});
}
});
client.on('disconnect', function(packet) {
if (self.receivedMsgHandler) {
self.receivedMsgHandler(client, packet, {event: 'disconnect'});
}
});
client.on('close', function(err) {
if (self.receivedMsgHandler) {
self.receivedMsgHandler(client, err, {event: 'close'});
}
});
client.on('error', function(err) {
if (self.receivedMsgHandler) {
self.receivedMsgHandler(client, err, {event: 'error'});
}
});
});
this.service.listen(serviceSpec.port);
}
function start(port){
if (!port) {port = 1883};
mqtt.createServer(function(client) {
client.on('connect', function(packet) {
registerUser(client,packet);
client.connack({returnCode: 0});
pushOfflineMessage(client);
event.emit('connect',client,packet);
});
client.on('publish', function(packet) {
onPublish(packet);
event.emit('publish',client,packet);
});
client.on('subscribe', function(packet) {
var granted = [];
for (var i = 0; i < packet.subscriptions.length; i++) {
granted.push(packet.subscriptions[i].qos);
}
client.suback({granted: granted, messageId: packet.messageId});
event.emit('subscribe',client,packet);
});
client.on('pingreq', function(packet) {
client.pingresp();
client.lastPing = new Date().getTime()/1000;
event.emit('pingreq',client,packet);
});
client.on('disconnect', function(packet) {
client.stream.end();
event.emit('disconnect',client,packet);
});
client.on('close', function(err) {
delete onlineUser[client.id];
event.emit('close',client,err);
});
client.on('error', function(err) {
client.stream.end();
event.emit('error',client,err);
});
}).listen(port);
//开始轮询，定时清理离线用户
setTimeout(cleanOfflineUser,1000);
}
ChatServer.prototype.start = function (opt_config) {
var self = this;
var port = (opt_config && opt_config.port) || 1883;
self.mqttServer_ = mqtt.createServer(function (client) {
client.on('connect', function(packet) {
console.log('on connect!');
self.onConnect.call(self, client, packet);
});
client.on('publish', function(packet) {
console.log('on publish!');
self.onPublish.call(self, client, packet);
});
client.on('subscribe', function(packet) {
console.log('on subscribe!');
self.onSubscribe.call(self, client, packet);
});
client.on('unsubscribe', function(packet) {
console.log('on unsubscribe!');
self.onUnsubscribe.call(self, client, packet);
});
client.on('pingreq', function(packet) {
self.onPingreq.call(self, client, packet);
});
client.on('disconnect', function(packet) {
console.log('on disconnect!');
self.onDisconnect.call(self, client, packet);
});
client.on('close', function(err) {
console.log('on close!');
self.onClose.call(self, client, err);
});
client.on('error', function(err) {
console.log('on error!');
self.onError.call(self, client, err);
});
});
self.mqttServer_.listen(port);
};
client.on('ready', function() {
var server;
if (startP) return;
startP = true;
options.logger.info('redis started');
server = (!!options.keyPath) ? mqtt.createSecureServer(options.keyPath, options.crtPath, listener)
: mqtt.createServer(listener);
server.on('error', function(err) {
options.logger.error('server', { event: 'error', diagnostic: err.message });
}).listen(options.mqttPort, function() {
options.logger.info('MQTT broker listening on mqtts://*:' + this.address().port);
});
}).on('connect', function() {
Connector.prototype.start = function(cb) {
var self = this;
this.mqttServer = mqtt.createServer();
this.mqttServer.on('client', function(client) {
client.on('error', function(err) {
client.stream.destroy();
});
client.on('close', function() {
client.stream.destroy();
});
client.on('disconnect', function(packet) {
client.stream.destroy();
});
client.on('connect', function(packet) {
client.connack({returnCode: 0});
var mqttsocket = new MQTTSocket(curId++, client, self.adaptor);
self.emit('connection', mqttsocket);
});
});
this.mqttServer.listen(this.port);
process.nextTick(cb);
};
(function () {
'use strict';
var expressPort = 8080;
var expressIPAddress = '0.0.0.0';
var mqttPort = 1883;
var mqttIPAddress = '0.0.0.0';
var mongoDBUrl = 'mongodb://127.0.0.1:27017/IsOccupied';
var mqtt = require('mqtt');
var chalk = require('chalk');
var express = require("express");
var bodyParser = require('body-parser');
var path = require("path");
var expressApp = express();
var http = require('http').Server(expressApp);
var webSockets = require('socket.io')(http);
var mongoClient = require('mongodb').MongoClient;
var events = require('events');
var nodemailer = require('nodemailer');
var smtpTransport = require('nodemailer-smtp-transport');
var config = require('./config');
var db = {};
// --------------------------------
// SMTP
var transporter = nodemailer.createTransport(smtpTransport(config.nodemailer));
// --------------------------------
// MQTT
var mqttBroker = mqtt.createServer(function (mqttClient) {
mqttClient.on('connect', function (packet) {
try {
mqttClient.id = packet.clientId;
// Send a response ACK
mqttClient.connack({returnCode: 0});
}
catch (ex) {
errorHandler(ex);
}
});
mqttClient.on('publish', function (packet) {
try {
var data = JSON.parse(packet.payload);
if (data.occupied == undefined) {
// Bad input, ignoring
return;
}
console.log(chalk.bold.cyan('INCOMING'), mqttClient.id, '->', chalk.cyan(packet.payload));
onDeviceOccupationUpdate(mqttClient.id, data.occupied)
}
catch (ex) {
errorHandler(ex);
}
});
});
// --------------------------------
// Mongo DB Init
mongoClient.connect(mongoDBUrl, function (err, mongoContext) {
if (err) {
console.error(chalk.red('Could not connect to MongoDB!'));
console.log(chalk.red(err));
}
else {
console.log(chalk.bold.green('CONNECTED'), 'mongodb', chalk.cyan(mongoDBUrl));
mongoContext.createCollection('devices', errorHandler);
db.devices = mongoContext.collection('devices');
}
});
// --------------------------------
// Express JS
// Parse application/json
expressApp.use(bodyParser.json())
// Static files
expressApp.use('/static/', express.static(path.join(__dirname, 'static')));
// REST API
expressApp.get("/api/devices/history/", function (request, response) {
db.devices.find({history: {$exists: true}}, {_id: 1, history: 1,}).toArray(function (err, history) {
response.json(history);
});
});
expressApp.get("/api/devices/", function (request, response) {
db.devices.find({}, {_id: 1, occupied: 1, occupiedSince: 1, lastActive: 1}).toArray(function (err, devices) {
response.json(devices);
});
});
expressApp.get("/api/devices/:id", function (request, response) {
var deviceId = request.params.id;
db.devices.findOne({_id: deviceId}, {
_id: 1,
occupied: 1,
occupiedSince: 1,
lastActive: 1
}, function (err, device) {
response.json(device);
});
});
expressApp.get("/api/devices/:id/history", function (request, response) {
var deviceId = request.params.id;
db.devices.findOne({_id: deviceId}, {
_id: 1,
history: 1
}, function (err, device) {
var history = [];
if (device && device.history) {
history = device.history;
}
response.json(history);
});
});
expressApp.post("/api/devices/:id/subscribe", function (request, response) {
var deviceId = request.params.id;
var body = request.body;
if (!body.email) {
return response.json({error: 'email must be provided'});
}
if (!validateEmail(body.email)) {
return response.json({error: 'invalid email provided'});
}
// Persist in database
db.devices.update(
{_id: deviceId},
{
$addToSet: {
subscribers: body.email
}
},
{},
function (err, rowsAffected) {
response.json({success: new Boolean(rowsAffected)});
});
});
// Root Page
expressApp.get("/", function (request, response) {
response.sendFile(path.join(__dirname, 'static', 'index.html'));
});
// --------------------------------
// Listen
http.listen(expressPort, expressIPAddress);
mqttBroker.listen(mqttPort, mqttIPAddress);
console.log(chalk.bold.yellow('LISTENING'), 'express', chalk.cyan(expressIPAddress), chalk.cyan(expressPort));
console.log(chalk.bold.yellow('LISTENING'), 'mqtt', chalk.cyan(mqttIPAddress), chalk.cyan(mqttPort));
// --------------------------------
// Error Handlers
function errorHandler(error) {
if (error) {
console.log(chalk.bold.red('ERROR'), error);
}
}
process.on('uncaughtException', function (err) {
// Ignored Purposely (mqtt client disconnection can cause ECONNRESET)
// so this type of unhandled errors go here instead of crashing the process
});
// -----------------------
// TODO export to different module:
function onDeviceOccupationUpdate(deviceId, occupied) {
var now = new Date();
db.devices.findOne({_id: deviceId},
function (err, device) {
var deviceStateChanged = true;
if (device) {
deviceStateChanged = device.occupied != occupied;
}
else {
device = {
occupiedSince: now
}
}
var update = {
occupied: occupied,
lastActive: now
};
if (occupied) {
update.occupiedSince = now;
}
// Persist in database
db.devices.update(
{_id: deviceId},
{
$set: update
},
{upsert: true},
errorHandler);
if (deviceStateChanged) {
// PUB/SUB via web sockets
var message = {
_id: deviceId,
lastActive: now,
occupied: occupied,
occupiedSince: device.occupiedSince
};
// Notify all subscribers
webSockets.emit('devices:update', message);
sendNotificationMail(device);
// Save history record
if (!occupied) {
var duration = now.getTime() - device.occupiedSince.getTime();
if (duration) {
// Persist in database
db.devices.update(
{_id: deviceId},
{
$addToSet: {
history: {
begin: device.occupiedSince,
end: now,
duration: duration
}
}
},
{},
errorHandler);
}
}
}
});
}
function validateEmail(email) {
var re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
return re.test(email);
}
function sendNotificationMail(device) {
// TODO remove me l8er
return;
if (!device.subscribers) {
return;
}
var to = '';
device.subscribers.forEach(function (subsciber) {
if (!to) {
to += ', ';
}
to += subsciber;
});
// setup e-mail data with unicode symbols
var mailOptions = {
from: '*****@*****.**', // sender address
to: to, // list of receivers
subject: device._id + ' is unoccupied', // Subject line
text: device._id + ' is unoccupied', // plaintext body
html: '<b>' + device._id + 'is unoccupied ✔</b>' // html body
};
// send mail with defined transport object
transporter.sendMail(mailOptions, function (error, info) {
if (error) {
console.log(error);
} else {
console.log('Message sent: ' + info.response);
}
});
}
})();
exports.init = function(conf, logger, onMessage, deviceId) {
var mqttServerPort = conf.listeners.mqtt_port || 1883;
var filename = conf.token_file || "token.json";
var fullFilename = path.join(__dirname, '../data/' + filename);
var secret = { };
if (fs.existsSync(fullFilename)) {
secret = common.readFileToJson(fullFilename);
} else {
//consider from system folder /usr/share/iotkit-agent/certs
fullFilename = '/usr/share/iotkit-agent/data/' + filename;
secret = common.readFileToJson(fullFilename);
}
var metric_topic = conf.connector.mqtt.topic.metric_topic || "server/metric/{accountid}/{deviceid}";
var tlsArgs = { };
var verifyCertKeyPath = conf.connector.mqtt.key || './certs/client.key';
if (fs.existsSync(verifyCertKeyPath)) {
tlsArgs = {
keyPath: conf.connector.mqtt.key || './certs/client.key',
certPath: conf.connector.mqtt.crt || './certs/client.crt',
keepalive: 59000
};
} else {
// load from /usr/share
tlsArgs = {
keyPath: '/usr/share/iotkit-agent/certs/enableiot_agent.key',
certPath: '/usr/share/iotkit-agent/certs/enableiot_agent.crt',
keepalive: 59000
};
}
var mqttServer = mqtt.createServer(function(client) {
client.on('connect', function(packet) {
client.connack({returnCode: 0});
client.id = packet.clientId;
logger.debug('MQTT Client connected: ', packet.clientId);
});
client.on('publish', function(packet) {
logger.debug('MQTT Topic: %s Payload: %s', packet.topic, packet.payload);
try {
onMessage(JSON.parse(packet.payload));
} catch (ex) {
logger.error('MQTT Error on message: %s', ex);
}
});
client.on('subscribe', function(packet) {
try {
// create a new client object to the new online broker
// subscribe
var newclient;
var topic = packet.subscriptions[0].topic;
if(conf.connector.mqtt.secure){
newclient = mqtt.createSecureClient(conf.connector.mqtt.port, conf.connector.mqtt.host, tlsArgs);
} else {
newclient = mqtt.createClient(conf.connector.mqtt.port, conf.connector.mqtt.host);
}
if(topic === 'data'){
newclient.subscribe(buildPath(metric_topic, [secret.accountId, deviceId]));
logger.info('Subscribed to topic:' + buildPath(metric_topic, [secret.accountId, deviceId]));
} else {
newclient.subscribe(buildPath(metric_topic, [secret.accountId, deviceId]) + '/' + topic);
logger.info('Subscribing to topic:' + buildPath(metric_topic, [secret.accountId, deviceId]) + '/' + topic);
}
newclient.on('message', function (topic, message) {
logger.info('Received a message on subscribed topic: ' + topic);
client.publish({"topic": topic, "payload": message});
});
} catch (ex) {
logger.error('Error on message: %s', ex.message);
logger.error(ex.stack);
}
});
client.on('pingreq', function() {
client.pingresp();
});
client.on('disconnect', function() {
client.stream.end();
});
client.on('error', function(err) {
//client.stream.end();
logger.error('MQTT Error: ', err);
});
}).listen(mqttServerPort);
logger.info("MQTT listener started on port: ", mqttServerPort);
return mqttServer;
};
mqtt.createServer(function(client) {
var self = this;
if (!self.clients) self.clients = {};
client.on('connect', function(packet) {
self.clients[packet.clientId] = client;
client.id = packet.clientId;
console.log("CONNECT: client id: " + client.id);
client.subscriptions = [];
client.connack({returnCode: 0});
});
client.on('subscribe', function(packet) {
var granted = [];
console.log("SUBSCRIBE(%s): %j", client.id, packet);
for (var i = 0; i < packet.subscriptions.length; i++) {
var qos = packet.subscriptions[i].qos
, topic = packet.subscriptions[i].topic
, reg = new RegExp(topic.replace('$', '\\$').replace('+', '[^\/]+').replace('#', '.+') + '$');
granted.push(qos);
client.subscriptions.push(reg);
}
client.suback({messageId: packet.messageId, granted: granted});
});
client.on('publish', function(packet) {
console.log("PUBLISH(%s): %j", client.id, packet);
for (var k in self.clients) {
var c = self.clients[k]
, publish = false;
for (var i = 0; i < c.subscriptions.length; i++) {
var s = c.subscriptions[i];
if (s.test(packet.topic)) {
publish = true;
}
}
if (publish) {
c.publish({topic: packet.topic, payload: packet.payload});
}
}
});
client.on('pingreq', function(packet) {
console.log('PINGREQ(%s)', client.id);
client.pingresp();
});
client.on('disconnect', function(packet) {
client.stream.end();
});
client.on('close', function(packet) {
delete self.clients[client.id];
});
client.on('error', function(e) {
client.stream.end();
console.log(e);
});
}).listen(1883);
mqtt.createServer(function(client) {
var self = this;
if (!self.clients) self.clients = {};
client.on('connect', function(packet) {
client.connack({returnCode: 0});
client.id = packet.clientId;
self.clients[client.id] = client;
});
client.on('publish', function(packet) {
console.log( packet.topic + ' say: ' + packet.payload);
for (var k in self.clients) {
self.clients[k].publish({topic: packet.topic, payload: packet.payload});
}
});
client.on('subscribe', function(packet) {
var granted = [];
for (var i = 0; i < packet.subscriptions.length; i++) {
granted.push(packet.subscriptions[i].qos);
}
client.suback({granted: granted, messageId: packet.messageId});
});
client.on('pingreq', function(packet) {
client.pingresp();
});
client.on('disconnect', function(packet) {
client.stream.end();
});
client.on('close', function(err) {
delete self.clients[client.id];
});
client.on('error', function(err) {
console.log('error!', err);
if (!self.clients[client.id]) return;
delete self.clients[client.id];
client.stream.end();
});
}).listen(1883);
mqtt.createServer(function(client) {
var self = this;
if (!self.clients) self.clients = {};
client.on('connect', function(packet) {
client.connack({returnCode: 0});
client.id = packet.clientId;
console.log("CONNECT(%s): %j", client.id, packet);
self.clients[client.id] = client;
});
client.on('publish', function(packet) {
for (var k in self.clients) {
console.log(k);
self.clients[k].publish({topic: packet.topic, payload: packet.payload});
}
});
client.on('subscribe', function(packet) {
console.log("SUBSCRIBE(%s): %j", client.id, packet);
var granted = [];
for (var i = 0; i < packet.subscriptions.length; i++) {
granted.push(packet.subscriptions[i].qos);
}
client.suback({granted: granted, messageId: packet.messageId});
});
client.on('pingreq', function(packet) {
console.log('PINGREQ(%s)', client.id);
client.pingresp();
});
client.on('disconnect', function(packet) {
client.stream.end();
});
client.on('close', function(err) {
delete self.clients[client.id];
});
client.on('error', function(err) {
client.stream.end();
console.dir(err);
});
}).listen(process.argv[2] || 1883);
function(cb) {
that.server = mqtt.createServer(serveWrap);
that.server.listen(that.opts.port, cb);
}, function(cb) {
define(['sandbox'],function(sandbox)
{
mqtt.createServer(function(client) {
var self = this;
if (!self.clients) self.clients = {};
client.on('connect', function(packet) {
client.connack({returnCode: 0});
client.id = packet.clientId;
sandbox.log(client.id, 'connect');
self.clients[client.id] = client;
});
client.on('publish', function(packet) {
// @todo check if packet counts specific destination host and only send event to that host
sandbox.log(packet.topic + ' -> ' + client.id + ' ' + packet.payload, 'publish');
// emit mqtt event in local node app
// @todo auto decode if payload is json
var e = new NetworkEvent( packet.payload );
e.setTopic( packet.topic );
sandbox.emit(packet.topic, e);
for (var k in self.clients) {
self.clients[k].publish({topic: packet.topic, payload: packet.payload});
}
});
client.on('subscribe', function(packet) {
sandbox.log(client.id + ' ' + packet.subscriptions[0].topic, 'subscribe');
var granted = [];
for (var i = 0; i < packet.subscriptions.length; i++) {
granted.push(packet.subscriptions[i].qos);
}
client.suback({granted: granted, messageId: packet.messageId});
});
client.on('pingreq', function(packet) {
sandbox.log(client.id, 'ping');
client.pingresp();
});
client.on('disconnect', function(packet) {
client.stream.end();
});
client.on('close', function(err) {
delete self.clients[client.id];
});
client.on('error', function(err) {
client.stream.end();
sandbox.log('error!', 'error');
});
}).listen(sandbox.getConfig().mqtt.port, function() {
sandbox.log('Started MQTT server at localhost:' + sandbox.getConfig().mqtt.port);
});
var module = {
name: "mqtt-server",
init: function() {
},
log: function( message ) {
var app = "[" + this.name + "]";
sandbox.log(app.toString().grey + " " + message);
}
};
module.log('test');
return module;
});
var server = mqtt.createServer(function(client) {
var self = this;
self.clients = self.clients || {};
client.on('connect', function(packet) {
logger.info('connection attempt: (punter: %s, uname: %s, pwd: %s)',
packet.clientId, packet.username, packet.password);
var punter = config.punters[packet.username];
var found = punter && punter.sites[packet.clientId];
if (!found || punter.getPassword() !== packet.password) {
logger.info('connection rejected');
client.connack({returnCode: 5});
} else {
client.connack({returnCode: 0});
// namespace hack to get unique client id:
// based on the packet's username being the *punter* name
// and the packet's clientId being the *site* name
client.id = packet.username + "_" + packet.clientId;
client.username = packet.username;
client.password = packet.password;
self.clients[client.id] = client;
logger.info('Added client %s to client list', client.id);
}
});
client.on('publish', function(packet) {
logger.info("Incoming data: %s", packet.payload);
if (!utils.verifyData(packet.topic, packet.payload)) {
return logger.error("OH NO! Data verification failed!: %s -- %s" +
"server checksum: %s",
packet.topic, packet.payload,
utils.checkchecksum(packet.payload));
}
logger.info("Data (%s) verified :-)", packet.topic);
var auth = {
id: client.id,
username: client.username,
password: client.password
};
// tell the client that all good only once all nicely distributed
function onSuccess(msg) {
logger.info(msg);
// TODO: we need a queue where we add the verifiedData if this here
// is not successful
logger.info("sending verification info back to client");
client.publish({topic: "verifiedData", payload: packet.topic});
}
self.distribute(auth, packet.payload, logger.error, onSuccess);
});
client.on('subscribe', function(packet) {
logger.debug("subscribe: packet = %s", packet);
var granted = [];
for (var i = 0; i < packet.subscriptions.length; i++) {
granted.push(packet.subscriptions[i].qos);
}
client.suback({granted: granted, messageId: packet.messageId});
});
client.on('pingreq', function(packet) {
client.pingresp();
});
client.on('disconnect', function(packet) {
client.stream.end();
});
client.on('close', function(err) {
delete self.clients[client.id];
});
client.on('error', function(err) {
console.log('error!', err);
if (!self.clients[client.id]) return;
delete self.clients[client.id];
client.stream.end();
});
});
mqtt.createServer(function(client) {
var self = this;
//客户端集合
if (!self.clients) self.clients = {};
//监听连接请求
client.on('connect', function(packet) {
client.connack({returnCode: 0});
client.id = packet.clientId;
client.subscriptions = [];
console.log("CONNECT: client id: " + client.id + "packet" + JSON.stringify(packet));
self.clients[client.id] = client;
});
client.on('publish', function(packet) {
//发布者本身不接受发布信息
delete self.clients[client.id];
//对所有连接进行一次广播
for (var k in self.clients) {
console.log("publish ->"+k);
self.clients[k].publish({topic: packet.topic, payload: packet.payload});
}
});
client.on('subscribe', function(packet) {
var granted = [];
for (var i = 0; i < packet.subscriptions.length; i++) {
//消息Qos 级别
granted.push(packet.subscriptions[i].qos);
}
console.log('subscribe->' + JSON.stringify({granted: granted}) + JSON.stringify(packet));
client.suback({granted:granted,messageId:packet.messageId});
});
client.on('pingreq', function(packet) {
util.log('pingreq!'+JSON.stringify(packet));
client.pingresp();
});
client.on('unsubscribe', function(packet){
console.log('unsubscribe!' + JSON.stringify(packet));
client.unsubscribe();
});
client.on('disconnect', function(packet) {
delete self.clients[client.id];
util.log('disconnect!');
client.stream.end();
});
client.on('close', function(err) {
delete self.clients[client.id];
});
client.on('error', function(err) {
delete self.clients[client.id];
client.stream.end();
console.log(err);
});
}).listen(1883);
mqtt.createServer(function(client) {
var self = this;
if (!self.clients) self.clients = {};
client.on('connect', function(packet) {
client.connack({returnCode: 0});
client.id = packet.clientId;
helper.log(client.id, 'connect');
self.clients[client.id] = client;
});
client.on('publish', function(packet) {
helper.log(client.id + ' ' + packet.payload, 'publish');
for (var k in self.clients) {
self.clients[k].publish({topic: packet.topic, payload: packet.payload});
}
});
client.on('subscribe', function(packet) {
helper.log(client.id + ' ' + packet.subscriptions[0].topic, 'subscribe');
var granted = [];
for (var i = 0; i < packet.subscriptions.length; i++) {
granted.push(packet.subscriptions[i].qos);
}
client.suback({granted: granted, messageId: packet.messageId});
});
client.on('pingreq', function(packet) {
helper.log(client.id, 'ping');
client.pingresp();
});
client.on('disconnect', function(packet) {
client.stream.end();
});
client.on('close', function(err) {
delete self.clients[client.id];
});
client.on('error', function(err) {
client.stream.end();
helper.log('error!', 'error');
});
}).listen(config.mqtt.port, function() {
var server = mqtt.createServer(function(client) {
//建立連接時觸發
client.on('connect', function(packet) {
client.connack({returnCode: 0});
});
//客户端發布主题时觸發
client.on('publish', function(packet) {
var topic=packet.topic;
var payload=packet.payload;
//如果没有創建空的主题對應的client數組
if(subscribeTopics[topic]==null){
subscribeTopics[topic]=[];
}else{
//遍歷該主題下全部client，並逐一發送消息
for(var i in subscribeTopics[topic]){
var client=subscribeTopics[topic][i];
//發布訊息
client.publish({
topic: topic,
payload: payload
});
}
}
});
//當客户端訂閱时觸發
client.on('subscribe', function(packet) {
var topic=packet.subscriptions[0].topic;
//如没有，創建空的主题對應的client數組
if(subscribeTopics[topic]==null){
subscribeTopics[topic]=[];
}
//如果client數組中没有當前client，加入
if(subscribeTopics[topic].indexOf(client)==-1){
subscribeTopics[topic].push(client);
}
});
client.on('pingreq', function(packet) {
client.pingresp();
});
client.on('disconnect', function(packet) {
//遍歷所有主题，检查对应的数组中是否有当前client，从数组中删除
for (var topic in subscribeTopics){
var index=subscribeTopics[topic].indexOf(client);
if(index>-1){
subscribeTopics[topic].splice(index,1);
}
}
});
});
client.on('close', function(err) {
console.log(" close:",client.id);
delete clients[client.id];
});
client.on('error', function(err) {
console.log(" error:",client.id);
delete clients[client.id];
client.stream.end();
console.log('error!');
});
}
///////////////////////////////////////////////////////////////////////////////////////
// creates the mqtt websocket server
var server = mows.createServer(callback_createServer);
server.listen(8080);
// creates the secure websocket server
var secureOpts = {
key : fs.readFileSync("tls-key.pem" ),
cert: fs.readFileSync("tls-cert.pem" )
};
var secureServer = mows.createSecureServer(secureOpts, callback_createServer);
secureServer.listen(4443);
// create the mqtt server
var mqttServer = mqtt.createServer(callback_createServer);
mqttServer.listen(1883);
mqtt.createServer( function(client) {
var self = this;
if (!self.clients) self.clients = {};
client.on('connect', function(packet) {
self.clients[packet.clientId] = client;
client.id = packet.clientId;
logger.info( ModuleName, "CONNECT: client id: " + client.id);
client.subscriptions = [];
client.connack({returnCode: 0});
});
client.on('subscribe', function(packet) {
var granted = [];
logger.info( ModuleName, 'SUBSCRIBE('+client.id+'): '+JSON.stringify(packet));
for (var i = 0; i < packet.subscriptions.length; i++) {
var qos = packet.subscriptions[i].qos
, topic = packet.subscriptions[i].topic
, reg = new RegExp(topic.replace('+', '[^\/]+').replace('#', '.+') + '$');
granted.push(qos);
client.subscriptions.push(reg);
}
client.suback({messageId: packet.messageId, granted: granted});
});
client.on('publish', function(packet) {
logger.info( ModuleName, 'PUBLISH('+client.id+'): '+JSON.stringify(packet));
for (var k in self.clients) {
var c = self.clients[k];
for (var i = 0; i < c.subscriptions.length; i++) {
var s = c.subscriptions[i];
if (s.test(packet.topic)) {
c.publish({topic: packet.topic, payload: packet.payload});
break;
}
}
}
});
client.on('pingreq', function(packet) {
logger.info( ModuleName, 'PINGREQ('+ client.id+')');
client.pingresp();
});
client.on('disconnect', function(packet) {
client.stream.end();
});
client.on('close', function(packet) {
delete self.clients[client.id];
});
client.on('error', function(e) {
client.stream.end();
logger.error( ModuleName, 'event error handled:'+JSON.stringify(e) );
});
}).listen( MQTTport );