personal/q3k/minecraft/prod.jsonnet

local kube = import "../../../kube/kube.libsonnet";
local defaultWorldguardConfig = import "worldguard.libsonnet";

{
    local minecraft = self,
    versions:: {
        "spigot-1.16.1": "registry.k0.hswaw.net/q3k/minecraft:spigot-1.16.1-r2",
        "paper-1.16.1": "registry.k0.hswaw.net/q3k/minecraft:paper-1.16.1-r2",
        "paper-1.16.4": "registry.k0.hswaw.net/q3k/minecraft:paper-1.16.4-r1",
        "paper-1.16.5": "registry.k0.hswaw.net/q3k/minecraft:paper-1.16.5-r2",
    },
    server(name, version):: {
        local server = self,
        name:: name,
        version:: version,
        image:: minecraft.versions[server.version],
        worldedit:: true,
        overviewer:: true,

        metadata:: {
            namespace: "minecraft",
        },

        componentName(component):: "%s-%s" % [server.name, component],

        properties:: {
            "spawn-protection": 16,
            "max-tick-time": 60000,
            "query.port": 25565,
            "generator-settings": "",
            "force-gamemode": false,
            "allow-nether": true,
            "enforce-whitelist": false,
            "gamemode": "survival",
            "broadcast-console-to-ops": true,
            "enable-query": false,
            "player-idle-timeout": 0,
            "difficulty": "easy",
            "broadcast-rcon-to-ops": true,
            "spawn-monsters": true,
            "op-permission-level": 4,
            "pvp": true,
            "snooper-enabled": true,
            "level-type": "default",
            "hardcore": false,
            "enable-command-block": false,
            "network-compression-threshold": 256,
            "max-players": 20,
            "max-world-size": 29999984,
            "resource-pack-sha1": "",
            "function-permission-level": 2,
            "rcon.port": 25575,
            "server-port": 25565,
            "debug": false,
            "server-ip": "",
            "spawn-npcs": true,
            "allow-flight": false,
            "level-name": "world",
            "view-distance": 10,
            "resource-pack": "",
            "spawn-animals": true,
            "white-list": false,
            "rcon.password": "",
            "generate-structures": true,
            "online-mode": true,
            "max-build-height": 256,
            "level-seed": "",
            "prevent-proxy-connections": false,
            "use-native-transport": true,
            "motd": "A Minecraft Server",
            "enable-rcon": false,
        },

        worldguardConfig:: defaultWorldguardConfig,

        startSteps:: [
        ] + (if server.worldedit then [
            "mkdir -p plugins/WorldGuard",
            "cp /home/minecraft/worldedit-*.jar plugins",
            "cp /home/minecraft/worldguard-*.jar plugins",
            "cp /home/minecraft/config/worldguard_config.yaml plugins/WorldGuard/config.yml",
        ] else []),

        startsh:: |||
            #!/usr/bin/env bash
            cd /home/minecraft/world
            cp /home/minecraft/config/server.properties .
            cp /home/minecraft/server.jar .
            echo "eula=true" > eula.txt
            %s

            bash /home/minecraft/config/overviewer.sh &
            exec java -Xmx4G -Xms4G -jar server.jar
        ||| % [std.join("\n", server.startSteps)],

        overviewersh:: |||
            #!/usr/bin/env bash
            mkdir -p overviewer/world
            sleep 60
            while true; do
                echo "Rendering Overviewer map..."
                overviewer.py -p 1 --rendermodes=normal,lighting,smooth-lighting,cave world overviewer/world
                echo "Done."
                sleep 900
            done
        |||,

        secretProperties: kube.Secret(server.componentName("properties")) {
            metadata+: server.metadata,
            data: {
                local properties = std.join("\n", ["%s=%s" % [k, std.toString(server.properties[k])] for k in std.objectFields(server.properties)]),
                "server.properties": std.base64(properties),
                "start.sh": std.base64(server.startsh),
            } + (if server.worldedit then {
                local worldguardConfig = std.manifestYamlDoc(server.worldguardConfig),
                "worldguard_config.yaml": std.base64(worldguardConfig),
            } else {} )+ (if server.overviewer then {
                "overviewer.sh": std.base64(server.overviewersh),
            } else {}),
        },

        worldVolume: kube.PersistentVolumeClaim(server.componentName("world")) {
            metadata+: server.metadata,
            spec+: {
                storageClassName: "waw-hdd-redundant-3",
                accessModes: ["ReadWriteOnce"],
                resources: {
                    requests: {
                        storage: "10Gi",
                    },
                },
            },
        },

        deploy: kube.Deployment(server.componentName("deploy")) {
            metadata+: server.metadata,
            spec+: {
                template+: {
                    spec+: {
                        volumes_: {
                            config: kube.SecretVolume(server.secretProperties),
                            world: kube.PersistentVolumeClaimVolume(server.worldVolume),
                        },
                        containers_: {
                            default: kube.Container("default") {
                                image: server.image,
                                command: [
                                    "bash", "/home/minecraft/config/start.sh",
                                ],
                                volumeMounts_: {
                                    config: { mountPath: "/home/minecraft/config" },
                                    world: { mountPath: "/home/minecraft/world" },
                                },
                                ports_: {
                                    minecraft: { containerPort: 25565 },
                                    grpc: { containerPort: 2137 },
                                },
                                resources: {
                                    requests: {
                                        memory: "6G",
                                        cpu: "2",
                                    },
                                    limits: {
                                        memory: "6G",
                                        cpu: "4",
                                    },
                                },
                            },
                            bridge: kube.Container("bridge") {
                                image: "registry.k0.hswaw.net/q3k/minecraft-hscloud-bridge:20200518c",
                                command: [
                                    "/personal/q3k/minecraft/plugin/hscloud/bridge/bridge",
                                    "-plugin", "127.0.0.1:2137",
                                ],
                                ports_: {
                                    bridge: { containerPort: 8081 },
                                },
                            },
                        } + (if server.overviewer then {
                            overviewer: kube.Container("overviewer") {
                                image: "halverneus/static-file-server:v1.8.0",
                                env_: {
                                    FOLDER: "/home/minecraft/world/overviewer/world",
                                },
                                volumeMounts_: {
                                    world: { mountPath: "/home/minecraft/world" },
                                },
                                ports_: {
                                    web: { containerPort: 8080 },
                                },
                            },
                        } else {}),
                    },
                },
            },
        },

        svc: kube.Service(server.componentName("svc")) {
            metadata+: server.metadata,
            target_pod:: server.deploy.spec.template,
            spec+: {
                ports: [
                    { name: "minecraft", port: 25565, targetPort: 25565, protocol: "TCP" },
                    { name: "web", port: 80, targetPort: 8080, protocol: "TCP" },
                    { name: "bridge", port: 8080, targetPort: 8081, protocol: "TCP" },
                    { name: "grpc", port: 2137, targetPort: 2137, protocol: "TCP" },
                ],
                type: "LoadBalancer",
                externalTrafficPolicy: "Local",
            },
        },
    },

    ns: kube.Namespace("minecraft"),

    q3k: {
        "nova-arcana": minecraft.server("q3k-nova-arcana", "paper-1.16.5") {
            overviewer: false,
            worldedit: false,
            properties+: {
                motd: "Nova Arcana V1.1.4",
                //"enforce-whitelist": true,
                "enable-rcon": "true",
                "rcon.password": "dupa.8",
            },
            startSteps+: [
                |||
                    if [ ! -e world/map-installed.txt ]; then
                        set -e -x
                        mkdir -p world
                        cd world
                        rm -rf *
                        wget https://object.ceph-waw3.hswaw.net/q3k-personal/f1a73ad0518a2629a5bed072a7de4e4534a3c89705d6cea2f203a05cccd01634.zip -O map.zip
                        unzip -o map.zip
                        mv Untold*/* .
                        rm -rf Untold*
                        rm map.zip
                        touch map-installed.txt
                        ls -la
                        cd ..
                        set +e +x
                    fi
                |||
            ],
        },
    },
}