mirror of
https://github.com/smogon/pokemon-showdown.git
synced 2026-03-27 04:05:40 -05:00
331 lines
11 KiB
JavaScript
331 lines
11 KiB
JavaScript
'use strict';
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const ProcessManager = require('./../process-manager');
|
|
const execFileSync = require('child_process').execFileSync;
|
|
|
|
const MAX_PROCESSES = 1;
|
|
const RESULTS_MAX_LENGTH = 100;
|
|
const LOG_PATH = '../logs/modlog/';
|
|
|
|
class ModlogManager extends ProcessManager {
|
|
onMessageUpstream(message) {
|
|
// Protocol:
|
|
// when crashing: "[id]|0"
|
|
// when not crashing: "[id]|1|[results]"
|
|
let pipeIndex = message.indexOf('|');
|
|
let id = +message.substr(0, pipeIndex);
|
|
|
|
if (this.pendingTasks.has(id)) {
|
|
this.pendingTasks.get(id)(message.slice(pipeIndex + 1));
|
|
this.pendingTasks.delete(id);
|
|
this.release();
|
|
}
|
|
}
|
|
|
|
onMessageDownstream(message) {
|
|
// protocol:
|
|
// "[id]|[room]|[searchString]|[exactSearch]|[maxLines]"
|
|
let pipeIndex = message.indexOf('|');
|
|
let nextPipeIndex = message.indexOf('|', pipeIndex + 1);
|
|
let id = message.substr(0, pipeIndex);
|
|
let room = message.substr(pipeIndex + 1, nextPipeIndex - pipeIndex - 1);
|
|
|
|
pipeIndex = nextPipeIndex;
|
|
nextPipeIndex = message.indexOf('|', pipeIndex + 1);
|
|
let searchString = message.substr(pipeIndex + 1, nextPipeIndex - pipeIndex - 1);
|
|
|
|
pipeIndex = nextPipeIndex;
|
|
nextPipeIndex = message.indexOf('|', pipeIndex + 1);
|
|
let exactSearch = message.substr(pipeIndex + 1, nextPipeIndex - pipeIndex - 1);
|
|
let maxLines = message.substr(nextPipeIndex + 1);
|
|
|
|
process.send(id + '|' + this.receive(room, searchString, exactSearch, maxLines));
|
|
}
|
|
|
|
receive(room, searchString, exactSearch, maxLines) {
|
|
let result;
|
|
exactSearch = exactSearch === '1';
|
|
maxLines = Number(maxLines);
|
|
if (isNaN(maxLines) || maxLines > RESULTS_MAX_LENGTH || maxLines < 1) maxLines = RESULTS_MAX_LENGTH;
|
|
try {
|
|
result = '1|' + runModlog(room, searchString, exactSearch, maxLines);
|
|
} catch (err) {
|
|
require('../crashlogger')(err, 'A modlog query', {
|
|
room: room,
|
|
searchString: searchString,
|
|
exactSearch: exactSearch,
|
|
maxLines: maxLines,
|
|
});
|
|
result = '0';
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
exports.ModlogManager = ModlogManager;
|
|
|
|
const PM = exports.PM = new ModlogManager({
|
|
execFile: __filename,
|
|
maxProcesses: MAX_PROCESSES,
|
|
isChatBased: true,
|
|
});
|
|
|
|
if (!process.send) {
|
|
PM.spawn();
|
|
}
|
|
|
|
if (process.send && module === process.mainModule) {
|
|
global.Config = require('../config/config');
|
|
global.Dex = require('../sim/dex');
|
|
global.toId = Dex.getId;
|
|
process.on('message', message => PM.onMessageDownstream(message));
|
|
process.on('disconnect', () => process.exit());
|
|
require('../repl').start('modlog', cmd => eval(cmd));
|
|
}
|
|
|
|
class SortedLimitedLengthList {
|
|
constructor(maxSize) {
|
|
this.maxSize = maxSize;
|
|
this.list = [];
|
|
}
|
|
|
|
getListClone() {
|
|
return this.list.slice(0);
|
|
}
|
|
|
|
tryInsert(element) {
|
|
let insertedAt = -1;
|
|
for (let i = this.list.length - 1; i >= 0; i--) {
|
|
if (element.localeCompare(this.list[i]) < 0) {
|
|
insertedAt = i + 1;
|
|
if (i === this.list.length - 1) {
|
|
this.list.push(element);
|
|
break;
|
|
}
|
|
this.list.splice(i + 1, 0, element);
|
|
break;
|
|
}
|
|
}
|
|
if (insertedAt < 0) this.list.splice(0, 0, element);
|
|
if (this.list.length > this.maxSize) {
|
|
this.list.pop();
|
|
if (insertedAt === this.list.length) return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
function checkRipgrepAvailability() {
|
|
if (Config.ripgrepmodlog === undefined) {
|
|
try {
|
|
execFileSync('rg', ['--version'], {cwd: path.normalize(`${__dirname}/${LOG_PATH}`)});
|
|
Config.ripgrepmodlog = true;
|
|
} catch (error) {
|
|
Config.ripgrepmodlog = false;
|
|
}
|
|
}
|
|
return Config.ripgrepmodlog;
|
|
}
|
|
|
|
function runModlog(room, searchString, exactSearch, maxLines) {
|
|
const useRipgrep = checkRipgrepAvailability();
|
|
let fileNameList = [];
|
|
if (room === 'all') {
|
|
const fileList = fs.readdirSync(`${__dirname}/${LOG_PATH}`);
|
|
for (let i = 0; i < fileList.length; i++) {
|
|
fileNameList.push(fileList[i]);
|
|
}
|
|
} else if (room === 'public') {
|
|
const isPublicRoom = (room => !(room.isPrivate || room.battle || room.isPersonal || room.id === 'global'));
|
|
const publicRoomIds = Array.from(Rooms.rooms.values()).filter(isPublicRoom).map(room => room.id);
|
|
for (let i = 0; i < publicRoomIds.length; i++) {
|
|
fileNameList.push(`modlog_${publicRoomIds[i]}.txt`);
|
|
}
|
|
} else {
|
|
fileNameList = [`modlog_${room}.txt`];
|
|
}
|
|
|
|
let regexString;
|
|
if (!searchString) {
|
|
regexString = '.';
|
|
} else if (exactSearch) {
|
|
regexString = searchString.replace(/[\\.+*?()|[\]{}^$]/g, '\\$&');
|
|
} else {
|
|
searchString = toId(searchString);
|
|
regexString = `\\b${searchString.split('').join('[\\W_]*')}\\b`;
|
|
}
|
|
|
|
let results = new SortedLimitedLengthList(maxLines);
|
|
if (useRipgrep && searchString) {
|
|
if (room === 'all') fileNameList = [`${__dirname}/${LOG_PATH}`];
|
|
runRipgrepModlog(fileNameList, regexString, results);
|
|
} else {
|
|
fileNameList = fileNameList.map(filename => path.normalize(`${__dirname}/${LOG_PATH}${filename}`));
|
|
const searchStringRegex = new RegExp(regexString, 'i');
|
|
for (let i = 0; i < fileNameList.length; i++) {
|
|
checkRoomModlog(fileNameList[i], searchStringRegex, results);
|
|
}
|
|
}
|
|
const resultData = results.getListClone();
|
|
return resultData.join('\n');
|
|
}
|
|
|
|
function checkRoomModlog(path, regex, results) {
|
|
if (!fs.existsSync(path)) return results;
|
|
let newLines = [];
|
|
let lineFragment = '';
|
|
let blockSize = 1024;
|
|
let buf = Buffer.alloc(blockSize);
|
|
const stats = fs.statSync(path);
|
|
let startPos = stats.size;
|
|
const fd = fs.openSync(path, 'r');
|
|
|
|
outerLoop: do {
|
|
startPos -= blockSize;
|
|
if (startPos < 0) {
|
|
blockSize += startPos;
|
|
startPos = 0;
|
|
}
|
|
const bytesRead = fs.readSync(fd, buf, 0, blockSize, startPos);
|
|
newLines = buf.toString().substr(0, bytesRead).split('\n').reverse();
|
|
newLines[0] += lineFragment;
|
|
lineFragment = newLines[newLines.length - 1];
|
|
if (startPos > 0) newLines.splice(-1, 1);
|
|
for (let i = 0; i < newLines.length; i++) {
|
|
if (newLines[i] && regex.test(newLines[i])) {
|
|
const insertionSuccessful = results.tryInsert(newLines[i]);
|
|
if (!insertionSuccessful) {
|
|
break outerLoop;
|
|
}
|
|
}
|
|
}
|
|
} while (startPos > 0);
|
|
|
|
fs.close(fd, () => {});
|
|
|
|
return results;
|
|
}
|
|
|
|
function runRipgrepModlog(paths, regexString, results) {
|
|
let stdout;
|
|
try {
|
|
stdout = execFileSync('rg', ['-i', '-e', regexString, '--no-filename', '--no-line-number', ...paths], {cwd: path.normalize(`${__dirname}/${LOG_PATH}`)});
|
|
} catch (error) {
|
|
return results;
|
|
}
|
|
const fileResults = stdout.toString().split('\n').reverse();
|
|
for (let i = 0; i < fileResults.length; i++) {
|
|
results.tryInsert(fileResults[i]);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
function prettifyResults(rawResults, room, searchString, exactSearch, addModlogLinks, hideIps) {
|
|
if (rawResults === '0') {
|
|
return "The modlog query has crashed.";
|
|
}
|
|
let roomName;
|
|
switch (room) {
|
|
case 'all':
|
|
roomName = "all rooms";
|
|
break;
|
|
case 'public':
|
|
roomName = "all public rooms";
|
|
break;
|
|
default:
|
|
roomName = `room ${room}`;
|
|
}
|
|
if (exactSearch) searchString = `"${searchString}"`;
|
|
let pipeIndex = rawResults.indexOf('|');
|
|
if (pipeIndex < 0) pipeIndex = 0;
|
|
rawResults = rawResults.substr(pipeIndex + 1, rawResults.length);
|
|
if (!rawResults) {
|
|
return `No moderator actions containing ${searchString} found on ${roomName}.` +
|
|
(exactSearch ? "" : " Add quotes to the search parameter to search for a phrase, rather than a user.");
|
|
}
|
|
const resultArray = rawResults.split('\n');
|
|
let lines = resultArray.length;
|
|
const resultString = resultArray.map(line => {
|
|
if (hideIps) line = line.replace(/\([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+\)/g, '');
|
|
let bracketIndex = line.indexOf(']');
|
|
let parenIndex = line.indexOf(')');
|
|
if (bracketIndex < 0) return Chat.escapeHTML(line);
|
|
const time = line.slice(1, bracketIndex);
|
|
let timestamp = Chat.toTimestamp(new Date(time), {hour12: true});
|
|
parenIndex = line.indexOf(')');
|
|
let thisRoomID = line.slice(bracketIndex + 3, parenIndex);
|
|
if (addModlogLinks) {
|
|
let url = Config.modloglink(time, thisRoomID);
|
|
if (url) timestamp = `<a href="${url}">${timestamp}</a>`;
|
|
}
|
|
return `<small>[${timestamp}] (${thisRoomID})</small>${Chat.escapeHTML(line.slice(parenIndex + 1))}`;
|
|
}).join(`<br />`);
|
|
let preamble;
|
|
if (searchString) {
|
|
preamble = `|wide||html|<p>The last ${lines} logged actions containing ${searchString} on ${roomName}.` +
|
|
(exactSearch ? "" : " Add quotes to the search parameter to search for a phrase, rather than a user.");
|
|
} else {
|
|
preamble = `|wide||html|<p>The last ${lines} lines of the Moderator Log of ${roomName}.`;
|
|
}
|
|
preamble += `</p><p><small>[${Chat.toTimestamp(new Date(), {hour12: true})}] \u2190 current server time</small></p>`;
|
|
return preamble + resultString;
|
|
}
|
|
|
|
exports.commands = {
|
|
timedmodlog: 'modlog',
|
|
modlog: function (target, room, user, connection, cmd) {
|
|
const startTime = Date.now();
|
|
let roomId = (room.id === 'staff' ? 'global' : room.id);
|
|
let hideIps = !user.can('lock');
|
|
|
|
if (target.includes(',')) {
|
|
let targets = target.split(',');
|
|
target = targets[1].trim();
|
|
roomId = toId(targets[0]) || room.id;
|
|
}
|
|
|
|
let targetRoom = Rooms.search(roomId);
|
|
// if a room alias was used, replace alias with actual id
|
|
if (targetRoom) roomId = targetRoom.id;
|
|
if (roomId.startsWith('battle-') || roomId.startsWith('groupchat-')) this.errorReply("Battles and groupchats don't have individual modlogs.");
|
|
|
|
// permission checking
|
|
if (roomId === 'all' || roomId === 'public') {
|
|
if (!this.can('modlog')) return;
|
|
} else {
|
|
if (!this.can('modlog', null, targetRoom)) return;
|
|
}
|
|
|
|
let addModlogLinks = Config.modloglink && (!hideIps || (targetRoom && targetRoom.isPrivate !== true));
|
|
// Let's check the number of lines to retrieve or if it's a word instead
|
|
let lines = 0;
|
|
if (!target.match(/[^0-9]/)) {
|
|
lines = parseInt(target || 20);
|
|
if (lines > RESULTS_MAX_LENGTH) lines = RESULTS_MAX_LENGTH;
|
|
}
|
|
let wordSearch = (!lines || lines < 0);
|
|
let searchString = '';
|
|
if (wordSearch) {
|
|
searchString = target.trim();
|
|
lines = RESULTS_MAX_LENGTH;
|
|
}
|
|
let exactSearch = '0';
|
|
if (searchString.match(/^["'].+["']$/)) {
|
|
exactSearch = '1';
|
|
searchString = searchString.substring(1, searchString.length - 1);
|
|
}
|
|
|
|
PM.send(roomId, searchString, exactSearch, lines).then(response => {
|
|
connection.popup(prettifyResults(response, roomId, searchString, exactSearch, addModlogLinks, hideIps));
|
|
if (cmd === 'timedmodlog') this.sendReply(`The modlog query took ${Date.now() - startTime} ms to complete.`);
|
|
});
|
|
},
|
|
modloghelp: ["/modlog [roomid|all|public], [n] - Roomid defaults to current room.",
|
|
"If n is a number or omitted, display the last n lines of the moderator log. Defaults to 20.",
|
|
"If n is not a number, search the moderator log for 'n' on room's log [roomid]. If you set [all] as [roomid], searches for 'n' on all rooms's logs.",
|
|
"If you set [public] as [roomid], searches for 'n' in all public room's logs, excluding battles. Requires: % @ * # & ~",
|
|
],
|
|
};
|