458 lines
16 KiB
JavaScript
458 lines
16 KiB
JavaScript
// ENiGMA½
|
|
const { MenuModule } = require('./menu_module');
|
|
const stringFormat = require('./string_format');
|
|
|
|
const {
|
|
getActiveConnectionList,
|
|
AllConnections
|
|
} = require('./client_connections');
|
|
const StatLog = require('./stat_log');
|
|
const SysProps = require('./system_property');
|
|
const UserProps = require('./user_property');
|
|
const Log = require('./logger');
|
|
const Config = require('./config.js').get;
|
|
|
|
// deps
|
|
const async = require('async');
|
|
const _ = require('lodash');
|
|
const moment = require('moment');
|
|
const bunyan = require('bunyan');
|
|
|
|
exports.moduleInfo = {
|
|
name : 'WFC',
|
|
desc : 'Semi-Traditional Waiting For Caller',
|
|
author : 'NuSkooler',
|
|
};
|
|
|
|
const FormIds = {
|
|
main: 0,
|
|
help: 1,
|
|
fullLog: 2,
|
|
};
|
|
|
|
const MciViewIds = {
|
|
main : {
|
|
nodeStatus : 1,
|
|
quickLogView : 2,
|
|
nodeStatusSelection : 3,
|
|
|
|
customRangeStart : 10,
|
|
}
|
|
};
|
|
|
|
// Secure + 2FA + root user + 'wfc' group.
|
|
const DefaultACS = 'SCAF2ID1GM[wfc]';
|
|
const MainStatRefreshTimeMs = 5000; // 5s
|
|
const MailCountTTLSeconds = 10;
|
|
|
|
exports.getModule = class WaitingForCallerModule extends MenuModule {
|
|
constructor(options) {
|
|
super(options);
|
|
|
|
this.config = Object.assign({}, _.get(options, 'menuConfig.config'), { extraArgs : options.extraArgs });
|
|
|
|
this.config.acs = this.config.acs || DefaultACS;
|
|
if (!this.config.acs.includes('SC')) {
|
|
this.config.acs = 'SC' + this.config.acs; // secure connection at the very least
|
|
}
|
|
|
|
this.selectedNodeStatusIndex = -1; // no selection
|
|
|
|
this.menuMethods = {
|
|
toggleAvailable : (formData, extraArgs, cb) => {
|
|
const avail = this.client.user.isAvailable();
|
|
this.client.user.setAvailability(!avail);
|
|
return this._refreshAll(cb);
|
|
},
|
|
toggleVisible : (formData, extraArgs, cb) => {
|
|
const visible = this.client.user.isVisible();
|
|
this.client.user.setVisibility(!visible);
|
|
return this._refreshAll(cb);
|
|
},
|
|
displayHelp : (formData, extraArgs, cb) => {
|
|
return this._displayHelpPage(cb);
|
|
},
|
|
setNodeStatusSelection : (formData, extraArgs, cb) => {
|
|
const nodeStatusView = this.getView('main', MciViewIds.main.nodeStatus);
|
|
if (!nodeStatusView) {
|
|
return cb(null);
|
|
}
|
|
|
|
const nodeId = parseInt(formData.ch); // 1-based
|
|
if (isNaN(nodeId)) {
|
|
return cb(null);
|
|
}
|
|
|
|
const index = this._getNodeByNodeId(nodeStatusView, nodeId);
|
|
if (index > -1) {
|
|
this.selectedNodeStatusIndex = index;
|
|
this._selectNodeByIndex(nodeStatusView, this.selectedNodeStatusIndex);
|
|
}
|
|
return cb(null);
|
|
}
|
|
}
|
|
}
|
|
|
|
initSequence() {
|
|
async.series(
|
|
[
|
|
(callback) => {
|
|
return this.beforeArt(callback);
|
|
},
|
|
(callback) => {
|
|
return this._displayMainPage(false, callback);
|
|
}
|
|
],
|
|
() => {
|
|
this.finishedLoading();
|
|
}
|
|
);
|
|
}
|
|
|
|
_displayMainPage(clearScreen, cb) {
|
|
async.series(
|
|
[
|
|
(callback) => {
|
|
return this.displayArtAndPrepViewController(
|
|
'main',
|
|
FormIds.main,
|
|
{ clearScreen },
|
|
callback
|
|
);
|
|
},
|
|
(callback) => {
|
|
const quickLogView = this.getView('main', MciViewIds.main.quickLogView);
|
|
if (!quickLogView) {
|
|
return callback(null);
|
|
}
|
|
|
|
if (!this.logRingBuffer) {
|
|
const logLevel = this.config.quickLogLevel || // WFC specific
|
|
_.get(Config(), 'logging.rotatingFile.level') || // ...or system setting
|
|
'info'; // ...or default to info
|
|
|
|
this.logRingBuffer = new bunyan.RingBuffer({ limit : quickLogView.dimens.height || 24 });
|
|
Log.log.addStream({
|
|
name : 'wfc-ringbuffer',
|
|
type : 'raw',
|
|
level : logLevel,
|
|
stream : this.logRingBuffer
|
|
});
|
|
}
|
|
|
|
const nodeStatusView = this.getView('main', MciViewIds.main.nodeStatus);
|
|
const nodeStatusSelectionView = this.getView('main', MciViewIds.main.nodeStatusSelection);
|
|
const nodeStatusSelectionFormat = this.config.nodeStatusSelectionFormat || '{text}';
|
|
if (nodeStatusView && nodeStatusSelectionView) {
|
|
nodeStatusView.on('index update', index => {
|
|
const item = nodeStatusView.getItems()[index];
|
|
if (item) {
|
|
nodeStatusSelectionView.setText(stringFormat(nodeStatusSelectionFormat, item));
|
|
// :TODO: Update view
|
|
// :TODO: this is not triggered by key-presses (1, 2, ...) -- we need to handle that as well
|
|
}
|
|
});
|
|
}
|
|
|
|
return callback(null);
|
|
},
|
|
(callback) => {
|
|
return this._refreshAll(callback);
|
|
}
|
|
],
|
|
err => {
|
|
if (!err) {
|
|
this._startRefreshing();
|
|
}
|
|
return cb(err);
|
|
}
|
|
);
|
|
}
|
|
|
|
_displayHelpPage(cb) {
|
|
this._stopRefreshing();
|
|
|
|
this.displayAsset(
|
|
this.menuConfig.config.art.help,
|
|
{ clearScreen : true },
|
|
() => {
|
|
this.client.waitForKeyPress( () => {
|
|
return this._displayMainPage(true, cb);
|
|
});
|
|
}
|
|
);
|
|
}
|
|
|
|
enter() {
|
|
this.client.stopIdleMonitor();
|
|
this._applyOpVisibility();
|
|
super.enter();
|
|
}
|
|
|
|
leave() {
|
|
_.remove(Log.log.streams, stream => {
|
|
return stream.name === 'wfc-ringbuffer';
|
|
});
|
|
|
|
this._restoreOpVisibility();
|
|
|
|
this._stopRefreshing();
|
|
this.client.startIdleMonitor();
|
|
|
|
super.leave();
|
|
}
|
|
|
|
_applyOpVisibility() {
|
|
this.restoreUserIsVisible = this.client.user.isVisible();
|
|
|
|
const vis = this.config.opVisibility || 'current';
|
|
switch (vis) {
|
|
case 'hidden' : this.client.user.setVisibility(false); break;
|
|
case 'visible' : this.client.user.setVisibility(true); break;
|
|
default : break;
|
|
}
|
|
|
|
}
|
|
|
|
_restoreOpVisibility() {
|
|
this.client.user.setVisibility(this.restoreUserIsVisible);
|
|
}
|
|
|
|
_startRefreshing() {
|
|
if (this.mainRefreshTimer) {
|
|
this._stopRefreshing();
|
|
}
|
|
|
|
this.mainRefreshTimer = setInterval( () => {
|
|
this._refreshAll();
|
|
}, MainStatRefreshTimeMs);
|
|
}
|
|
|
|
_stopRefreshing() {
|
|
if (this.mainRefreshTimer) {
|
|
clearInterval(this.mainRefreshTimer);
|
|
delete this.mainRefreshTimer;
|
|
}
|
|
}
|
|
|
|
_refreshAll(cb) {
|
|
async.series(
|
|
[
|
|
(callback) => {
|
|
return this._refreshStats(callback);
|
|
},
|
|
(callback) => {
|
|
return this._refreshNodeStatus(callback);
|
|
},
|
|
(callback) => {
|
|
return this._refreshQuickLog(callback);
|
|
},
|
|
(callback) => {
|
|
this.updateCustomViewTextsWithFilter(
|
|
'main',
|
|
MciViewIds.main.customRangeStart,
|
|
this.stats
|
|
);
|
|
return callback(null);
|
|
}
|
|
],
|
|
err => {
|
|
if (cb) {
|
|
return cb(err);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
_getStatusStrings(isAvailable, isVisible) {
|
|
const availIndicators = Array.isArray(this.config.statusAvailableIndicators) ?
|
|
this.config.statusAvailableIndicators :
|
|
this.client.currentTheme.helpers.getStatusAvailableIndicators();
|
|
const visIndicators = Array.isArray(this.config.statusVisibleIndicators) ?
|
|
this.config.statusVisibleIndicators :
|
|
this.client.currentTheme.helpers.getStatusVisibleIndicators();
|
|
|
|
return [
|
|
isAvailable ? (availIndicators[1] || 'Y') : (availIndicators[0] || 'N'),
|
|
isVisible ? (visIndicators[1] || 'Y') : (visIndicators[0] || 'N'),
|
|
];
|
|
}
|
|
|
|
_refreshStats(cb) {
|
|
const fileAreaStats = StatLog.getSystemStat(SysProps.FileBaseAreaStats) || {};
|
|
const sysMemStats = StatLog.getSystemStat(SysProps.SystemMemoryStats) || {};
|
|
const sysLoadStats = StatLog.getSystemStat(SysProps.SystemLoadStats) || {};
|
|
const lastLoginStats = StatLog.getSystemStat(SysProps.LastLogin);
|
|
|
|
const now = moment();
|
|
|
|
const [availIndicator, visIndicator] = this._getStatusStrings(
|
|
this.client.user.isAvailable(), this.client.user.isVisible()
|
|
);
|
|
|
|
this.stats = {
|
|
// Date/Time
|
|
nowDate : now.format(this.getDateFormat()),
|
|
nowTime : now.format(this.getTimeFormat()),
|
|
now : now.format(this._dateTimeFormat('now')),
|
|
|
|
// Current process (our Node.js service)
|
|
processUptimeSeconds : process.uptime(),
|
|
|
|
// Totals
|
|
totalCalls : StatLog.getSystemStatNum(SysProps.LoginCount),
|
|
totalPosts : StatLog.getSystemStatNum(SysProps.MessageTotalCount),
|
|
totalUsers : StatLog.getSystemStatNum(SysProps.TotalUserCount),
|
|
totalFiles : fileAreaStats.totalFiles || 0,
|
|
totalFileBytes : fileAreaStats.totalFileBytes || 0,
|
|
|
|
// totalUploads :
|
|
// totalUploadBytes :
|
|
// totalDownloads :
|
|
// totalDownloadBytes :
|
|
|
|
// Today's Stats
|
|
callsToday : StatLog.getSystemStatNum(SysProps.LoginsToday),
|
|
postsToday : StatLog.getSystemStatNum(SysProps.MessagesToday),
|
|
uploadsToday : StatLog.getSystemStatNum(SysProps.FileUlTodayCount),
|
|
uploadBytesToday : StatLog.getSystemStatNum(SysProps.FileUlTodayBytes),
|
|
downloadsToday : StatLog.getSystemStatNum(SysProps.FileDlTodayCount),
|
|
downloadBytesToday : StatLog.getSystemStatNum(SysProps.FileDlTodayBytes),
|
|
newUsersToday : StatLog.getSystemStatNum(SysProps.NewUsersTodayCount),
|
|
|
|
// Current
|
|
currentUserName : this.client.user.username,
|
|
currentUserRealName : this.client.user.getProperty(UserProps.RealName) || this.client.user.username,
|
|
availIndicator : availIndicator,
|
|
visIndicator : visIndicator,
|
|
lastLoginUserName : lastLoginStats.userName,
|
|
lastLoginRealName : lastLoginStats.realName,
|
|
lastLoginDate : moment(lastLoginStats.timestamp).format(this.getDateFormat()),
|
|
lastLoginTime : moment(lastLoginStats.timestamp).format(this.getTimeFormat()),
|
|
lastLogin : moment(lastLoginStats.timestamp).format(this._dateTimeFormat('lastLogin')),
|
|
totalMemoryBytes : sysMemStats.totalBytes || 0,
|
|
freeMemoryBytes : sysMemStats.freeBytes || 0,
|
|
systemAvgLoad : sysLoadStats.average || 0,
|
|
systemCurrentLoad : sysLoadStats.current || 0,
|
|
newPrivateMail : StatLog.getUserStatNumByClient(this.client, UserProps.NewPrivateMailCount, MailCountTTLSeconds),
|
|
newMessagesAddrTo : StatLog.getUserStatNumByClient(this.client, UserProps.NewAddressedToMessageCount, MailCountTTLSeconds),
|
|
};
|
|
|
|
return cb(null);
|
|
}
|
|
|
|
_getNodeByNodeId(nodeStatusView, nodeId) {
|
|
return nodeStatusView.getItems().findIndex(entry => entry.node == nodeId);
|
|
}
|
|
|
|
_selectNodeByIndex(nodeStatusView, index) {
|
|
if (index >= 0 && nodeStatusView.getFocusItemIndex() !== index) {
|
|
nodeStatusView.setFocusItemIndex(index);
|
|
} else {
|
|
nodeStatusView.redraw();
|
|
}
|
|
}
|
|
|
|
_refreshNodeStatus(cb) {
|
|
const nodeStatusView = this.getView('main', MciViewIds.main.nodeStatus);
|
|
if (!nodeStatusView) {
|
|
return cb(null);
|
|
}
|
|
|
|
const nodeStatusItems = getActiveConnectionList(AllConnections)
|
|
.slice(0, nodeStatusView.dimens.height)
|
|
.map(ac => {
|
|
// Handle pre-authenticated
|
|
if (!ac.authenticated) {
|
|
ac.text = ac.userName = '*Pre Auth*';
|
|
ac.action = 'Logging In';
|
|
}
|
|
|
|
const [availIndicator, visIndicator] = this._getStatusStrings(ac.isAvailable, ac.isVisible);
|
|
|
|
const timeOn = ac.timeOn || moment.duration(0);
|
|
|
|
return Object.assign(ac, {
|
|
availIndicator,
|
|
visIndicator,
|
|
timeOnMinutes : timeOn.asMinutes(),
|
|
timeOn : _.upperFirst(timeOn.humanize()), // make friendly
|
|
affils : ac.affils || 'N/A',
|
|
realName : ac.realName || 'N/A',
|
|
});
|
|
});
|
|
|
|
// :TODO: Currently this always redraws due to setItems(). We really need painters alg.; The alternative now is to compare items... yuk.
|
|
nodeStatusView.setItems(nodeStatusItems);
|
|
this._selectNodeByIndex(nodeStatusView, this.selectedNodeStatusIndex); // redraws
|
|
return cb(null);
|
|
}
|
|
|
|
_refreshQuickLog(cb) {
|
|
const quickLogView = this.viewControllers.main.getView(MciViewIds.main.quickLogView);
|
|
if (!quickLogView) {
|
|
return cb(null);
|
|
}
|
|
|
|
const records = this.logRingBuffer.records;
|
|
if (records.length === 0) {
|
|
return cb(null);
|
|
}
|
|
|
|
const hasChanged = this.lastLogTime !== records[records.length - 1].time;
|
|
this.lastLogTime = records[records.length - 1].time;
|
|
|
|
if (!hasChanged) {
|
|
return cb(null);
|
|
}
|
|
|
|
const quickLogTimestampFormat =
|
|
this.config.quickLogTimestampFormat ||
|
|
this.getDateTimeFormat('short');
|
|
|
|
const levelIndicators = this.config.quickLogLevelIndicators ||
|
|
{
|
|
trace : 'T',
|
|
debug : 'D',
|
|
info : 'I',
|
|
warn : 'W',
|
|
error : 'E',
|
|
fatal : 'F',
|
|
};
|
|
|
|
|
|
const makeLevelIndicator = (level) => {
|
|
return levelIndicators[level] || '?';
|
|
};
|
|
|
|
const quickLogLevelMessagePrefixes = this.config.quickLogLevelMessagePrefixes || {};
|
|
const prefixMssage = (message, level) => {
|
|
const prefix = quickLogLevelMessagePrefixes[level] || '';
|
|
return `${prefix}${message}`;
|
|
};
|
|
|
|
const logItems = records.map(rec => {
|
|
const level = bunyan.nameFromLevel[rec.level];
|
|
return {
|
|
timestamp : moment(rec.time).format(quickLogTimestampFormat),
|
|
level : rec.level,
|
|
levelIndicator : makeLevelIndicator(level),
|
|
nodeId : rec.nodeId || '*',
|
|
sessionId : rec.sessionId || '',
|
|
message : prefixMssage(rec.msg, level),
|
|
};
|
|
});
|
|
|
|
quickLogView.setItems(logItems);
|
|
quickLogView.redraw();
|
|
|
|
return cb(null);
|
|
}
|
|
|
|
_dateTimeFormat(element) {
|
|
const format = this.config[`${element}DateTimeFormat`];
|
|
return format || this.getDateFormat();
|
|
}
|
|
};
|
|
|