uspring
Version:
A very fast Webserver which has interface like springboot
180 lines (179 loc) • 6.95 kB
JavaScript
;
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var Joi = __importStar(require("joi"));
var Channel_1 = require("../Channel");
var ab2str = __importStar(require("arraybuffer-to-string"));
var StripUnknown_1 = __importDefault(require("../../uApp/helper/StripUnknown"));
function Functor(app, routename, opt) {
var req = {
schema: null,
invalid: function (err, ws) { },
request: null,
onJoin: function (ws, request) { },
onClose: function (ws, code, message) { },
onDrain: function (ws) { }
};
return {
Message: function (opt) {
req.schema = opt && opt.schema;
req.invalid = opt ? opt.onInvalid : req.invalid;
return this;
},
onJoin: function (fn) {
req.onJoin = fn;
return this;
},
onClose: function (cb) {
req.onClose = cb;
return this;
},
onDrain: function (cb) {
req.onDrain = cb;
return this;
},
Apply: function (fn) {
app.ws(routename, __assign(__assign({}, opt), { open: function (ws, request) {
req.request = request;
Channel_1.Route.joinRoute(routename, ws);
if (req.onJoin) {
req.onJoin(ws, request);
}
}, message: function (ws, message, isBinary) {
// extend ws
var extendWS = {
publish: function (message) {
if (typeof message === "object") {
message = JSON.stringify(message);
}
Channel_1.Route.publishToRoute(routename, message);
},
broadcast: function (message) {
if (typeof message === "object") {
message = JSON.stringify(message);
}
Channel_1.Route.broadcastToRoute(routename, ws.id, message);
}
};
for (var key in extendWS) {
ws[key] = extendWS[key];
}
var str = ab2str(message);
var obj;
try {
obj = JSON.parse(str);
}
catch (err) {
console.error(err);
}
var result;
var toValidate = obj;
var schema = req.schema;
if (schema)
result = Joi.validate(toValidate, schema, { abortEarly: false });
var errorMessages = [];
(result && result.error) && result.error.details.forEach(function (err) {
var message = err.message.split(" ").slice(1).join(" ");
var pathname = err.path[0];
errorMessages.push(pathname + " " + message);
});
if (errorMessages.length > 0) {
if (req.invalid) {
return req.invalid(errorMessages, ws);
}
return ws.send("ERROR, reason:" + JSON.stringify(errorMessages));
}
if (schema) {
result = StripUnknown_1.default.target(schema).value(result.value);
}
else {
result = obj;
}
fn(req, result, isBinary, ws);
}, drain: function (ws) {
console.log('WebSocket backpressure: ' + ws.getBufferedAmount());
if (req.onDrain) {
req.onDrain(ws);
}
}, close: function (ws, code, message) {
Channel_1.Route.removeUserFromAllRoute(ws.id);
if (req.onClose) {
req.onClose(ws, code, message);
}
} }));
}
};
}
exports.Functor = Functor;
function uSocket(_app, opt, uWS) {
// @ts-ignore
var errorCallback = function (e) { };
// @ts-ignore
var sucessCallback = function (port, token) { };
var listenSocket;
var shutdown = false;
return {
route: function (routeName) {
return Functor(_app, routeName, opt);
},
onerror: function (cb) {
errorCallback = cb;
return this;
},
onsuccess: function (cb) {
sucessCallback = cb;
return this;
},
listen: function (port, cb) {
return _app.listen(port, function (token) {
listenSocket = token;
/* Did we even manage to listen? */
if (token) {
sucessCallback(port, token);
cb(port, token);
/* When shutdown stop listening soon */
if (shutdown) {
setTimeout(function () {
console.log('Shutting down now');
if (listenSocket) {
uWS.us_listen_socket_close(listenSocket);
listenSocket = null;
}
}, 1000);
}
process.on('uncaughtException', function (err) {
errorCallback(err);
if (listenSocket) {
uWS.us_listen_socket_close(listenSocket);
listenSocket = null;
}
});
}
else {
console.log('Failed to listen to port ' + port);
}
});
},
};
}
exports.uSocket = uSocket;