Minikura/packages/k8s-operator/src/resources/reverseProxyServer.ts

import type * as k8s from "@kubernetes/client-node";
import type { ReverseProxyServerType } from "@minikura/db";
import { LABEL_PREFIX } from "../config/constants";
import { calculateJavaMemory, convertToK8sFormat } from "../utils/memory";
import type { ReverseProxyConfig } from "../types";

export async function createReverseProxyServer(
  server: ReverseProxyConfig,
  appsApi: k8s.AppsV1Api,
  coreApi: k8s.CoreV1Api,
  _networkingApi: k8s.NetworkingV1Api,
  namespace: string
): Promise<void> {
  console.log(`Creating reverse proxy server ${server.id} in namespace '${namespace}'`);

  const serverType = server.type.toLowerCase();
  const serverName = `${serverType}-${server.id}`;

  const configMap = {
    apiVersion: "v1",
    kind: "ConfigMap",
    metadata: {
      name: `${serverName}-config`,
      namespace: namespace,
      labels: {
        app: serverName,
        [`${LABEL_PREFIX}/server-type`]: serverType,
        [`${LABEL_PREFIX}/proxy-id`]: server.id,
      },
    },
    data: {
      "minikura-api-key": server.apiKey,
    },
  };

  try {
    await coreApi.createNamespacedConfigMap({ namespace, body: configMap });
    console.log(`Created ConfigMap for reverse proxy server ${server.id}`);
  } catch (error: any) {
    if (error.response?.statusCode === 409) {
      await coreApi.replaceNamespacedConfigMap({ name: `${serverName}-config`, namespace, body: configMap });
      console.log(`Updated ConfigMap for reverse proxy server ${server.id}`);
    } else {
      throw error;
    }
  }

  const service = {
    apiVersion: "v1",
    kind: "Service",
    metadata: {
      name: serverName,
      namespace: namespace,
      labels: {
        app: serverName,
        [`${LABEL_PREFIX}/server-type`]: serverType,
        [`${LABEL_PREFIX}/proxy-id`]: server.id,
      },
    },
    spec: {
      selector: {
        app: serverName,
      },
      ports: [
        {
          port: server.external_port,
          targetPort: server.listen_port,
          protocol: "TCP",
          name: "minecraft",
        },
      ],
      type: "LoadBalancer",
    },
  };

  try {
    await coreApi.createNamespacedService({ namespace, body: service });
    console.log(`Created Service for reverse proxy server ${server.id}`);
  } catch (error: any) {
    if (error.response?.statusCode === 409) {
      await coreApi.replaceNamespacedService({ name: serverName, namespace, body: service });
      console.log(`Updated Service for reverse proxy server ${server.id}`);
    } else {
      throw error;
    }
  }

  const deployment = {
    apiVersion: "apps/v1",
    kind: "Deployment",
    metadata: {
      name: serverName,
      namespace: namespace,
      labels: {
        app: serverName,
        [`${LABEL_PREFIX}/server-type`]: serverType,
        [`${LABEL_PREFIX}/proxy-id`]: server.id,
      },
    },
    spec: {
      replicas: 1,
      selector: {
        matchLabels: {
          app: serverName,
        },
      },
      template: {
        metadata: {
          labels: {
            app: serverName,
            [`${LABEL_PREFIX}/server-type`]: serverType,
            [`${LABEL_PREFIX}/proxy-id`]: server.id,
          },
        },
        spec: {
          containers: [
            {
              name: serverType,
              image: "itzg/mc-proxy:latest",
              ports: [
                {
                  containerPort: server.listen_port,
                  name: "minecraft",
                },
              ],
              env: [
                {
                  name: "TYPE",
                  value: server.type,
                },
                {
                  name: "NETWORKADDRESS_CACHE_TTL",
                  value: "30",
                },
                {
                  name: "MEMORY",
                  value: calculateJavaMemory(server.memory || "512M", 0.8),
                },
                ...(server.env_variables || []).map((ev) => ({
                  name: ev.key,
                  value: ev.value,
                })),
              ],
              readinessProbe: {
                tcpSocket: {
                  port: server.listen_port,
                },
                initialDelaySeconds: 30,
                periodSeconds: 10,
              },
              resources: {
                requests: {
                  memory: convertToK8sFormat(server.memory || "512M"),
                  cpu: "250m",
                },
                limits: {
                  memory: convertToK8sFormat(server.memory || "512M"),
                  cpu: "500m",
                },
              },
            },
          ],
        },
      },
    },
  };

  try {
    await appsApi.createNamespacedDeployment({ namespace, body: deployment });
    console.log(`Created Deployment for reverse proxy server ${server.id}`);
  } catch (error: any) {
    if (error.response?.statusCode === 409) {
      await appsApi.replaceNamespacedDeployment({ name: serverName, namespace, body: deployment });
      console.log(`Updated Deployment for reverse proxy server ${server.id}`);
    } else {
      throw error;
    }
  }
}

export async function deleteReverseProxyServer(
  proxyId: string,
  proxyType: ReverseProxyServerType,
  appsApi: k8s.AppsV1Api,
  coreApi: k8s.CoreV1Api,
  namespace: string
): Promise<void> {
  const serverType = proxyType.toLowerCase();
  const name = `${serverType}-${proxyId}`;

  try {
    await appsApi.deleteNamespacedDeployment({ name, namespace });
    console.log(`Deleted Deployment for reverse proxy server ${proxyId}`);
  } catch (error: any) {
    if (error.response?.statusCode !== 404) {
      console.error(`Error deleting Deployment for reverse proxy server ${proxyId}:`, error);
    }
  }

  try {
    await coreApi.deleteNamespacedService({ name, namespace });
    console.log(`Deleted Service for reverse proxy server ${proxyId}`);
  } catch (error: any) {
    if (error.response?.statusCode !== 404) {
      console.error(`Error deleting Service for reverse proxy server ${proxyId}:`, error);
    }
  }

  try {
    await coreApi.deleteNamespacedConfigMap({ name: `${name}-config`, namespace });
    console.log(`Deleted ConfigMap for reverse proxy server ${proxyId}`);
  } catch (error: any) {
    if (error.response?.statusCode !== 404) {
      console.error(`Error deleting ConfigMap for reverse proxy server ${proxyId}:`, error);
    }
  }
}