elysium/minecluster
elysium/minecluster
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[REV] Switch to use IDS over server names

Browse source
This commit is contained in:
Dunemask 2023-12-22 14:45:49 -07:00
parent e94aca7c96
commit 91587f66b2
21 changed files with 196 additions and 221 deletions
Download patch file Download diff file Expand all files Collapse all files

10
lib/controllers/file-controller.js
View file

@ -10,7 +10,7 @@ import { sendError } from "../util/ExpressClientError.js";
export async function listFiles(req, res) {
const serverSpec = req.body;
if (!serverSpec) return res.sendStatus(400);
if (!serverSpec.host) return res.status(400).send("Server name required!");
if (!serverSpec.id) return res.status(400).send("Server id missing!");
listServerFiles(serverSpec)
.then((f) => {
const fileData = f.map((fi, i) => ({
@ -29,7 +29,7 @@ export async function listFiles(req, res) {
export async function createFolder(req, res) {
const serverSpec = req.body;
if (!serverSpec) return res.sendStatus(400);
if (!serverSpec.host) return res.status(400).send("Server name required!");
if (!serverSpec.id) return res.status(400).send("Server id missing!");
if (!serverSpec.path) return res.status(400).send("Path required!");
createServerFolder(serverSpec)
.then(() => res.sendStatus(200))
@ -39,7 +39,7 @@ export async function createFolder(req, res) {
export async function deleteItem(req, res) {
const serverSpec = req.body;
if (!serverSpec) return res.sendStatus(400);
if (!serverSpec.host) return res.status(400).send("Server name required!");
if (!serverSpec.id) return res.status(400).send("Server id missing!");
if (!serverSpec.path) return res.status(400).send("Path required!");
if (serverSpec.isDir === undefined || serverSpec.isDir === null)
return res.status(400).send("IsDIr required!");
@ -50,7 +50,7 @@ export async function deleteItem(req, res) {
export async function uploadItem(req, res) {
const serverSpec = req.body;
if (!serverSpec.host) return res.status(400).send("Server name required!");
if (!serverSpec.id) return res.status(400).send("Server id missing!");
if (!serverSpec.path) return res.status(400).send("Path required!");
uploadServerItem(serverSpec, req.file)
.then(() => res.sendStatus(200))
@ -59,7 +59,7 @@ export async function uploadItem(req, res) {
export async function getItem(req, res) {
const serverSpec = req.body;
if (!serverSpec.host) return res.status(400).send("Server name required!");
if (!serverSpec.id) return res.status(400).send("Server id missing!");
if (!serverSpec.path) return res.status(400).send("Path required!");
getServerItem(serverSpec, res)
.then(({ ds, ftpTransfer }) => {

34
lib/controllers/lifecycle-controller.js
View file

@ -8,33 +8,35 @@ import {
import { sendError } from "../util/ExpressClientError.js";
import { toggleServer } from "../k8s/k8s-server-control.js";
const dnsRegex = new RegExp(
`^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*$`,
);
function payloadFilter(req, res) {
const serverSpec = req.body;
if (!serverSpec) return res.sendStatus(400);
const { name, host, version, serverType, memory } =
serverSpec;
const { name, host, version, serverType, memory } = serverSpec;
if (!name) return res.status(400).send("Server name is required!");
if (!host) return res.status(400).send("Server host is required!");
if (!dnsRegex.test(host)) return res.status(400).send("Hostname invalid!");
if (!version) return res.status(400).send("Server version is required!");
if (!serverType) return res.status(400).send("Server type is required!");
if (!memory) return res.status(400).send("Memory is required!");
return "filtered";
}
function checkServerHost(serverSpec) {
function checkServerId(serverSpec) {
if (!serverSpec) throw new ExpressClientError({ c: 400 });
if (!serverSpec.host)
throw new ExpressClientError({ c: 400, m: "Server name required!" });
if (!serverSpec.id)
throw new ExpressClientError({ c: 400, m: "Server id missing!" });
}
export async function createServer(req, res) {
if (payloadFilter(req, res) !== "filtered") return;
const serverSpec = req.body;
try {
const serverSpecs = await getServerEntry(serverSpec.id);
if (serverSpecs.length !== 0) throw Error("Server already exists in DB!");
await createServerResources(serverSpec);
await createServerEntry(serverSpec);
const serverEntry = await createServerEntry(serverSpec);
await createServerResources(serverEntry);
res.sendStatus(200);
} catch (e) {
sendError(res)(e);
@ -45,7 +47,7 @@ export async function deleteServer(req, res) {
// Ensure spec is safe
const serverSpec = req.body;
try {
checkServerHost(serverSpec);
checkServerId(serverSpec);
} catch (e) {
return sendError(res)(e);
}
@ -60,12 +62,12 @@ export async function startServer(req, res) {
// Ensure spec is safe
const serverSpec = req.body;
try {
checkServerHost(serverSpec);
checkServerId(serverSpec);
} catch (e) {
return sendError(res)(e);
}
const { name } = serverSpec;
toggleServer(name, true)
const { id } = serverSpec;
toggleServer(id, true)
.then(() => res.sendStatus(200))
.catch(sendError(res));
}
@ -74,12 +76,12 @@ export async function stopServer(req, res) {
// Ensure spec is safe
const serverSpec = req.body;
try {
checkServerHost(serverSpec);
checkServerId(serverSpec);
} catch (e) {
return sendError(res)(e);
}
const { name } = serverSpec;
toggleServer(name, false)
const { id } = serverSpec;
toggleServer(id, false)
.then(() => res.sendStatus(200))
.catch(sendError(res));
}

37
lib/database/queries/server-queries.js
View file

@ -9,32 +9,47 @@ const asExpressClientError = (e) => {
export async function createServerEntry(serverSpec) {
const { name, host, version, serverType: server_type, memory } = serverSpec;
const q = insertQuery(table, { name, host, version, server_type, memory });
var q = insertQuery(table, { name, host, version, server_type, memory });
q += "\n RETURNING *";
try {
const entries = await pg.query(q);
const {
id,
name,
host,
version,
server_type: serverType,
memory,
} = entries[0];
return { name, id, host, version, serverType, memory };
} catch (e) {
asExpressClientError(e);
}
}
export async function deleteServerEntry(serverId) {
if (!serverId) asExpressClientError({ message: "Server ID Required!" });
const q = deleteQuery(table, { id: serverId });
return pg.query(q).catch(asExpressClientError);
}
export async function deleteServerEntry(serverName) {
if (!serverName) asExpressClientError({ message: "Server Name Required!" });
const q = deleteQuery(table, { name: serverName });
return pg.query(q).catch(asExpressClientError);
}
export async function getServerEntry(serverName) {
if (!serverName) asExpressClientError({ message: "Server Name Required!" });
const q = selectWhereQuery(table, { name: serverName });
export async function getServerEntry(serverId) {
if (!serverId) asExpressClientError({ message: "Server ID Required!" });
const q = selectWhereQuery(table, { id: serverId });
try {
const serverSpecs = await pg.query(q);
if (serverSpecs.length === 0) return [];
if (!serverSpecs.length === 1)
throw Error("Multiple servers found with the same name!");
const {
id,
name,
host,
version,
server_type: serverType,
memory,
} = serverSpecs[0];
return { name, host, version, serverType, memory };
return { name, id, host, version, serverType, memory };
} catch (e) {
asExpressClientError(e);
}

2
lib/k8s/configs/rcon-secret.yml
View file

@ -4,7 +4,7 @@ data:
kind: Secret
metadata:
annotations:
minecluster.dunemask.net/server-name: changeme-server-name
minecluster.dunemask.net/id: changeme-server-id
labels:
app: changeme-app-label
name: changeme-rcon-secret

2
lib/k8s/configs/rcon-svc.yml
View file

@ -2,7 +2,7 @@ apiVersion: v1
kind: Service
metadata:
annotations:
minecluster.dunemask.net/server-name: changeme-server-name
minecluster.dunemask.net/id: changeme-server-id
labels:
app: changeme-app
name: changeme-rcon

4
lib/k8s/configs/server-deployment.yml
View file

@ -2,7 +2,7 @@ apiVersion: apps/v1
kind: Deployment
metadata:
annotations:
minecluster.dunemask.net/server-name: changeme-server-name
minecluster.dunemask.net/id: changeme-server-id
name: changeme-name
namespace: changeme-namespace
spec:
@ -17,7 +17,7 @@ spec:
template:
metadata:
annotations:
minecluster.dunemask.net/server-name: changeme-server-name
minecluster.dunemask.net/id: changeme-server-id
labels:
app: changeme-app
spec:

2
lib/k8s/configs/server-pvc.yml
View file

@ -2,7 +2,7 @@ apiVersion: v1
kind: PersistentVolumeClaim
metadata:
annotations:
minecluster.dunemask.net/server-name: changeme-server-name
minecluster.dunemask.net/id: changeme-server-id
labels:
service: changeme-service-name
name: changeme-pvc-name

2
lib/k8s/configs/server-svc.yml
View file

@ -4,7 +4,7 @@ metadata:
annotations:
ingress.qumine.io/hostname: changeme-url
ingress.qumine.io/portname: minecraft
minecluster.dunemask.net/server-name: changeme-server-name
minecluster.dunemask.net/id: changeme-server-id
labels:
app: changeme-app
name: changeme-name

58
lib/k8s/k8s-server-control.js
View file

@ -20,10 +20,10 @@ const loadYaml = (f) => yaml.load(fs.readFileSync(path.resolve(f), "utf8"));
const mineclusterManaged = (o) =>
o.metadata &&
o.metadata.annotations &&
o.metadata.annotations["minecluster.dunemask.net/server-name"] !== undefined;
o.metadata.annotations["minecluster.dunemask.net/id"] !== undefined;
export const serverMatch = (serverName) => (o) =>
o.metadata.annotations["minecluster.dunemask.net/server-name"] === serverName;
export const serverMatch = (serverId) => (o) =>
o.metadata.annotations["minecluster.dunemask.net/id"] === serverId;
export async function getDeployments() {
const deploymentRes = await k8sDeps.listNamespacedDeployment(namespace);
@ -50,8 +50,9 @@ export async function getVolumes() {
return serverVolumes;
}
export function getServerAssets(serverName) {
const serverFilter = serverMatch(serverName);
export function getServerAssets(serverId) {
const serverFilter = serverMatch(serverId);
console.log(serverId);
return Promise.all([
getDeployments(),
getServices(),
@ -69,13 +70,9 @@ export function getServerAssets(serverName) {
if (secrets.length > 1) throw Error("Secrets broken!");
const serverAssets = {
deployment: deployments[0],
service: services.find(
(s) => s.metadata.name === `mcl-${serverName}-server`,
),
service: services.find((s) => s.metadata.name.endsWith("-server")),
volume: volumes[0],
rconService: services.find(
(s) => s.metadata.name === `mcl-${serverName}-rcon`,
),
rconService: services.find((s) => s.metadata.name.endsWith("-rcon")),
rconSecret: secrets[0],
};
for (var k in serverAssets) if (serverAssets[k]) return serverAssets;
@ -84,30 +81,29 @@ export function getServerAssets(serverName) {
.catch((e) => ERR("SERVER ASSETS", e));
}
export async function getDeployment(serverName) {
export async function getDeployment(serverId) {
const servers = await getDeployments();
console.log(servers.map(({ metadata }) => metadata.annotations));
const serverDeployment = servers.find(
(s) =>
s.metadata.annotations["minecluster.dunemask.net/server-name"] ===
serverName,
(s) => s.metadata.annotations["minecluster.dunemask.net/id"] === serverId,
);
if (!serverDeployment)
throw Error(`MCL Deployment '${serverName}' could not be found!`);
throw Error(`MCL Deployment with ID '${serverId}' could not be found!`);
return serverDeployment;
}
export async function getContainers(serverName) {
const deployment = await getDeployment(serverName);
export async function getContainers(serverId) {
const deployment = await getDeployment(serverId);
return deployment.spec.template.spec.containers;
}
async function containerControl(serverName, deployment, scaleUp) {
async function containerControl(serverId, deployment, scaleUp) {
const { containers } = deployment.spec.template.spec;
const depFtp = containers.find((c) => c.name.endsWith("-ftp"));
const depServer = containers.find((c) => c.name.endsWith("-server"));
const depBackup = containers.find((c) => c.name.endsWith("-backup"));
const serverSpec = await getServerEntry(serverName);
const serverSpec = await getServerEntry(serverId);
const ftpContainer = depFtp ?? getFtpContainer(serverSpec);
const serverContainer = depServer ?? getCoreServerContainer(serverSpec);
const backupContainer = depBackup ?? getBackupContainer(serverSpec);
@ -115,10 +111,10 @@ async function containerControl(serverName, deployment, scaleUp) {
return [ftpContainer];
}
export async function toggleServer(serverName, scaleUp = false) {
const deployment = await getDeployment(serverName);
export async function toggleServer(serverId, scaleUp = false) {
const deployment = await getDeployment(serverId);
deployment.spec.template.spec.containers = await containerControl(
serverName,
serverId,
deployment,
scaleUp,
);
@ -128,19 +124,3 @@ export async function toggleServer(serverName, scaleUp = false) {
deployment,
);
}
export async function scaleDeployment(serverName, scaleUp = false) {
const deployment = await getDeployment(serverName);
if (deployment.spec.replicas === 1 && scaleUp)
return VERB(
"KSC",
`MCL Deployment '${serverName}' is already scaled! Ignoring scale adjustment.`,
);
deployment.spec.replicas = scaleUp ? 1 : 0;
return k8sDeps.replaceNamespacedDeployment(
deployment.metadata.name,
namespace,
deployment,
);
}

14
lib/k8s/server-containers.js
View file

@ -4,9 +4,9 @@ import yaml from "js-yaml";
const loadYaml = (f) => yaml.load(fs.readFileSync(path.resolve(f), "utf8"));
export function getFtpContainer(serverSpec) {
const { name } = serverSpec;
const { mclName } = serverSpec;
const ftpContainer = loadYaml("lib/k8s/configs/containers/ftp-server.yml");
ftpContainer.name = `mcl-${name}-ftp`;
ftpContainer.name = `mcl-${mclName}-ftp`;
const ftpPortList = [
{ p: 20, n: "ftp-data" },
{ p: 21, n: "ftp-commands" },
@ -22,10 +22,10 @@ export function getFtpContainer(serverSpec) {
}
export function getCoreServerContainer(serverSpec) {
const { name, version, serverType, memory } = serverSpec;
const { mclName, version, serverType, memory } = serverSpec;
const container = loadYaml("lib/k8s/configs/containers/minecraft-server.yml");
// Container Updates
container.name = `mcl-${name}-server`;
container.name = `mcl-${mclName}-server`;
container.resources.requests.memory = `${memory}Mi`;
const findEnv = (k) => container.env.find(({ name: n }) => n === k);
@ -36,7 +36,7 @@ export function getCoreServerContainer(serverSpec) {
updateEnv("VERSION", version);
updateEnv("MEMORY", `${memory}M`);
// RCON
const rs = `mcl-${name}-rcon-secret`;
const rs = `mcl-${mclName}-rcon-secret`;
findEnv("RCON_PASSWORD").valueFrom.secretKeyRef.name = rs;
return container;
}
@ -50,13 +50,13 @@ export function getServerContainer(serverSpec) {
const updateEnv = (k, v) => (findEnv(k).value = v);
// Enviornment variables
updateEnv("DIFFICULTY", difficulty);
/*updateEnv("DIFFICULTY", difficulty);
updateEnv("MODE", gamemode);
updateEnv("MOTD", motd);
updateEnv("MAX_PLAYERS", maxPlayers);
updateEnv("SEED", seed);
updateEnv("OPS", ops);
updateEnv("WHITELIST", whitelist);
updateEnv("WHITELIST", whitelist); */
return container;
}

83
lib/k8s/server-control.js
View file

@ -1,51 +1,42 @@
import k8s from "@kubernetes/client-node";
import {
getDeployment,
getDeployments,
getServerAssets,
scaleDeployment,
} from "./k8s-server-control.js";
import { ERR } from "../util/logging.js";
import ExpressClientError from "../util/ExpressClientError.js";
import { getDeployments } from "./k8s-server-control.js";
const kc = new k8s.KubeConfig();
kc.loadFromDefault();
const k8sMetrics = new k8s.Metrics(kc);
const namespace = process.env.MCL_SERVER_NAMESPACE;
export async function startServerContainer(serverSpec) {
const { name } = serverSpec;
try {
await scaleDeployment(name, true);
} catch (e) {
ERR("SERVER CONTROL", e);
throw new ExpressClientError({
c: 500,
m: `Error updating server '${name}'!\n`,
});
}
}
function getServerMetrics(podMetricsRes, serverId, serverAvailable) {
const pod = podMetricsRes.items.find(({ metadata: md }) => {
return (
md.annotations &&
md.annotations["minecluster.dunemask.net/id"] === serverId
);
});
export async function stopServerContainer(serverSpec) {
const { name } = serverSpec;
try {
await scaleDeployment(name, false);
} catch (e) {
ERR("SERVER CONTROL", e);
throw new ExpressClientError({
c: 500,
m: `Error updating server '${name}'!`,
});
if (serverAvailable && pod) {
const podCpus = pod.containers.map(
({ usage }) => parseInt(usage.cpu) / 1_000_000,
);
const podMems = pod.containers.map(
({ usage }) => parseInt(usage.memory) / 1024,
);
metrics = {
cpu: Math.ceil(podCpus.reduce((a, b) => a + b)),
memory: Math.ceil(podMems.reduce((a, b) => a + b)),
};
}
}
export async function getInstances() {
const serverDeployments = await getDeployments();
const podMetricsResponse = await k8sMetrics.getPodMetrics(namespace);
var name, metrics, services, serverAvailable, ftpAvailable;
const podMetricsRes = await k8sMetrics.getPodMetrics(namespace);
var name, serverId, metrics, services, serverAvailable, ftpAvailable;
const serverInstances = serverDeployments.map((s) => {
name = s.metadata.annotations["minecluster.dunemask.net/server-name"];
serverId = s.metadata.annotations["minecluster.dunemask.net/id"];
name = s.metadata.name;
metrics = null;
const { containers } = s.spec.template.spec;
services = containers.map(({ name }) => name.split("-").pop());
const serverStatusList = s.status.conditions.map(
@ -57,23 +48,15 @@ export async function getInstances() {
) !== undefined;
serverAvailable = services.includes(`server`) && deploymentAvailable;
ftpAvailable = services.includes("ftp") && deploymentAvailable;
const pod = podMetricsResponse.items.find(({ metadata: md }) => {
return md.labels && md.labels.app && md.labels.app === `mcl-${name}-app`;
});
if (serverAvailable && pod) {
const podCpus = pod.containers.map(
({ usage }) => parseInt(usage.cpu) / 1_000_000,
);
const podMems = pod.containers.map(
({ usage }) => parseInt(usage.memory) / 1024,
);
metrics = {
cpu: Math.ceil(podCpus.reduce((a, b) => a + b)),
memory: Math.ceil(podMems.reduce((a, b) => a + b)),
};
}
return { name, metrics, services, serverAvailable, ftpAvailable };
metrics = getServerMetrics(podMetricsRes, serverId, serverAvailable);
return {
name,
id: serverId,
metrics,
services,
serverAvailable,
ftpAvailable,
};
});
return serverInstances;
}

80
lib/k8s/server-create.js
View file

@ -4,7 +4,7 @@ import k8s from "@kubernetes/client-node";
import yaml from "js-yaml";
import fs from "node:fs";
import path from "node:path";
import ExpressClientError from "../util/ExpressClientError.js";
import {
getFtpContainer,
getServerContainer,
@ -20,32 +20,31 @@ const namespace = process.env.MCL_SERVER_NAMESPACE;
const loadYaml = (f) => yaml.load(fs.readFileSync(path.resolve(f), "utf8"));
function createRconSecret(serverSpec) {
const { name } = serverSpec;
const { mclName, id } = serverSpec;
const rconYaml = loadYaml("lib/k8s/configs/rcon-secret.yml");
// TODO: Dyamic rconPassword
const rconPassword = bcrypt.hashSync(uuidv4(), 10);
rconYaml.data["rcon-password"] = Buffer.from(rconPassword).toString("base64");
rconYaml.metadata.labels.app = `mcl-${name}-app`;
rconYaml.metadata.name = `mcl-${name}-rcon-secret`;
rconYaml.metadata.labels.app = `mcl-${mclName}-app`;
rconYaml.metadata.name = `mcl-${mclName}-rcon-secret`;
rconYaml.metadata.namespace = namespace;
rconYaml.metadata.annotations["minecluster.dunemask.net/server-name"] = name;
rconYaml.metadata.annotations["minecluster.dunemask.net/id"] = id;
return rconYaml;
}
function createServerVolume(serverSpec) {
const { name } = serverSpec;
const { mclName, id } = serverSpec;
const volumeYaml = loadYaml("lib/k8s/configs/server-pvc.yml");
volumeYaml.metadata.labels.service = `mcl-${name}-server`;
volumeYaml.metadata.name = `mcl-${name}-volume`;
volumeYaml.metadata.labels.service = `mcl-${mclName}-server`;
volumeYaml.metadata.name = `mcl-${mclName}-volume`;
volumeYaml.metadata.namespace = namespace;
volumeYaml.metadata.annotations["minecluster.dunemask.net/server-name"] =
name;
volumeYaml.metadata.annotations["minecluster.dunemask.net/id"] = id;
volumeYaml.spec.resources.requests.storage = "1Gi"; // TODO: Changeme
return volumeYaml;
}
function createServerDeploy(serverSpec) {
const { name, host } = serverSpec;
const { mclName, id } = serverSpec;
const deployYaml = loadYaml("lib/k8s/configs/server-deployment.yml");
const { metadata } = deployYaml;
const serverContainer = getServerContainer(serverSpec);
@ -53,19 +52,21 @@ function createServerDeploy(serverSpec) {
const ftpContainer = getFtpContainer(serverSpec);
// Configure Metadata;
metadata.name = `mcl-${name}`;
metadata.name = `mcl-${mclName}`;
metadata.namespace = namespace;
metadata.annotations["minecluster.dunemask.net/server-name"] = name;
metadata.annotations["minecluster.dunemask.net/id"] = id;
deployYaml.metadata = metadata;
// Configure Lables & Selectors
deployYaml.spec.selector.matchLabels.app = `mcl-${name}-app`;
deployYaml.spec.template.metadata.labels.app = `mcl-${name}-app`;
deployYaml.spec.selector.matchLabels.app = `mcl-${mclName}-app`;
deployYaml.spec.template.metadata.labels.app = `mcl-${mclName}-app`;
deployYaml.spec.template.metadata.annotations["minecluster.dunemask.net/id"] =
id;
// Volumes
deployYaml.spec.template.spec.volumes.find(
({ name }) => name === "datadir",
).persistentVolumeClaim.claimName = `mcl-${name}-volume`;
).persistentVolumeClaim.claimName = `mcl-${mclName}-volume`;
// Apply Containers TODO: User control for autostart
deployYaml.spec.template.spec.containers.push(serverContainer);
@ -75,17 +76,16 @@ function createServerDeploy(serverSpec) {
}
function createServerService(serverSpec) {
const { name, host } = serverSpec;
const { mclName, host, id } = serverSpec;
const serviceYaml = loadYaml("lib/k8s/configs/server-svc.yml");
serviceYaml.metadata.annotations["ingress.qumine.io/hostname"] = host;
serviceYaml.metadata.annotations["mc-router.itzg.me/externalServerName"] =
host;
serviceYaml.metadata.labels.app = `mcl-${name}-app`;
serviceYaml.metadata.name = `mcl-${name}-server`;
serviceYaml.metadata.labels.app = `mcl-${mclName}-app`;
serviceYaml.metadata.name = `mcl-${mclName}-server`;
serviceYaml.metadata.namespace = namespace;
serviceYaml.metadata.annotations["minecluster.dunemask.net/server-name"] =
name;
serviceYaml.spec.selector.app = `mcl-${name}-app`;
serviceYaml.metadata.annotations["minecluster.dunemask.net/id"] = id;
serviceYaml.spec.selector.app = `mcl-${mclName}-app`;
// Port List:
const serverPortList = [{ p: 25565, n: "minecraft" }];
@ -107,32 +107,26 @@ function createServerService(serverSpec) {
return serviceYaml;
}
function createRconService(serverSpec) {
const { name } = serverSpec;
function createRconService(createSpec) {
const { id, mclName } = createSpec;
const rconSvcYaml = loadYaml("lib/k8s/configs/rcon-svc.yml");
rconSvcYaml.metadata.labels.app = `mcl-${name}-app`;
rconSvcYaml.metadata.name = `mcl-${name}-rcon`;
rconSvcYaml.metadata.labels.app = `mcl-${mclName}-app`;
rconSvcYaml.metadata.name = `mcl-${mclName}-rcon`;
rconSvcYaml.metadata.namespace = namespace;
rconSvcYaml.metadata.annotations["minecluster.dunemask.net/server-name"] =
name;
rconSvcYaml.spec.selector.app = `mcl-${name}-app`;
rconSvcYaml.metadata.annotations["minecluster.dunemask.net/id"] = id;
rconSvcYaml.spec.selector.app = `mcl-${mclName}-app`;
return rconSvcYaml;
}
export default async function createServerResources(serverSpec) {
const deploymentRes = await k8sDeps.listNamespacedDeployment(namespace);
const deployments = deploymentRes.body.items.map((i) => i.metadata.name);
if (deployments.includes(`mcl-${serverSpec.name}`))
throw new ExpressClientError({ m: "Server already exists!", c: 409 });
const pvcRes = await k8sCore.listNamespacedPersistentVolumeClaim(namespace);
const pvcs = pvcRes.body.items.map((i) => i.metadata.name);
if (pvcs.includes(`mcl-${serverSpec.name}-volume`))
throw new ExpressClientError({ m: "Server PVC already exists!", c: 409 });
const rconSecret = createRconSecret(serverSpec);
const serverVolume = createServerVolume(serverSpec);
const serverDeploy = createServerDeploy(serverSpec);
const serverService = createServerService(serverSpec);
const rconService = createRconService(serverSpec);
export default async function createServerResources(createSpec) {
createSpec.mclName = `${createSpec.host.replaceAll(".", "-")}-${
createSpec.id
}`;
const rconSecret = createRconSecret(createSpec);
const serverVolume = createServerVolume(createSpec);
const serverDeploy = createServerDeploy(createSpec);
const serverService = createServerService(createSpec);
const rconService = createRconService(createSpec);
k8sCore.createNamespacedPersistentVolumeClaim(namespace, serverVolume);
k8sCore.createNamespacedSecret(namespace, rconSecret);
k8sCore.createNamespacedService(namespace, serverService);

4
lib/k8s/server-delete.js
View file

@ -22,9 +22,9 @@ function deleteOnExist(o, fn) {
}
export default async function deleteServerResources(serverSpec) {
const { name } = serverSpec;
const { id } = serverSpec;
// Ensure deployment exists
const server = await getServerAssets(name);
const server = await getServerAssets(id);
if (!server)
throw new ExpressClientError({
c: 404,

4
lib/k8s/server-files.js
View file

@ -34,8 +34,8 @@ export async function getFtpClient(serverService) {
}
export async function useServerFtp(serverSpec, fn) {
const { name } = serverSpec;
const server = await getServerAssets(name);
const { id } = serverSpec;
const server = await getServerAssets(id);
if (!server)
throw new ExpressClientError({
c: 404,

12
src/components/files/MineclusterFiles.jsx
View file

@ -33,14 +33,14 @@ export default function MineclusterFiles(props) {
],
[],
);
const { server: serverName } = props;
const { server: serverId } = props;
const inputRef = useRef(null);
const [dirStack, setDirStack] = useState(["."]);
const [files, setFiles] = useState([]);
const updateFiles = () => {
const dir = dirStack.join("/");
getServerFiles(serverName, dir).then((f) => {
getServerFiles(serverId, dir).then((f) => {
const files = f.map((fi) => ({ ...fi, id: `${dir}/${fi.name}` }));
setFiles(files ?? []);
});
@ -70,13 +70,13 @@ export default function MineclusterFiles(props) {
function createFolder() {
const name = prompt("What is the name of the new folder?");
const path = [...dirStack, name].join("/");
createServerFolder(serverName, path).then(updateFiles);
createServerFolder(serverId, path).then(updateFiles);
}
function deleteItems(files) {
Promise.all(
files.map((f) =>
deleteServerItem(serverName, [...dirStack, f.name].join("/"), f.isDir),
deleteServerItem(serverId, [...dirStack, f.name].join("/"), f.isDir),
),
)
.catch((e) => console.error("Error deleting some files!", e))
@ -94,7 +94,7 @@ export default function MineclusterFiles(props) {
async function uploadFile(file) {
const formData = new FormData();
formData.append("file", file);
formData.append("name", serverName);
formData.append("id", serverId);
formData.append("path", [...dirStack, name].join("/"));
await fetch("/api/files/upload", {
method: "POST",
@ -105,7 +105,7 @@ export default function MineclusterFiles(props) {
async function downloadFiles(files) {
Promise.all(
files.map((f) =>
getServerItem(serverName, f.name, [...dirStack, f.name].join("/")),
getServerItem(serverId, f.name, [...dirStack, f.name].join("/")),
),
)
.then(() => console.log("Done downloading files!"))

5
src/components/servers/RconDialog.jsx
View file

@ -16,7 +16,8 @@ export function useRconDialog(isOpen = false) {
}
export default function RconDialog(props) {
const { serverName, open, dialogToggle } = props;
const { server, open, dialogToggle } = props;
const { name: serverName, id: serverId } = server ?? {};
const theme = useTheme();
const fullScreen = useMediaQuery(theme.breakpoints.down("sm"));
return (
@ -33,7 +34,7 @@ export default function RconDialog(props) {
<Toolbar sx={{ display: { sm: "none" } }} />
<DialogTitle>RCON - {serverName}</DialogTitle>
<DialogContent>
<RconView serverName={serverName} />
<RconView serverId={serverId} />
</DialogContent>
<DialogActions>
<Button autoFocus onClick={dialogToggle}>

4
src/components/servers/RconSocket.js
View file

@ -1,7 +1,7 @@
import { io } from "socket.io-client";
export default class RconSocket {
constructor(logUpdate, serverName) {
(this.sk = io("/", { query: { serverName } })), (this.logs = []);
constructor(logUpdate, serverId) {
(this.sk = io("/", { query: { serverId } })), (this.logs = []);
this.logUpdate = logUpdate;
this.sk.on("push", this.onPush.bind(this));
this.sk.on("connect", this.onConnect.bind(this));

4
src/components/servers/RconView.jsx
View file

@ -6,14 +6,14 @@ import RconSocket from "./RconSocket.js";
import "@mcl/css/rcon.css";
export default function RconView(props) {
const { serverName } = props;
const { serverId } = props;
const logsRef = useRef(0);
const [cmd, setCmd] = useState("");
const [logs, setLogs] = useState([]);
const [rcon, setRcon] = useState({});
const updateCmd = (e) => setCmd(e.target.value);
useEffect(function () {
setRcon(new RconSocket(setLogs, serverName));
setRcon(new RconSocket(setLogs, serverId));
return () => {
if (rcon && typeof rcon.disconnect === "function") rcon.disconnect();
};

12
src/components/servers/ServerCard.jsx
View file

@ -19,10 +19,10 @@ import { Link } from "react-router-dom";
export default function ServerCard(props) {
const { server, openRcon } = props;
const { name, metrics, ftpAvailable, serverAvailable, services } = server;
const startServer = useStartServer(name);
const stopServer = useStopServer(name);
const deleteServer = useDeleteServer(name);
const { name, id, metrics, ftpAvailable, serverAvailable, services } = server;
const startServer = useStartServer(id);
const stopServer = useStopServer(id);
const deleteServer = useDeleteServer(id);
function toggleRcon() {
if (!services.includes("server")) return;
openRcon();
@ -113,7 +113,7 @@ export default function ServerCard(props) {
aria-label="Edit"
size="large"
component={Link}
to={`/mcl/edit?server=${name}`}
to={`/mcl/edit?server=${id}`}
>
<EditIcon />
</IconButton>
@ -122,7 +122,7 @@ export default function ServerCard(props) {
aria-label="Files"
size="large"
component={Link}
to={`/mcl/files?server=${name}`}
to={`/mcl/files?server=${id}`}
disabled={!services.includes("ftp")}
>
<FolderIcon />

4
src/pages/Home.jsx
View file

@ -50,10 +50,10 @@ export default function Home() {
<Box className="servers">
{!isLoading &&
servers.map((s, k) => (
<ServerCard key={k} server={s} openRcon={openRcon(s.name)} />
<ServerCard key={k} server={s} openRcon={openRcon(s)} />
))}
</Box>
<RconDialog open={rdOpen} dialogToggle={rconToggle} serverName={server} />
<RconDialog open={rdOpen} dialogToggle={rconToggle} server={server} />
<Button
component={Link}
to="/mcl/create"

40
src/util/queries.js
View file

@ -20,38 +20,38 @@ const fetchApiPost = (subPath, json) => async () =>
body: JSON.stringify(json),
}).then((res) => res.json());
export const useServerStatus = (server) =>
export const useServerStatus = (serverId) =>
useQuery({
queryKey: [`server-status-${server}`],
queryFn: fetchApiPost("/server/status", { name: server }),
queryKey: [`server-status-${serverId}`],
queryFn: fetchApiPost("/server/status", { id: serverId }),
});
export const useServerMetrics = (server) =>
export const useServerMetrics = (serverId) =>
useQuery({
queryKey: [`server-metrics-${server}`],
queryFn: fetchApiPost("/server/metrics", { name: server }),
queryKey: [`server-metrics-${serverId}`],
queryFn: fetchApiPost("/server/metrics", { id: serverId }),
refetchInterval: 10000,
});
export const useStartServer = (server) =>
postJsonApi("/server/start", { name: server }, "server-instances");
export const useStopServer = (server) =>
postJsonApi("/server/stop", { name: server }, "server-instances");
export const useDeleteServer = (server) =>
postJsonApi("/server/delete", { name: server }, "server-instances", "DELETE");
export const useStartServer = (serverId) =>
postJsonApi("/server/start", { id: serverId }, "server-instances");
export const useStopServer = (serverId) =>
postJsonApi("/server/stop", { id: serverId }, "server-instances");
export const useDeleteServer = (serverId) =>
postJsonApi("/server/delete", { id: serverId }, "server-instances", "DELETE");
export const useCreateServer = (spec) =>
postJsonApi("/server/create", spec, "server-list");
export const getServerFiles = async (server, path) =>
fetchApiCore("/files/list", { name: server, path }, "POST", true);
export const createServerFolder = async (server, path) =>
export const getServerFiles = async (serverId, path) =>
fetchApiCore("/files/list", { id: serverId, path }, "POST", true);
export const createServerFolder = async (serverId, path) =>
fetchApiCore("/files/folder", {
name: server,
id: serverId,
path,
});
export const deleteServerItem = async (server, path, isDir) =>
fetchApiCore("/files/item", { name: server, path, isDir }, "DELETE");
export const deleteServerItem = async (serverId, path, isDir) =>
fetchApiCore("/files/item", { id: serverId, path, isDir }, "DELETE");
export const getServerItem = async (server, name, path) =>
fetchApiCore("/files/item", { name: server, path })
export const getServerItem = async (serverId, name, path) =>
fetchApiCore("/files/item", { id: serverId, path })
.then((resp) =>
resp.status === 200
? resp.blob()