src/services/LogServer.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import bcrypt from "bcrypt";
import chalk from "chalk";
import { Server, Socket } from "socket.io";
import Client from "../core/Client";
import Service from "../core/Service";
import { LogLevel, logInfo, logStringWithLevel, logWarn } from "../utils/logger";

export const name = "logServer";

export default class LogServer extends Service {
    public readonly MAX_CONNECTIONS = 5;
    protected connections = 0;
    private _io?: Server;
    public readonly sockets: Array<Socket> = [];
    public readonly attributes: Array<{ colorize?: boolean }> = [];

    constructor(client: Client) {
        super(client);

        if (!client.configManager.systemConfig.log_server?.auto_start) {
            return;
        }

        this.initialize();
    }

    get io() {
        return this._io;
    }

    initialize() {
        this._io = new Server();
        this.setupListeners();
    }

    start() {
        this.initialize();
        this.listen();
    }

    close() {
        this.io?.close();
        this._io = undefined;
    }

    isAuthorized(socket: Socket) {
        const { authorization } = socket.request.headers;
        const [type, password] = authorization?.split(/\s+/) ?? ["", ""];

        if (type !== "Bearer") {
            socket.send("[error] Only bearer tokens are supported!");
            socket.disconnect(true);
            return false;
        }

        if (!bcrypt.compareSync(password, process.env.LOG_SERVER_PASSWORD ?? Math.random().toString())) {
            socket.send("[error] Authentication failed");
            socket.disconnect(true);
            return false;
        }

        return true;
    }

    setupListeners() {
        this.io?.on("connection", socket => {
            if (this.connections >= this.MAX_CONNECTIONS) {
                socket.disconnect();
                return;
            }

            this.connections++;
            logInfo("New client connected to the log server", socket.id);

            socket.on("disconnect", reason => {
                this.connections--;
                logInfo("Client Disonnected from log server: ", socket.id, reason);
                const index = this.sockets.findIndex(s => s.id === socket.id);

                if (index !== -1) {
                    this.sockets.splice(index, 1);
                    this.attributes.splice(index, 1);
                }
            });

            if (!this.isAuthorized(socket)) {
                logWarn("Unauthorized client attempted to connect to the log server", socket.id);
                return;
            }

            const colorize = socket.request.headers["x-colorize"] === "Yes";

            socket.write(`${colorize ? chalk.cyan("[info]") : "[info]"} Connection Accepted`);

            this.sockets.push(socket);
            this.attributes.push({
                colorize
            });
        });
    }

    send(message: string) {
        for (const socket of this.sockets) {
            socket.send(message);
        }
    }

    log(level: LogLevel, message: string) {
        this.sockets.forEach((socket, index) => {
            const { colorize } = this.attributes[index] ?? {};

            if (colorize) {
                socket.send(logStringWithLevel(level, message));
            } else {
                socket.send(`[system:${LogLevel[level].toLowerCase()}] ${message}`);
            }
        });
    }

    listen() {
        let port = process.env.LOG_SERVER_PORT ? parseInt(process.env.LOG_SERVER_PORT) : 3500;
        port = isNaN(port) ? 3500 : port;

        this.io?.listen(port);
        logInfo("The log server is running at port", port);
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2023 OSN Developers.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import bcrypt from "bcrypt";
21			import chalk from "chalk";
22			import { Server, Socket } from "socket.io";
23			import Client from "../core/Client";
24			import Service from "../core/Service";
25			import { LogLevel, logInfo, logStringWithLevel, logWarn } from "../utils/logger";
26
27			export const name = "logServer";
28
29			export default class LogServer extends Service {
30			public readonly MAX_CONNECTIONS = 5;
31			protected connections = 0;
32			private _io?: Server;
33			public readonly sockets: Array<Socket> = [];
34			public readonly attributes: Array<{ colorize?: boolean }> = [];
35
36			constructor(client: Client) {
37			super(client);
38
39			if (!client.configManager.systemConfig.log_server?.auto_start) {
40			return;
41			}
42
43			this.initialize();
44			}
45
46			get io() {
47			return this._io;
48			}
49
50			initialize() {
51			this._io = new Server();
52			this.setupListeners();
53			}
54
55			start() {
56			this.initialize();
57			this.listen();
58			}
59
60			close() {
61			this.io?.close();
62			this._io = undefined;
63			}
64
65			isAuthorized(socket: Socket) {
66			const { authorization } = socket.request.headers;
67			const [type, password] = authorization?.split(/\s+/) ?? ["", ""];
68
69			if (type !== "Bearer") {
70			socket.send("[error] Only bearer tokens are supported!");
71			socket.disconnect(true);
72			return false;
73			}
74
75			if (!bcrypt.compareSync(password, process.env.LOG_SERVER_PASSWORD ?? Math.random().toString())) {
76			socket.send("[error] Authentication failed");
77			socket.disconnect(true);
78			return false;
79			}
80
81			return true;
82			}
83
84			setupListeners() {
85			this.io?.on("connection", socket => {
86			if (this.connections >= this.MAX_CONNECTIONS) {
87			socket.disconnect();
88			return;
89			}
90
91			this.connections++;
92			logInfo("New client connected to the log server", socket.id);
93
94			socket.on("disconnect", reason => {
95			this.connections--;
96			logInfo("Client Disonnected from log server: ", socket.id, reason);
97			const index = this.sockets.findIndex(s => s.id === socket.id);
98
99			if (index !== -1) {
100			this.sockets.splice(index, 1);
101			this.attributes.splice(index, 1);
102			}
103			});
104
105			if (!this.isAuthorized(socket)) {
106			logWarn("Unauthorized client attempted to connect to the log server", socket.id);
107			return;
108			}
109
110			const colorize = socket.request.headers["x-colorize"] === "Yes";
111
112			socket.write(`${colorize ? chalk.cyan("[info]") : "[info]"} Connection Accepted`);
113
114			this.sockets.push(socket);
115			this.attributes.push({
116			colorize
117			});
118			});
119			}
120
121			send(message: string) {
122			for (const socket of this.sockets) {
123			socket.send(message);
124			}
125			}
126
127			log(level: LogLevel, message: string) {
128			this.sockets.forEach((socket, index) => {
129			const { colorize } = this.attributes[index] ?? {};
130
131			if (colorize) {
132			socket.send(logStringWithLevel(level, message));
133			} else {
134			socket.send(`[system:${LogLevel[level].toLowerCase()}] ${message}`);
135			}
136			});
137			}
138
139			listen() {
140			let port = process.env.LOG_SERVER_PORT ? parseInt(process.env.LOG_SERVER_PORT) : 3500;
141			port = isNaN(port) ? 3500 : port;
142
143			this.io?.listen(port);
144			logInfo("The log server is running at port", port);
145			}
146			}