minecluster/lib/k8s/server-control.js

import k8s from "@kubernetes/client-node";
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;

function getServerMetrics(podMetricsRes, serverId, serverAvailable) {
  const pod = podMetricsRes.items.find(({ metadata: md }) => {
    return (
      md.annotations &&
      md.annotations["minecluster.dunemask.net/id"] === serverId
    );
  });

  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 podMetricsRes = await k8sMetrics.getPodMetrics(namespace);
  var name, serverId, metrics, services, serverAvailable, ftpAvailable;
  const serverInstances = serverDeployments.map((s) => {
    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(
      ({ type: statusType, status: sts }) => ({ statusType, sts }),
    );
    const deploymentAvailable =
      serverStatusList.find(
        (ss) => ss.statusType === "Available" && ss.sts === "True",
      ) !== undefined;
    serverAvailable = services.includes(`server`) && deploymentAvailable;
    ftpAvailable = services.includes("ftp") && deploymentAvailable;
    metrics = getServerMetrics(podMetricsRes, serverId, serverAvailable);
    return {
      name,
      id: serverId,
      metrics,
      services,
      serverAvailable,
      ftpAvailable,
    };
  });
  return serverInstances;
}

export async function getNamespaceMetrics() {
  const serverInstances = await getInstances();
  var clusterMetrics = { cpu: 0, memory: 0 };
  if (servers.length > 1) {
    const clusterCpu = serverInstances
      .map(({ metrics }) => (metrics ? metrics.cpu : 0))
      .reduce((a, b) => a + b);
    const clusterMem = serverInstances
      .map(({ metrics }) => (metrics ? metrics.memory : 0))
      .reduce((a, b) => a + b);
    clusterMetrics = { cpu: clusterCpu, memory: clusterMem };
  }
  return clusterMetrics;
}