Fascinated/mc-tracker
1
0
Fork 0
Code Issues 1 Pull Requests 6 Actions Activity

cleanup

Browse Source
This commit is contained in:
Lee
2024-01-01 17:04:19 +00:00
parent 3750a00017
commit a3dbd9e689
11 changed files with 476 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
src/database/database.ts Normal file
View File

@ -0,0 +1,153 @@
import SQLiteDatabase from "better-sqlite3";
import cron from "node-cron";
import Server, { PingResponse } from "../server/server";
import { logger } from "../utils/logger";
import { getFormattedDate } from "../utils/timeUtils";
import Config from "../../data/config.json";
import { Ping } from "../types/ping";
import { createDirectory } from "../utils/fsUtils";
const DATA_DIR = "data";
const BACKUP_DIR = `${DATA_DIR}/database-backups`;
const PINGS_TABLE = "pings";
const RECORD_TABLE = "record";
/**
* SQL Queries
*/
const CREATE_PINGS_TABLE = `
CREATE TABLE IF NOT EXISTS pings (
id INTEGER NOT NULL,
timestamp BIGINT NOT NULL,
ip TINYTEXT NOT NULL,
playerCount MEDIUMINT NOT NULL
);
`;
const CREATE_RECORD_TABLE = `
CREATE TABLE IF NOT EXISTS record (
id INTEGER PRIMARY KEY,
timestamp BIGINT NOT NULL,
ip TINYTEXT NOT NULL,
playerCount MEDIUMINT NOT NULL
);
`;
const CREATE_PINGS_INDEX = `CREATE INDEX IF NOT EXISTS ip_index ON pings (id, ip, playerCount)`;
const CREATE_TIMESTAMP_INDEX = `CREATE INDEX IF NOT EXISTS timestamp_index on PINGS (id, timestamp)`;
const INSERT_PING = `
INSERT INTO ${PINGS_TABLE} (id, timestamp, ip, playerCount)
VALUES (?, ?, ?, ?)
`;
const INSERT_RECORD = `
INSERT INTO ${RECORD_TABLE} (id, timestamp, ip, playerCount)
VALUES (?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET
timestamp = excluded.timestamp,
playerCount = excluded.playerCount,
ip = excluded.ip
`;
const SELECT_PINGS = `
SELECT * FROM ${PINGS_TABLE} WHERE id = ? AND timestamp >= ? AND timestamp <= ?
`;
const SELECT_RECORD = `
SELECT playerCount, timestamp FROM ${RECORD_TABLE} WHERE {} = ?
`;
const SELECT_RECORD_BY_ID = SELECT_RECORD.replace("{}", "id");
const SELECT_RECORD_BY_IP = SELECT_RECORD.replace("{}", "ip");
export default class Database {
private db: SQLiteDatabase.Database;
constructor() {
this.db = new SQLiteDatabase(`${DATA_DIR}/db.sqlite`);
this.db.pragma("journal_mode = WAL");
logger.info("Ensuring tables exist");
this.db.exec(CREATE_PINGS_TABLE); // Ensure the pings table exists
this.db.exec(CREATE_RECORD_TABLE); // Ensure the record table exists
logger.info("Ensuring indexes exist");
this.db.exec(CREATE_PINGS_INDEX); // Ensure the pings index exists
this.db.exec(CREATE_TIMESTAMP_INDEX); // Ensure the timestamp index exists
cron.schedule(Config.backup.cron, () => {
this.createBackup();
});
}
/**
* Gets the pings for a server.
*
* @param id the server ID
* @param startTime the start time
* @param endTime the end time
* @returns the pings for the server
*/
public getPings(id: number, startTime: number, endTime: number): Ping[] | [] {
return this.db.prepare(SELECT_PINGS).all(id, startTime, endTime) as
| Ping[]
| [];
}
/**
* Gets the record player count for a server.
*
* @param value the server ID or IP
* @returns the record for the server
*/
public getRecord(value: any): Ping | undefined {
if (typeof value === "number") {
return this.db.prepare(SELECT_RECORD_BY_ID).get(value) as
| Ping
| undefined;
}
return this.db.prepare(SELECT_RECORD_BY_IP).get(value) as Ping | undefined;
}
/**
* Creates a full backup of the database.
*/
public async createBackup() {
logger.info("Creating database backup");
createDirectory(BACKUP_DIR);
await this.db.backup(`${BACKUP_DIR}/${getFormattedDate()}.sqlite`);
logger.info("Finished creating database backup");
}
/**
* Inserts a ping into the database.
*
* @param timestamp the timestamp of the ping
* @param ip the IP address of the server
* @param playerCount the number of players online
*/
public insertPing(server: Server, response: PingResponse) {
const { timestamp, players } = response;
const id = server.getID();
const ip = server.getIP();
const onlineCount = players.online;
const statement = this.db.prepare(INSERT_PING);
statement.run(id, timestamp, ip, onlineCount); // Insert the ping into the database
}
/**
* Inserts a record into the database.
*
* @param server the server to insert
* @param response the response to insert
*/
public insertRecord(server: Server, response: PingResponse) {
const { timestamp, players } = response;
const id = server.getID();
const ip = server.getIP();
const onlineCount = players.online;
const statement = this.db.prepare(INSERT_RECORD);
statement.run(id, timestamp, ip, onlineCount); // Insert the record into the database
}
}

