feat: DNS switcher

DNS switcher switches the external DNS to
internal DNS that is organized per cluster
which allows for HA. This task includes
waiting for the DNS propagation (locally)
to finish

nix/env.nix

@@ -23,6 +23,7 @@ with packages;
     terraform
     bun
     curl
+    dogdns
   ];
 
   lint = [

nix/packages.nix

@@ -21,6 +21,7 @@ let
       {
         inherit
           coreutils
+          dogdns
           sd
           curl
           bash

src/init/tasks.ts

@@ -5,8 +5,10 @@ import { SulfoxideBoronWaiter } from '../tasks/sulfoxide-boron-waiter.ts';
 import { SERVICE_TREE } from '../lib/service-tree.ts';
 import { SulfoxideXenonWaiter } from '../tasks/sulfoxide-xenon-waiter.ts';
 import { SulfoxideFluorineCreator } from '../tasks/sulfoxide-fluorine-creator.ts';
+import { LoadBalancerDNSSwitcher } from "../tasks/lb-dns-switcher.ts";
 
 interface TaskGenerator {
+  lbDNSSwitcher: LoadBalancerDNSSwitcher;
   nitrosoWaiter: NitrosoWaiter;
   sulfoxideHeliumWaiter: SulfoxideHeliumWaiter;
   sulfoxideBoronWaiter: SulfoxideBoronWaiter;
@@ -17,6 +19,7 @@ interface TaskGenerator {
 function initTasks(d: Dependencies): TaskGenerator {
   const services = SERVICE_TREE.sulfoxide.services;
   return {
+    lbDNSSwitcher: new LoadBalancerDNSSwitcher("cluster.atomi.cloud","lb.atomi.cloud"),
     nitrosoWaiter: new NitrosoWaiter(d.kubectl, d.httpUtil),
     sulfoxideHeliumWaiter: new SulfoxideHeliumWaiter(d.kubectl, services.argocd),
     sulfoxideBoronWaiter: new SulfoxideBoronWaiter(d.kubectl, services.internal_ingress),

src/tasks/lb-dns-switcher.ts

@@ -0,0 +1,43 @@
+import type { Task } from "./tasks.ts";
+import type { CloudTreeClusterPrincipal } from "../lib/service-tree-def.ts";
+import { $ } from "bun";
+
+class LoadBalancerDNSSwitcher {
+  constructor(
+    private external: string,
+    private internal: string
+  ) {
+  }
+
+  name: string = "Switching DNS for Load Balancing";
+
+  task(from: CloudTreeClusterPrincipal, target: CloudTreeClusterPrincipal): Task {
+    return [
+      this.name,
+      async () => {
+        console.log(`🚧 Switching DNS from ${from.name} to ${target.name}`);
+        const path = `./platforms/sulfoxide/tofu`;
+        await $`nix develop -c pls setup`.cwd(path);
+        await $`nix develop -c pls arceus:apply -- -var="target_cluster=${{ raw: target.slug }}" -auto-approve `.cwd(path);
+        console.log(`✅ DNS now points to ${target.name}`);
+        await $`sleep 120`;
+        console.log("🔍 Checking if DNS has propagated...");
+        const query = async (): Promise<string> => {
+          const result = await $`dog pichu.${this.external} -J`.cwd(path).json();
+          const answers: { name: string, type: string, data: { domain: string } }[] = result.responses[0].answers;
+          return answers.find(x => x.type === "CNAME")?.data.domain ?? "";
+        };
+        const t = `${target.slug}.${this.internal}`;
+        let domain = await query();
+        while (domain != t) {
+          console.log(`⏳ Waiting for DNS to propagate...`);
+          await $`sleep 5`;
+          domain = await query();
+        }
+        console.log(`✅ DNS propagated!`);
+      }
+    ];
+  }
+}
+
+export { LoadBalancerDNSSwitcher };