thinknode
Version:
A fast, flexible and all-in-one web framework for node.js.
258 lines (202 loc) • 7.98 kB
JavaScript
;
exports.__esModule = true;
var _regenerator = require('babel-runtime/regenerator');
var _regenerator2 = _interopRequireDefault(_regenerator);
var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
var _keys = require('babel-runtime/core-js/object/keys');
var _keys2 = _interopRequireDefault(_keys);
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
var _inherits2 = require('babel-runtime/helpers/inherits');
var _inherits3 = _interopRequireDefault(_inherits2);
var _url = require('url');
var _url2 = _interopRequireDefault(_url);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var _class = function (_THINK$Base) {
(0, _inherits3.default)(_class, _THINK$Base);
function _class() {
(0, _classCallCheck3.default)(this, _class);
return (0, _possibleConstructorReturn3.default)(this, _THINK$Base.apply(this, arguments));
}
_class.prototype.init = function init(options) {
this.server = options.server;
this.app = options.app;
};
/**
* run
* @return {} []
*/
_class.prototype.run = function run() {
var _this2 = this;
var socketio = require('socket.io');
this.io = new socketio(this.server);
//set io adapter, must be a function
//http://socket.io/docs/using-multiple-nodes/
if (THINK.isFunction(THINK.config('websocket_adp'))) {
this.io.adapter(THINK.config('websocket_adp')());
}
//Sets the path v under which engine.io and the static files will be served. Defaults to /socket.io.
if (THINK.config('websocket_path')) {
this.io.path(THINK.config('websocket_path'));
}
//Sets the allowed origins v. Defaults to any origins being allowed.
if (THINK.config('websocket_allow_origin')) {
this.io.origins(THINK.config('websocket_allow_origin'));
}
//get message type
var messages = THINK.config('websocket_messages');
messages = THINK.isArray(messages) ? messages : [messages];
messages.forEach(function () {
var v = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var sc = v.namespace ? _this2.io.of(v.namespace) : _this2.io;
_this2.registerSocket(sc, v);
});
};
/**
* register namespace of socket, and support multi socket connect
* eg:
* export default {
messages:
[
{
namespace:'/payCount',
open: 'analysis/erp_pay/open',
close: 'analysis/erp_pay/close',
day: 'analysis/erp_pay/day',
updateFromMq: 'analysis/erp_pay/updateFromMq',
}
]
};
* @param io
* @param messages
*/
_class.prototype.registerSocket = function registerSocket(io, messages) {
var _this3 = this;
var msgKeys = (0, _keys2.default)(messages);
var open = messages.open;
delete messages.open;
var close = messages.close;
delete messages.close;
io.on('connection', function (socket) {
//open connection
if (open) {
_this3.message(open, undefined, socket);
}
//listen disonnection event
if (close) {
socket.on('disconnect', function () {
_this3.message(close, undefined, socket);
});
}
//listen list of message type
msgKeys.forEach(function (msgKey) {
socket.on(msgKey, function (msg) {
_this3.message(messages[msgKey], msg, socket);
});
});
});
};
/**
* emit socket data
* @param {String} event []
* @param {Mixed} data []
* @return {} []
*/
_class.prototype.emit = function emit(event, data) {
return this.socket.emit(event, data);
};
/**
* broadcast socket data
* @param {String} event []
* @param {Mixed} data []
* @param {Boolean} containSelf []
* @return {} []
*/
_class.prototype.broadcast = function broadcast(event, data, containSelf) {
if (containSelf) {
this.io.sockets.emit(event, data);
} else {
this.socket.broadcast.emit(event, data);
}
};
/**
* deal message
* @param {String} urls []
* @param {Mixed} data []
* @return {} []
*/
_class.prototype.message = function () {
var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(urls, data, socket) {
var request, http;
return _regenerator2.default.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
request = socket.request;
if (urls[0] !== '/') {
urls = '/' + urls;
}
request.url = urls;
_context.next = 5;
return THINK.Http.run(request, THINK.extend({}, request.res), 'WS');
case 5:
http = _context.sent;
http.pathname = urls;
http.method = 'ws';
http.url = urls;
http.data = data;
http.isWebSocket = true;
http.socket = socket;
http.io = this.io;
http.socketEmit = this.emit;
http.socketBroadcast = this.broadcast;
return _context.abrupt('return', this.app.exec(http).then(function () {
return THINK.statusAction(http, 200);
}).catch(function (err) {
return THINK.statusAction(http, 500, err);
}));
case 16:
case 'end':
return _context.stop();
}
}
}, _callee, this);
}));
function message(_x2, _x3, _x4) {
return _ref.apply(this, arguments);
}
return message;
}();
/**
* check origin allowed
* @param {String} origin []
* @return {Boolean} []
*/
_class.prototype.isOriginAllowed = function isOriginAllowed(origin) {
var allowOrigins = THINK.config('websocket_allow_origin');
if (!allowOrigins) {
return true;
}
var info = _url2.default.parse(origin);
var hostname = info.hostname;
if (THINK.isString(allowOrigins)) {
return allowOrigins === hostname;
} else if (THINK.isArray(allowOrigins)) {
return allowOrigins.indexOf(hostname) > -1;
} else if (THINK.isFunction(allowOrigins)) {
return allowOrigins(hostname, info);
}
return false;
};
return _class;
}(THINK.Base); /**
*
* @author richen
* @copyright Copyright (c) 2015 - <richenlin(at)gmail.com>
* @license MIT
* @version 15/12/9
*/
exports.default = _class;