16
src/index.ts
View File

@ -1,5 +1,21 @@
import Database from "./database/database";
import Scanner from "./scanner/scanner";
import ServerManager from "./server/serverManager";
/**
* The database instance.
*/
export const database = new Database();
/**
* The server manager instance.
*/
export const serverManager = new ServerManager();
// The scanner is responsible for scanning all servers
new Scanner();
serverManager.getServers().forEach((server) => {
const record = database.getRecord(server.getID());
console.log(`Record for "${server.getName()}": ${record?.playerCount}`);
});

107
src/scanner/scanner.ts
View File

@ -1,67 +1,15 @@
import Database from "better-sqlite3";
import cron from "node-cron";
import { serverManager } from "..";
import { database, serverManager } from "..";
import Server from "../server/server";
import Config from "../../data/config.json";
import Server, { PingResponse } from "../server/server";
const DATA_DIR = "data";
const PINGS_TABLE = "pings";
const RECORD_TABLE = "record";
/**
* SQL Queries
*/
const CREATE_PINGS_TABLE = `
CREATE TABLE IF NOT EXISTS pings (
id INTEGER NOT NULL,
timestamp BIGINT NOT NULL,
ip TINYTEXT NOT NULL,
player_count MEDIUMINT NOT NULL
);
`;
const CREATE_RECORD_TABLE = `
CREATE TABLE IF NOT EXISTS record (
id INTEGER PRIMARY KEY,
timestamp BIGINT NOT NULL,
ip TINYTEXT NOT NULL,
player_count MEDIUMINT NOT NULL
);
`;
const CREATE_PINGS_INDEX = `CREATE INDEX IF NOT EXISTS ip_index ON pings (id, ip, player_count)`;
const CREATE_TIMESTAMP_INDEX = `CREATE INDEX IF NOT EXISTS timestamp_index on PINGS (id, timestamp)`;
const INSERT_PING = `
INSERT INTO ${PINGS_TABLE} (id, timestamp, ip, player_count)
VALUES (?, ?, ?, ?)
`;
const INSERT_RECORD = `
INSERT INTO ${RECORD_TABLE} (id, timestamp, ip, player_count)
VALUES (?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET
timestamp = excluded.timestamp,
player_count = excluded.player_count,
ip = excluded.ip
`;
import { logger } from "../utils/logger";
export default class Scanner {
private db: Database.Database;
constructor() {
console.log("Loading scanner database");
this.db = new Database(`${DATA_DIR}/db.sqlite`);
logger.info("Loading scanner database");
console.log("Ensuring tables exist");
this.db.exec(CREATE_PINGS_TABLE); // Ensure the pings table exists
this.db.exec(CREATE_RECORD_TABLE); // Ensure the record table exists
console.log("Ensuring indexes exist");
this.db.exec(CREATE_PINGS_INDEX); // Ensure the pings index exists
this.db.exec(CREATE_TIMESTAMP_INDEX); // Ensure the timestamp index exists
console.log("Starting server scan");
logger.info("Starting server scan");
cron.schedule(Config.scanner.updateCron, () => {
this.scanServers();
});
@ -71,14 +19,14 @@ export default class Scanner {
* Start a server scan to ping all servers.
*/
private async scanServers(): Promise<void> {
console.log(`Scanning servers ${serverManager.getServers().length}`);
logger.info(`Scanning servers ${serverManager.getServers().length}`);
// ping all servers in parallel
await Promise.all(
serverManager.getServers().map((server) => this.scanServer(server))
);
console.log("Finished scanning servers");
logger.info("Finished scanning servers");
}
/**
@ -88,7 +36,7 @@ export default class Scanner {
* @returns a promise that resolves when the server has been scanned
*/
async scanServer(server: Server): Promise<void> {
//console.log(`Scanning server ${server.getIP()} - ${server.getType()}`);
//logger.info(`Scanning server ${server.getIP()} - ${server.getType()}`);
let response;
let online = false;
@ -99,7 +47,7 @@ export default class Scanner {
}
online = true;
} catch (err) {
console.log(`Failed to ping ${server.getIP()}`, err);
logger.info(`Failed to ping ${server.getIP()}`, err);
return;
}
@ -107,40 +55,7 @@ export default class Scanner {
return; // Server is offline
}
this.insertPing(server, response);
this.insertRecord(server, response);
}
/**
* Inserts a ping into the database.
*
* @param timestamp the timestamp of the ping
* @param ip the IP address of the server
* @param playerCount the number of players online
*/
private insertPing(server: Server, response: PingResponse): void {
const { timestamp, players } = response;
const id = server.getID();
const ip = server.getIP();
const onlineCount = players.online;
const statement = this.db.prepare(INSERT_PING);
statement.run(id, timestamp, ip, onlineCount); // Insert the ping into the database
}
/**
* Inserts a record into the database.
*
* @param server the server to insert
* @param response the response to insert
*/
private insertRecord(server: Server, response: PingResponse): void {
const { timestamp, players } = response;
const id = server.getID();
const ip = server.getIP();
const onlineCount = players.online;
const statement = this.db.prepare(INSERT_RECORD);
statement.run(id, timestamp, ip, onlineCount); // Insert the record into the database
database.insertPing(server, response);
database.insertRecord(server, response);
}
}

47
src/server/server.ts
View File

@ -1,5 +1,6 @@
import javaPing from "mcping-js";
import { ResolvedServer, resolveDns } from "../utils/dnsResolver";
import JavaPing = require("mcping-js");
const bedrockPing = require("mcpe-ping-fixed"); // Doesn't have typescript definitions
import Config from "../../data/config.json";
@ -16,10 +17,10 @@ export type ServerType = "PC" | "PE";
export type PingResponse = {
timestamp: number;
ip: string;
version: string;
version?: string;
players: {
online: number;
max: number;
max?: number;
};
};
@ -27,6 +28,7 @@ type ServerOptions = {
id: number;
name: string;
ip: string;
port?: number;
type: ServerType;
};
@ -51,6 +53,11 @@ export default class Server {
*/
private ip: string;
/**
* The port of the server.
*/
private port: number | undefined;
/**
* The type of server.
*/
@ -64,10 +71,11 @@ export default class Server {
hasResolved: false,
};
constructor({ id, name, ip, type }: ServerOptions) {
constructor({ id, name, ip, port, type }: ServerOptions) {
this.id = id;
this.name = name;
this.ip = ip;
this.port = port;
this.type = type;
}
@ -126,7 +134,7 @@ export default class Server {
port = 25565; // The default port
}
const serverPing = new JavaPing.MinecraftServer(ip, port);
const serverPing = new javaPing.MinecraftServer(ip, port);
return new Promise((resolve, reject) => {
serverPing.ping(Config.scanner.timeout, 700, (err, res) => {
@ -156,7 +164,25 @@ export default class Server {
private async pingPEServer(
server: Server
): Promise<PingResponse | undefined> {
return undefined;
return new Promise((resolve, reject) => {
bedrockPing(
server.getIP(),
server.getPort() || 19132,
(err: any, res: any) => {
if (err || res == undefined) {
return reject(err);
}
resolve({
timestamp: Date.now(),
ip: server.getIP(),
players: {
online: res.currentPlayers,
},
});
}
);
});
}
/**
@ -186,6 +212,15 @@ export default class Server {
return this.ip;
}
/**
* Returns the port of the server.
*
* @returns the port
*/
public getPort(): number | undefined {
return this.port;
}
/**
* Returns the type of server.
*

6
src/types/ping.ts Normal file
View File

@ -0,0 +1,6 @@
export type Ping = {
id: number;
timestamp: number;
ip: string;
playerCount: number;
};

31
src/utils/logger.ts Normal file
View File

@ -0,0 +1,31 @@
import Winston, { format } from "winston";
const { colorize, timestamp, printf } = format;
interface LogInfo {
level: string;
message: string;
label?: string;
timestamp?: string;
}
const customFormat = format.combine(
timestamp({ format: "YY-MM-DD HH:MM:SS" }),
printf((info: LogInfo) => {
return `[${info.timestamp}] ${info.level}: ${info.message}`;
})
);
/**
* The global logger instance.
*/
export const logger = Winston.createLogger({
transports: [
new Winston.transports.Console({
format: Winston.format.combine(colorize(), customFormat),
}),
new Winston.transports.File({
filename: `data/logs/${new Date().toISOString().slice(0, 10)}.log`,
format: Winston.format.combine(customFormat),
}),
],
});

8
src/utils/timeUtils.ts Normal file
View File

@ -0,0 +1,8 @@
/**
* Gets the current date as YYYY-MM-DD.
*
* @returns the date
*/
export function getFormattedDate() {
return new Date().toISOString().slice(0, 10);
}