feat: Enable HTTPS in iPXE

This is a breaking change as the return type of cluster.nodes has
changed, resulting in old templates potentially no longer working.

.gitea/workflows/committed.yaml

@@ -11,9 +11,9 @@ jobs:
     name: committed
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v6
-      with:
-        fetch-depth: 0
-    - uses: crate-ci/committed@master
-      with:
-        commits: "origin/${{ gitea.base_ref }}..HEAD"
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - uses: crate-ci/committed@v1.1.11
+        with:
+          commits: "origin/${{ gitea.base_ref }}..HEAD"

.pre-commit-config.yaml

@@ -76,6 +76,6 @@ repos:
           glob: .gitea/workflows/*.yaml
 
   - repo: https://github.com/crate-ci/committed
-    rev: v1.1.8
+    rev: v1.1.11
     hooks:
       - id: committed

Cargo.toml

@@ -7,35 +7,38 @@ publish = ["infra"]
 license = "GPL-3.0-or-later"
 
 [workspace]
-members = ["xtask"]
+members = ["ipxe", "xtask"]
 
 [workspace.dependencies]
-schemars = { version = "1.2.1", features = ["semver1"] }
-serde_json = "1.0.149"
+schemars = { version = "1.2.2", features = ["semver1"] }
+serde_json = "1.0.151"
 
 [dependencies]
+async-walkdir = "2.2.0"
 byteorder = "1.5.0"
-clap = { version = "4.6.0", features = ["derive"] }
-clap_complete = "4.6.0"
-gix-discover = { version = "0.55.0", features = ["sha1"] }
-minijinja = { version = "2.18.0", features = ["json", "loader"] }
+clap = { version = "4.6.7", features = ["derive"] }
+clap_complete = "4.6.11"
+futures = "0.3.34"
+gix-discover = { version = "0.56.0", features = ["sha1"] }
+minijinja = { version = "2.24.0", features = ["json", "loader"] }
 netascii = "0.1.0"
 num_enum = "0.7.6"
 optional_struct = "0.5.2"
 regex = "1.13.1"
-reqwest = { version = "0.13.2", default-features = false, features = [
-  "blocking",
-  "stream",
+reqwest = { version = "0.13.5", default-features = false, features = [
   "native-tls",
 ] }
 schemars = { workspace = true }
-semver = { version = "1.0.27", features = ["serde"] }
-serde = { version = "1.0.228", features = ["derive"] }
+semver = { version = "1.0.28", features = ["serde"] }
+serde = { version = "1.0.229", features = ["derive"] }
 serde_json = { workspace = true }
 serde_yaml = "0.9.34"
-thiserror = "2.0.18"
+thiserror = "2.0.21"
 tokio = { version = "1.52.1", features = ["full"] }
-walkdir = "2.5.0"
+ipxe = { path = "./ipxe" }
+axum = { version = "0.8.9", features = ["macros"] }
+socket2 = "0.6.5"
+socket-pktinfo = "0.4.1"
 
 [lib]
 test = false

helios.yaml

@@ -1,210 +0,0 @@
-version: v1alpha1
-debug: false
-persist: true
-machine:
-    type: controlplane
-    token: 6yf327.db3x2zfs5ptbxrst
-    ca:
-        crt: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUJQekNCOHFBREFnRUNBaEVBM0ZXN0JrK21pK3h5TFk4V29pNFNqVEFGQmdNclpYQXdFREVPTUF3R0ExVUUKQ2hNRmRHRnNiM013SGhjTk1qVXhNVEE1TURJek9USXdXaGNOTXpVeE1UQTNNREl6T1RJd1dqQVFNUTR3REFZRApWUVFLRXdWMFlXeHZjekFxTUFVR0F5dGxjQU1oQUJvSDVycnRxT3BaakRuaU5scXppOVRlT2c0OW4zMzBtcVp4CjVySXRYVEJJbzJFd1h6QU9CZ05WSFE4QkFmOEVCQU1DQW9Rd0hRWURWUjBsQkJZd0ZBWUlLd1lCQlFVSEF3RUcKQ0NzR0FRVUZCd01DTUE4R0ExVWRFd0VCL3dRRk1BTUJBZjh3SFFZRFZSME9CQllFRkkwcDJYT0pmTVE5SUV0eQpqZzlRYlk0VnJPbGZNQVVHQXl0bGNBTkJBQXkvYlFLYmxZSEtYb0QrZE1NWU1zZmY0QjkzWFJIR29ZWmpGM2lKCnp5R3lXdkh0SnYzdEY3aVJrOG9ibnpWZUR5dnlUOEM0QVAzZUkvZmlZQmFDaXcwPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-        key: LS0tLS1CRUdJTiBFRDI1NTE5IFBSSVZBVEUgS0VZLS0tLS0KTUM0Q0FRQXdCUVlESzJWd0JDSUVJTDg3ckFBbTgvUzlNSU1GQm9pZ2ZpUDg4Mmg3QlNUSGppUTFrSng2QmNEVAotLS0tLUVORCBFRDI1NTE5IFBSSVZBVEUgS0VZLS0tLS0K
-    certSANs: []
-    kubelet:
-        image: ghcr.io/siderolabs/kubelet:v1.35.3
-        extraArgs:
-            rotate-server-certificates: "true"
-        extraMounts:
-            - destination: /var/lib/longhorn
-              type: bind
-              source: /var/lib/longhorn
-              options:
-                - bind
-                - rshared
-                - rw
-        defaultRuntimeSeccompProfileEnabled: true
-        disableManifestsDirectory: true
-    network: {}
-    install:
-        disk: /dev/sda
-        image: factory.talos.dev/metal-installer/53edcacbd9153fcbce2ba04cc41e1c6867ef92b462b37344de8c420ceeb21816:v1.12.6
-        wipe: false
-        grubUseUKICmdline: true
-    files:
-        - content: |-
-            [plugins."io.containerd.cri.v1.images"]
-              discard_unpacked_layers = false
-          permissions: 0o0
-          path: /etc/cri/conf.d/20-customization.part
-          op: create
-    features:
-        diskQuotaSupport: true
-        kubePrism:
-            enabled: true
-            port: 7445
-        hostDNS:
-            enabled: true
-            forwardKubeDNSToHost: false
-    nodeLabels:
-        node.kubernetes.io/exclude-from-external-load-balancers: ""
-cluster:
-    id: CZ7M2eK-gs9qR50_MYzIL8653An9nHRGCR2R1rfIfSo=
-    secret: hnYuExJx1JeFfG6Ss3yYI1wuJRqokD9laXboLmI0A4Q=
-    controlPlane:
-        endpoint: https://10.0.2.1:6443
-    clusterName: titan
-    network:
-        cni:
-            name: none
-        dnsDomain: cluster.local
-        podSubnets:
-            - 10.244.0.0/16
-        serviceSubnets:
-            - 10.96.0.0/12
-    token: 5607yr.7fbnk2hyaukxnkwx
-    secretboxEncryptionSecret: NSHASj2WMMmiZqluiHGKdiJuaxejaz6bmytD07ccp/A=
-    ca:
-        crt: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUJpakNDQVRDZ0F3SUJBZ0lSQU4xVTVpY2FlY1B6QXRTeDFobjdCaU13Q2dZSUtvWkl6ajBFQXdJd0ZURVQKTUJFR0ExVUVDaE1LYTNWaVpYSnVaWFJsY3pBZUZ3MHlOVEV4TURrd01qTTVNakJhRncwek5URXhNRGN3TWpNNQpNakJhTUJVeEV6QVJCZ05WQkFvVENtdDFZbVZ5Ym1WMFpYTXdXVEFUQmdjcWhrak9QUUlCQmdncWhrak9QUU1CCkJ3TkNBQVJPYmVEM3UzbWVoYk1NWE9xeHJKYzNFaGovZ1NrNENENm42cXhQcTBIVHdDbk1iY2l1cmNZUTk5VkkKM0ZPUU92ZCtGMGtKSFV1ZitkSDFlRU1GWno4eG8yRXdYekFPQmdOVkhROEJBZjhFQkFNQ0FvUXdIUVlEVlIwbApCQll3RkFZSUt3WUJCUVVIQXdFR0NDc0dBUVVGQndNQ01BOEdBMVVkRXdFQi93UUZNQU1CQWY4d0hRWURWUjBPCkJCWUVGUExUWTYveUthQUFOUk1Ud0pmUDh2a2FEcXh5TUFvR0NDcUdTTTQ5QkFNQ0EwZ0FNRVVDSVFESjM4TloKcEZDMjJLK3pMRWlrQWp1YlNoMWNXcW5JZmU4c2VHbkZHckFWOXdJZ1cyLy9WS3BFSTNSaGtTaTkxWGVLNVduOAowRXdaVmlKRkZSWENVcEt6L0pFPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-        key: LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSURsQ3BaWThKYmx1Znl3cStWcmJGb25XRmlZYjJINDRXdG0xLzFSRWpubFNvQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFVG0zZzk3dDVub1d6REZ6cXNheVhOeElZLzRFcE9BZytwK3FzVDZ0QjA4QXB6RzNJcnEzRwpFUGZWU054VGtEcjNmaGRKQ1IxTG4vblI5WGhEQldjL01RPT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo=
-    aggregatorCA:
-        crt: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUJYekNDQVFXZ0F3SUJBZ0lRVHBwakprbXRucktUM09yOEVsU2VPakFLQmdncWhrak9QUVFEQWpBQU1CNFgKRFRJMU1URXdPVEF5TXpreU1Gb1hEVE0xTVRFd056QXlNemt5TUZvd0FEQlpNQk1HQnlxR1NNNDlBZ0VHQ0NxRwpTTTQ5QXdFSEEwSUFCS2cwOW4xcXExSkhBNTJmZXNkT1RVYTFHOUpHWUQ2WWF1aDdOSjdjbDl2dzQ4QUJORmJkCnA3YUdSQnNtNzdDZVNIemRiOWU4MmdoZHVkTUVRbVFnUCtXallUQmZNQTRHQTFVZER3RUIvd1FFQXdJQ2hEQWQKQmdOVkhTVUVGakFVQmdnckJnRUZCUWNEQVFZSUt3WUJCUVVIQXdJd0R3WURWUjBUQVFIL0JBVXdBd0VCL3pBZApCZ05WSFE0RUZnUVVuNjhCcWJmUkZpaXpzTis0VUFKYkk0RUFaTXd3Q2dZSUtvWkl6ajBFQXdJRFNBQXdSUUloCkFOb3lXbFpXQkR5K0tONHRYdldmTDlYcXZGaGNabGxEYkhLNnlGQkE2Z0h1QWlBdUVFV1JCaXhrMU1VdVVrTXAKTkhOWHpSMXQ4TWVBNVBmY1BnakVramhjcmc9PQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-        key: LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSUgwZGkzc3hMZmxQZVZFNnplY1ppbk42QWM5SURaSjJvdHF1bWdJUTNnRnNvQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFcURUMmZXcXJVa2NEblo5NngwNU5SclViMGtaZ1BwaHE2SHMwbnR5WDIvRGp3QUUwVnQybgp0b1pFR3lidnNKNUlmTjF2MTd6YUNGMjUwd1JDWkNBLzVRPT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo=
-    serviceAccount:
-        key: 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
-    apiServer:
-        image: registry.k8s.io/kube-apiserver:v1.35.3
-        admissionControl:
-            - name: PodSecurity
-              configuration:
-                apiVersion: pod-security.admission.config.k8s.io/v1alpha1
-                defaults:
-                    audit: restricted
-                    audit-version: latest
-                    enforce: baseline
-                    enforce-version: latest
-                    warn: restricted
-                    warn-version: latest
-                exemptions:
-                    namespaces:
-                        - kube-system
-                    runtimeClasses: []
-                    usernames: []
-                kind: PodSecurityConfiguration
-        auditPolicy:
-            apiVersion: audit.k8s.io/v1
-            kind: Policy
-            rules:
-                - level: Metadata
-    controllerManager:
-        image: registry.k8s.io/kube-controller-manager:v1.35.3
-    proxy:
-        disabled: true
-        image: registry.k8s.io/kube-proxy:v1.35.3
-    scheduler:
-        image: registry.k8s.io/kube-scheduler:v1.35.3
-    discovery:
-        enabled: true
-        registries:
-            kubernetes:
-                disabled: true
-            service: {}
-    etcd:
-        ca:
-            crt: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUJmakNDQVNTZ0F3SUJBZ0lSQU02WFZ6VTd6YlU5QjlqcTJZOU5IRzh3Q2dZSUtvWkl6ajBFQXdJd0R6RU4KTUFzR0ExVUVDaE1FWlhSalpEQWVGdzB5TlRFeE1Ea3dNak01TWpCYUZ3MHpOVEV4TURjd01qTTVNakJhTUE4eApEVEFMQmdOVkJBb1RCR1YwWTJRd1dUQVRCZ2NxaGtqT1BRSUJCZ2dxaGtqT1BRTUJCd05DQUFRcUhzRllaNFA4CmNybTVzaFZEaWNvWWFweXJneGFsaWppcUJubWVMazVlOVM4RnVYMGFac2dwQXdpMkIwWUNNVndQM25SK3d3YVkKVVRtWGpOSDBhcXp2bzJFd1h6QU9CZ05WSFE4QkFmOEVCQU1DQW9Rd0hRWURWUjBsQkJZd0ZBWUlLd1lCQlFVSApBd0VHQ0NzR0FRVUZCd01DTUE4R0ExVWRFd0VCL3dRRk1BTUJBZjh3SFFZRFZSME9CQllFRkxYMkJXSVdKU3diCk9zRW1JR21MTGI4aGp0VXhNQW9HQ0NxR1NNNDlCQU1DQTBnQU1FVUNJRnBCbGdXUHB6Tkg0UkkrYTBrMEczcWIKSE42Z1pFSU5PZkhnWXV2MHNIYy9BaUVBc3p0eTd4ckdLVVYrOXF6bEpNRXBsWi9jVTJ4NFpQbVUzMmdraUQyagpDc1U9Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0K
-            key: LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSUg1L2VmL0d0T1lKN2FuVWUzZnBQRW9ta21oRlJpOWM4eGtLN3ZTTGJPZy9vQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFS2g3QldHZUQvSEs1dWJJVlE0bktHR3FjcTRNV3BZbzRxZ1o1bmk1T1h2VXZCYmw5R21iSQpLUU1JdGdkR0FqRmNEOTUwZnNNR21GRTVsNHpSOUdxczd3PT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo=
-    extraManifests:
-        - https://raw.githubusercontent.com/alex1989hu/kubelet-serving-cert-approver/main/deploy/standalone-install.yaml
-        - https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
-        - https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.4.1/standard-install.yaml
-    inlineManifests:
-        - name: sops-key
-          contents: |-
-            apiVersion: v1
-            kind: Namespace
-            metadata:
-              name: flux-system
-            ---
-            apiVersion: v1
-            kind: Secret
-            metadata:
-              name: sops-gpg
-              namespace: flux-system
-            stringData:
-              age.agekey: |
-                # created: 2025-12-01T02:18:04+01:00
-                # public key: age1hktythzvsnth6u5en2lvag0tftnj9r03w7rpnzfgzgf5w95qxycq2azufj
-                AGE-SECRET-KEY-1ES2W2EQY2MXKF04QSNMWHERKFX0Y27CDMCWFX47Z3PV6H37R735SV8UDSZ
-        - name: cluster-variables
-          contents: |-
-            ---
-            apiVersion: v1
-            kind: Namespace
-            metadata:
-              name: flux-system
-            ---
-            apiVersion: v1
-            kind: ConfigMap
-            metadata:
-              name: cluster-variables
-              namespace: flux-system
-            data:
-              cluster_env: production
-    allowSchedulingOnControlPlanes: true
----
-apiVersion: v1alpha1
-kind: HostnameConfig
-auto: "off"
-hostname: helios
----
-apiVersion: v1alpha1
-kind: LinkConfig
-name: enp2s0
-up: true
-mtu: 9000
-addresses:
-    - address: 10.0.0.202/22
-routes:
-    - gateway: 10.0.0.1
----
-apiVersion: v1alpha1
-kind: TimeSyncConfig
-ntp:
-    servers:
-        - nl.pool.ntp.org
----
-apiVersion: v1alpha1
-kind: ResolverConfig
-nameservers:
-    - address: 1.1.1.1
-    - address: 8.8.8.8
----
-apiVersion: v1alpha1
-kind: Layer2VIPConfig
-name: 10.0.2.1
-link: enp2s0
----
-apiVersion: v1alpha1
-kind: ExtensionServiceConfig
-name: tailscale
-environment:
-    - TS_AUTHKEY=hskey-auth-dn_t5EiIfKGe-GHafxPQRMudp4G_ygs4Rmc5a6TSzdxV4HzKklwOEy-gOiIovOxHfoFlrTt0cpiWp
-    - TS_EXTRA_ARGS=--login-server https://headscale.huizinga.dev
-    - TS_ROUTES=
----
-apiVersion: v1alpha1
-kind: UserVolumeConfig
-name: longhorn
-provisioning:
-    diskSelector:
-        match: system_disk
-    grow: true
-    maxSize: 2000GB
----
-apiVersion: v1alpha1
-kind: UserVolumeConfig
-name: local-path-provisioner
-volumeType: directory
----
-apiVersion: v1alpha1
-kind: VolumeConfig
-name: EPHEMERAL
-provisioning:
-    maxSize: 30GB

ipxe/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "ipxe"
+version = "0.1.0"
+edition = "2024"
+
+[build-dependencies]
+diffy = "0.5.2"
+gix = { version = "0.89.0", default-features = false, features = [
+  "blocking-network-client",
+  "worktree-mutation",
+  "sha1",
+  "blocking-http-transport-reqwest-rust-tls",
+] }
+
+[dependencies]
+include_dir = "0.7.4"

ipxe/build.rs

@@ -0,0 +1,180 @@
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::AtomicBool;
+
+use diffy::apply;
+use diffy::patch_set::{FileOperation, ParseOptions, PatchSet};
+use gix::Repository;
+use gix::progress::Discard;
+
+const URL: &str = "https://github.com/ipxe/ipxe";
+const REVISION: &str = "fe159d0910cac1cd49bab8d4b9296dbe2d9d3cc2";
+const FILES: &[&str] = &["bin/ipxe.pxe", "bin-x86_64-efi/ipxe.efi"];
+
+const SRC_DIR: &str = "src";
+
+fn main() {
+    let manifest_dir = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+        .canonicalize()
+        .unwrap();
+    let out_dir = PathBuf::from(std::env::var("OUT_DIR").unwrap())
+        .canonicalize()
+        .unwrap();
+    let repo_dir = out_dir.join("repo");
+
+    let repo = checkout(&out_dir, &repo_dir);
+
+    apply_patches(&repo, &manifest_dir, &repo_dir);
+    println!("cargo::rerun-if-changed=patches");
+
+    build(&manifest_dir, &repo_dir);
+    println!("cargo::rerun-if-changed=src/embed.ipxe");
+
+    copy_files(&repo_dir, &out_dir);
+}
+
+fn checkout(out_dir: &Path, repo_dir: &Path) -> Repository {
+    // Stamp file is used instead of comparing against HEAD to guard against incomplete clones
+    let stamp = out_dir.join("checkout.stamp");
+    if std::fs::read_to_string(&stamp).is_ok_and(|stamp| stamp == REVISION)
+        && let Ok(repo) = gix::open(repo_dir)
+    {
+        return repo;
+    }
+
+    // Cleanup any left-overs
+    std::fs::remove_file(&stamp).ok();
+    std::fs::remove_dir_all(repo_dir).ok();
+
+    std::fs::create_dir_all(repo_dir).unwrap();
+
+    let mut prepare = gix::prepare_clone(URL, repo_dir)
+        .unwrap()
+        .with_revision(Some(REVISION))
+        .unwrap();
+
+    let interrupt = AtomicBool::new(false);
+    let (mut checkout, _) = prepare.fetch_then_checkout(Discard, &interrupt).unwrap();
+    let (repo, _) = checkout.main_worktree(Discard, &interrupt).unwrap();
+
+    std::fs::write(&stamp, REVISION).unwrap();
+
+    repo
+}
+
+fn apply_patches(repo: &Repository, manifest_dir: &Path, repo_dir: &Path) {
+    let commit_id = gix::ObjectId::from_hex(REVISION.as_bytes()).unwrap();
+    let tree = repo.find_commit(commit_id).unwrap().tree().unwrap();
+
+    // Get all the patches and sort them based on name
+    let mut patch_files: Vec<PathBuf> = std::fs::read_dir(manifest_dir.join("patches"))
+        .unwrap()
+        .map(|e| e.unwrap().path())
+        .filter(|e| e.extension().is_some_and(|e| e == "patch"))
+        .collect();
+    patch_files.sort();
+
+    let mut patched = HashMap::new();
+    for path in patch_files {
+        let text = std::fs::read_to_string(&path).unwrap();
+        let patch_set = PatchSet::parse(&text, ParseOptions::gitdiff());
+
+        for patch in patch_set {
+            let patch = patch.unwrap();
+
+            match patch.operation().strip_prefix(1) {
+                FileOperation::Modify { original, modified } => {
+                    assert_eq!(original, modified);
+                    let path = original.to_string();
+
+                    // Either get the current in-memory patched file, otherwise get the prisine file
+                    let current = patched
+                        .remove(&path)
+                        .unwrap_or_else(|| pristine(&tree, &path));
+
+                    let new = apply(&current, patch.patch().as_text().unwrap()).unwrap();
+                    patched.insert(path, new);
+                }
+                _ => todo!(),
+            }
+        }
+    }
+
+    // If the file was previously patched, but now isn't restore the pristine file
+    for path in modified_files(repo) {
+        if !patched.contains_key(&path) {
+            std::fs::write(repo_dir.join(&path), pristine(&tree, &path)).unwrap();
+        }
+    }
+
+    // Write all the patched files
+    for (path, content) in &patched {
+        let path = repo_dir.join(path);
+        let content = content.as_bytes();
+
+        // But only if the file is actually different from the one on disk
+        // This prevents changing the mtime unnecessarily
+        if std::fs::read(&path).ok().as_deref() != Some(content) {
+            std::fs::write(path, content).unwrap();
+        }
+    }
+}
+
+fn pristine(tree: &gix::Tree<'_>, path: &str) -> String {
+    let entry = tree.lookup_entry_by_path(path).unwrap().unwrap();
+
+    String::from_utf8(entry.object().unwrap().data.clone()).unwrap()
+}
+
+fn modified_files(repo: &gix::Repository) -> Vec<String> {
+    repo.status(Discard)
+        .unwrap()
+        .untracked_files(gix::status::UntrackedFiles::None)
+        .into_index_worktree_iter(Vec::<gix::bstr::BString>::new())
+        .unwrap()
+        .map(|item| item.unwrap().rela_path().to_string())
+        .collect()
+}
+
+fn build(manifest_dir: &Path, repo_dir: &Path) {
+    let src_dir = repo_dir.join(SRC_DIR);
+
+    let mut command = Command::new("make");
+    command
+        .current_dir(&src_dir)
+        .env_remove("DEBUG")
+        .env_remove("PROFILE")
+        .arg(format!(
+            "EMBED={}",
+            manifest_dir
+                .join("src")
+                .join("embed.ipxe")
+                .to_string_lossy()
+        ))
+        .args(FILES);
+
+    if let Ok(flags) = std::env::var("CARGO_MAKEFLAGS") {
+        command.env("MAKEFLAGS", flags);
+    }
+
+    let output = command.output().unwrap();
+
+    if !output.status.success() {
+        panic!("make failed:\n{}", String::from_utf8_lossy(&output.stderr));
+    }
+}
+
+fn copy_files(repo_dir: &Path, out_dir: &Path) {
+    let src_dir = repo_dir.join(SRC_DIR);
+    let bin_dir = out_dir.join("bin");
+
+    std::fs::create_dir_all(&bin_dir).unwrap();
+    for file in FILES {
+        let file = Path::new(file);
+        let input = src_dir.join(file);
+        let output = bin_dir.join(file.file_name().unwrap());
+
+        std::fs::copy(input, output).unwrap();
+    }
+}

ipxe/patches/0001_enable_protocols.patch

@@ -0,0 +1,19 @@
+diff --git a/src/config/general.h b/src/config/general.h
+index 43858dceb..54cb1b657 100644
+--- a/src/config/general.h
++++ b/src/config/general.h
+@@ -60,10 +60,10 @@ FILE_SECBOOT ( PERMITTED );
+ //#define HTTP_ENC_PEERDIST	/* PeerDist content encoding */
+
+ /* Disable protocols not historically included in BIOS builds */
+-#if defined ( PLATFORM_pcbios )
+-  #undef DOWNLOAD_PROTO_HTTPS
+-  #undef HTTP_AUTH_NTLM
+-#endif
++// #if defined ( PLATFORM_pcbios )
++//   #undef DOWNLOAD_PROTO_HTTPS
++//   #undef HTTP_AUTH_NTLM
++// #endif
+
+ /*****************************************************************************
+  *

ipxe/src/embed.ipxe

@@ -0,0 +1,4 @@
+#!ipxe
+
+dhcp
+chain boot.ipxe

ipxe/src/lib.rs

@@ -0,0 +1,3 @@
+use include_dir::{Dir, include_dir};
+
+pub static IPXE_DIR: Dir<'_> = include_dir!("$OUT_DIR/bin");

rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-03-12"
+channel = "nightly-2026-10-01"
 profile = "default"
 components = ["rust-analyzer"]

src/boot.ipxe

@@ -0,0 +1,19 @@
+#!ipxe
+echo Starting ${serial}
+
+:start
+goto node_${serial} || exit
+# Default behavior (non install mode) is to exit iPXE script
+
+{% for cluster in clusters%}
+{% for _, node in cluster.nodes|items %}
+{%- if node.install.serial -%}
+# {{ cluster.name }}/{{ node.hostname }}
+:node_{{ node.install.serial }}
+imgfree
+kernel https://pxe.factory.talos.dev/image/{{ node.schematic }}/v{{ cluster.version.talos }}/kernel-{{ node.arch }} {{ node.kernelArgs|join(" ") }} {% if node.install.auto %}talos.config={{httpUrl}}/talos/{{cluster.name}}/{{node.hostname}}.yaml{% endif +%}
+initrd https://pxe.factory.talos.dev/image/{{ node.schematic }}/v{{ cluster.version.talos }}/initramfs-{{ node.arch }}.xz
+boot
+{% endif %}
+{% endfor %}
+{% endfor %}

src/cli.rs

@@ -1,3 +1,4 @@
+use std::net::IpAddr;
 use std::path::PathBuf;
 
 use clap::{Args, Parser, Subcommand};
@@ -49,6 +50,11 @@ pub enum Commands {
     Generate,
     /// Generate completions for your current shell
     ShellCompletions,
-    /// Test
-    Serve,
+    /// Serve config files over tftp
+    Serve {
+        #[arg(short, long, default_value = "3000")]
+        port: u16,
+        #[arg(long, default_value = "0.0.0.0")]
+        ip: IpAddr,
+    },
 }

src/cluster.rs

@@ -1,19 +1,22 @@
 use std::collections::HashMap;
 use std::net::Ipv4Addr;
 use std::path::PathBuf;
-use std::process::Command;
 use std::str::FromStr;
 
+use async_walkdir::WalkDir;
+use futures::StreamExt;
+use futures::stream::FuturesUnordered;
 use minijinja::Environment;
 use optional_struct::{Applicable, optional_struct};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use walkdir::WalkDir;
+use tokio::process::Command;
 
 use crate::environment::PathEnvironment;
 use crate::node::{Node, OptionalNodeDeserialize};
 use crate::patch::Patches;
-use crate::{get_configs_path, get_talos_path};
+use crate::talosconfig::TalosConfig;
+use crate::{get_configs_path, get_talos_path, run_command};
 
 #[optional_struct]
 #[derive(Debug, Deserialize, JsonSchema, Clone)]
@@ -69,7 +72,7 @@ struct ClusterDeserialize {
     base: Base,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct Cluster {
     pub(crate) name: String,
@@ -81,19 +84,23 @@ pub struct Cluster {
 }
 
 impl Cluster {
-    pub(crate) fn get(cluster_name: &str, env: &Environment) -> Self {
+    pub(crate) async fn get(cluster_name: &str, env: &Environment<'static>) -> Self {
         let path = get_talos_path().join("clusters").join("default.yaml");
 
         let default: OptionalClusterDeserialize = if path.exists() {
-            let content = std::fs::read_to_string(path).unwrap();
-            serde_yaml::from_str(&content).unwrap()
+            let content = tokio::fs::read_to_string(path).await.unwrap();
+
+            // The deserialization makes a blocking web request
+            tokio::task::spawn_blocking(move || serde_yaml::from_str(&content).unwrap())
+                .await
+                .unwrap()
         } else {
             Default::default()
         };
 
         let mut path = get_talos_path().join("clusters").join(cluster_name);
         path.add_extension("yaml");
-        let content = std::fs::read_to_string(path).unwrap();
+        let content = tokio::fs::read_to_string(path).await.unwrap();
 
         let mut cluster: OptionalClusterDeserialize = serde_yaml::from_str(&content).unwrap();
 
@@ -115,31 +122,32 @@ impl Cluster {
         let cluster = Self {
             name: cluster_name.into(),
             version: cluster.version,
-            nodes: HashMap::new(),
+            nodes: Default::default(),
             cluster_env: cluster.cluster_env,
             control_plane_ip: cluster.control_plane_ip,
             secrets_file,
         };
 
-        let nodes = nodes
-            .into_iter()
-            .map(|name| {
-                let node = Node::get(&name, env, &cluster, &default, &base);
-                (node.hostname().into(), node)
-            })
-            .collect();
+        let nodes = nodes.iter().map(|name| async {
+            let node = Node::get(name, env, &cluster, &default, &base).await;
+            (node.hostname().to_owned(), node)
+        });
+
+        let nodes = FuturesUnordered::from_iter(nodes).collect().await;
 
         Self { nodes, ..cluster }
     }
 
-    pub fn get_all() -> HashMap<String, Cluster> {
+    pub async fn get_all() -> HashMap<String, Cluster> {
         let env = PathEnvironment::new_patches();
 
-        WalkDir::new(get_talos_path().join("clusters"))
-            .into_iter()
-            .filter_map(|e| e.ok())
-            .filter(|e| e.metadata().unwrap().is_file())
-            .filter_map(|e| {
+        let names: Vec<_> = WalkDir::new(get_talos_path().join("clusters"))
+            .filter_map(|e| async { e.ok() })
+            .filter(|e| {
+                let e = e.clone();
+                async move { e.metadata().await.unwrap().is_file() }
+            })
+            .filter_map(|e| async move {
                 let mut path = PathBuf::from_str(&e.file_name().to_string_lossy()).unwrap();
                 path.set_extension("");
 
@@ -149,24 +157,35 @@ impl Cluster {
                     return None;
                 }
 
-                let cluster = Cluster::get(&name, &env);
-
-                Some((name, cluster))
+                Some(name)
             })
             .collect()
+            .await;
+
+        // Get the clusters concurrently
+        FuturesUnordered::from_iter(names.iter().map(|name| {
+            let env = env.clone();
+            let name = name.clone();
+
+            async move {
+                let cluster = Cluster::get(&name, &env).await;
+
+                (name, cluster)
+            }
+        }))
+        .collect()
+        .await
     }
 
     pub fn nodes(&self) -> impl Iterator<Item = &Node> {
         self.nodes.values()
     }
 
-    pub fn node(&self, name: &str) -> Option<&Node> {
-        self.nodes.get(name)
+    pub fn node(&self, node: &str) -> Option<&Node> {
+        self.nodes.get(node)
     }
 
-    pub fn talosctl_gen_config_command(&self) -> Command {
-        let path = get_configs_path().join(&self.name).join("talosconfig");
-
+    pub async fn talosconfig(&self) -> String {
         let mut command = Command::new("talosctl");
         command.args([
             "gen",
@@ -178,41 +197,59 @@ impl Cluster {
             "--output-types",
             "talosconfig",
             "-o",
-            path.to_str().expect("Path should be valid utf-8"),
+            "-",
         ]);
 
-        command
+        run_command(command).await
     }
 
-    pub fn talosctl_add_endpoint_command(&self) -> Command {
-        let path = get_configs_path().join(&self.name).join("talosconfig");
+    pub fn talosconfig_path(&self) -> PathBuf {
+        get_configs_path().join(&self.name).join("talosconfig")
+    }
 
+    async fn talosconfig_add_endpoint(&self) {
         let mut command = Command::new("talosctl");
         command.args([
             "config",
             "--talosconfig",
-            path.to_str().expect("Path should be valid utf-8"),
+            self.talosconfig_path()
+                .to_str()
+                .expect("Path should be valid utf-8"),
             "endpoint",
             &self.control_plane_ip.to_string(),
         ]);
 
-        command
+        run_command(command).await;
     }
 
-    pub fn talosctl_merge_command(&self) -> Command {
-        let cluster_path = get_configs_path().join(&self.name).join("talosconfig");
-        let path = get_configs_path().join("talosconfig");
+    pub async fn talosconfig_write(&self) {
+        let config = self.talosconfig().await;
 
+        let path = self.talosconfig_path();
+        tokio::fs::create_dir_all(path.parent().expect("talosconfig should have parent"))
+            .await
+            .unwrap();
+
+        tokio::fs::write(path, config).await.unwrap();
+
+        self.talosconfig_add_endpoint().await
+    }
+
+    pub async fn talosconfig_merge(&self) {
         let mut command = Command::new("talosctl");
         command.args([
             "config",
             "--talosconfig",
-            path.to_str().expect("Path should be valid utf-8"),
+            TalosConfig::merged_path()
+                .to_str()
+                .expect("Path should be valid utf-8"),
             "merge",
-            cluster_path.to_str().expect("Path should be valid utf-8"),
+            self.talosconfig_path()
+                .to_str()
+                .expect("Path should be valid utf-8"),
         ]);
 
-        command
+        run_command(command).await;
     }
 }
 

src/environment.rs

@@ -2,15 +2,17 @@ use std::net::Ipv4Addr;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
+use async_walkdir::WalkDir;
+use futures::{Stream, StreamExt};
 use minijinja::value::ViaDeserialize;
 use minijinja::{AutoEscape, Environment, path_loader};
-use walkdir::WalkDir;
 
 use crate::{get_configs_path, get_talos_path};
 
 /// Transparent wrapper around minijinja::Environment that loads templates from a path and
 /// configures better defaults. It also implements IntoIter, making it possible to iterate over all
 /// the templates.
+#[derive(Clone)]
 pub struct PathEnvironment<'a> {
     env: Environment<'a>,
     path: PathBuf,
@@ -23,46 +25,50 @@ fn apply_netmask(
     Ok((*ip & *netmask).to_string())
 }
 
+pub fn configure_environment(env: &mut Environment) {
+    // Configure jinja
+    env.set_trim_blocks(true);
+    env.set_lstrip_blocks(true);
+    env.set_undefined_behavior(minijinja::UndefinedBehavior::Strict);
+    env.set_auto_escape_callback(|_| AutoEscape::None);
+
+    // Add filters
+    env.add_filter("to_prefix", |netmask: ViaDeserialize<Ipv4Addr>| {
+        let mask = netmask.to_bits();
+        let prefix = mask.leading_ones();
+
+        if mask.checked_shl(prefix).unwrap_or(0) == 0 {
+            Ok(prefix as u8)
+        } else {
+            Err(minijinja::Error::new(
+                minijinja::ErrorKind::InvalidOperation,
+                "invalid IP prefix length",
+            ))
+        }
+    });
+
+    env.add_function("apply_netmask", apply_netmask);
+
+    // Helper function for getting the path to kubeconfig files
+    env.add_filter("kubeconfig", move |names: Vec<String>| {
+        names
+            .iter()
+            .map(|name| {
+                get_configs_path()
+                    .join(name)
+                    .join("kubeconfig")
+                    .to_string_lossy()
+                    .to_string()
+            })
+            .collect::<Vec<_>>()
+    });
+}
+
 impl<'a> PathEnvironment<'a> {
     pub fn new(path: &Path) -> Self {
         let mut env = Environment::new();
 
-        // Configure jinja
-        env.set_trim_blocks(true);
-        env.set_lstrip_blocks(true);
-        env.set_undefined_behavior(minijinja::UndefinedBehavior::Strict);
-        env.set_auto_escape_callback(|_| AutoEscape::None);
-
-        // Add filters
-        env.add_filter("to_prefix", |netmask: ViaDeserialize<Ipv4Addr>| {
-            let mask = netmask.to_bits();
-            let prefix = mask.leading_ones();
-
-            if mask.checked_shl(prefix).unwrap_or(0) == 0 {
-                Ok(prefix as u8)
-            } else {
-                Err(minijinja::Error::new(
-                    minijinja::ErrorKind::InvalidOperation,
-                    "invalid IP prefix length",
-                ))
-            }
-        });
-
-        env.add_function("apply_netmask", apply_netmask);
-
-        // Helper function for getting the path to kubeconfig files
-        env.add_filter("kubeconfig", move |names: Vec<String>| {
-            names
-                .iter()
-                .map(|name| {
-                    get_configs_path()
-                        .join(name)
-                        .join("kubeconfig")
-                        .to_string_lossy()
-                        .to_string()
-                })
-                .collect::<Vec<_>>()
-        });
+        configure_environment(&mut env);
 
         // Add path loader
         env.set_loader(path_loader(&path));
@@ -76,6 +82,23 @@ impl<'a> PathEnvironment<'a> {
     pub(crate) fn new_patches() -> Self {
         Self::new(&get_talos_path().join("patches"))
     }
+
+    pub fn files(&self) -> impl Stream<Item = String> {
+        // Find all templates in path
+        WalkDir::new(&self.path)
+            .filter_map(|e| async { e.ok() })
+            .filter(|e| {
+                let e = e.clone();
+                async move { e.metadata().await.unwrap().is_file() }
+            })
+            .map(move |e| {
+                e.path()
+                    .strip_prefix(&self.path)
+                    .expect("All paths should have prefix")
+                    .to_string_lossy()
+                    .to_string()
+            })
+    }
 }
 
 // Make PathEnvironment act like a normal Environment transparently
@@ -86,25 +109,3 @@ impl<'a> Deref for PathEnvironment<'a> {
         &self.env
     }
 }
-
-// Iterate over all the files in the path
-impl<'a, 'b> IntoIterator for &'b PathEnvironment<'a> {
-    type Item = String;
-
-    type IntoIter = impl Iterator<Item = Self::Item>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        // Find all templates in path
-        WalkDir::new(&self.path)
-            .into_iter()
-            .filter_map(|e| e.ok())
-            .filter(|e| e.metadata().unwrap().is_file())
-            .map(|e| {
-                e.path()
-                    .strip_prefix(&self.path)
-                    .expect("All paths should have prefix")
-                    .to_string_lossy()
-                    .to_string()
-            })
-    }
-}

src/error.rs

@@ -0,0 +1,10 @@
+use crete::tftp::ServerError;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("No clusters where found")]
+    NoClustersFound,
+    #[error("Server error: {0}")]
+    ServerError(#[from] ServerError),
+}

src/file.rs

@@ -0,0 +1,55 @@
+use crete::cluster::Cluster;
+use crete::environment::configure_environment;
+use ipxe::IPXE_DIR;
+use minijinja::{Environment, context};
+use regex::regex;
+
+pub async fn get_file(
+    filename: impl ToString,
+    http_url: impl ToString,
+) -> Option<(Vec<u8>, &'static str)> {
+    let re = regex!(r"^talos/(?<cluster>.+)/(?<node>.+)\.ya?ml$");
+
+    let filename: String = filename.to_string();
+    let re = re.clone();
+
+    const IPXE_PATTERN: &str = "ipxe/";
+    if filename == format!("{IPXE_PATTERN}boot.ipxe") {
+        let mut env = Environment::new();
+
+        configure_environment(&mut env);
+
+        let template = env
+            .template_from_str(include_str!("./boot.ipxe"))
+            .expect("Template should be valid");
+
+        let clusters = Cluster::get_all().await;
+        let content = template
+            .render(context! {
+                clusters => clusters.values().collect::<Vec<_>>(),
+                httpUrl => http_url.to_string()
+            })
+            .unwrap();
+
+        Some((content.into(), "text/plain; charset=utf-8"))
+    } else if let Some(filename) = filename.strip_prefix(IPXE_PATTERN) {
+        Some((
+            IPXE_DIR.get_file(filename)?.contents().to_owned(),
+            "application/octet-stream",
+        ))
+    } else if let Some(caps) = re.captures(&filename) {
+        let cluster = &caps["cluster"];
+        let node = &caps["node"];
+
+        let clusters = Cluster::get_all().await;
+        let cluster = clusters.get(cluster)?;
+
+        let node = cluster.node(node)?;
+
+        let config = node.config(cluster).await;
+
+        Some((config.into(), "application/yaml; charset=utf-8"))
+    } else {
+        None
+    }
+}

src/http.rs

@@ -0,0 +1,46 @@
+use std::path::PathBuf;
+
+use axum::debug_handler;
+use axum::extract::Request;
+use axum::http::Uri;
+use axum::response::IntoResponse;
+use reqwest::{StatusCode, header};
+
+use crate::file::get_file;
+
+#[debug_handler]
+pub async fn handler(req: Request) -> impl IntoResponse {
+    let uri: Uri = req
+        .headers()
+        .iter()
+        .find(|(name, _)| header::HOST.eq(name))
+        .map(|(_, value)| value)
+        .expect("Host header should exist")
+        .to_str()
+        .expect("Header value should be valid ASCII")
+        .parse()
+        .expect("Host should be valid Uri");
+
+    let host = uri.host().expect("Uri should have host");
+    let port = uri.port().map(|port| port.as_u16()).unwrap_or(80);
+
+    let Some(path) = req.uri().path().strip_prefix("/") else {
+        return StatusCode::BAD_REQUEST.into_response();
+    };
+
+    let Some((file, content_type)) = get_file(path, format!("http://{host}:{port}")).await else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
+
+    let path = PathBuf::from(path);
+    let filename = path.file_name().unwrap();
+    let filename = filename.to_str().unwrap();
+
+    let content_type = [(header::CONTENT_TYPE, content_type)];
+    let disposition = [(
+        header::CONTENT_DISPOSITION,
+        format!("inline; filename=\"{filename}\""),
+    )];
+
+    (content_type, disposition, file).into_response()
+}

src/lib.rs

@@ -1,13 +1,16 @@
-#![feature(impl_trait_in_assoc_type, path_absolute_method, never_type)]
+#![feature(path_absolute_method)]
 use std::path::{Path, PathBuf};
 use std::sync::OnceLock;
 
+use tokio::process::Command;
+
 pub mod cluster;
 pub mod environment;
 pub mod node;
 pub mod patch;
 pub mod schematic;
 pub mod secret;
+pub mod talosconfig;
 pub mod tftp;
 
 pub(crate) static REPO_PATH: OnceLock<PathBuf> = OnceLock::new();
@@ -29,3 +32,14 @@ pub fn get_talos_path() -> PathBuf {
 pub fn get_configs_path() -> PathBuf {
     get_repo_path().join("configs")
 }
+
+pub async fn run_command(mut command: Command) -> String {
+    let output = command.output().await.unwrap();
+    if !output.stderr.is_empty() {
+        println!("{}", String::from_utf8_lossy(&output.stderr).trim_end());
+    }
+
+    String::from_utf8_lossy(&output.stdout)
+        .trim_end()
+        .to_owned()
+}

src/main.rs

@@ -1,58 +1,45 @@
 mod cli;
+mod error;
+mod file;
+mod http;
 
-use std::process::Command;
+use std::net::SocketAddr;
+use std::pin::pin;
 
+use axum::Router;
+use axum::routing::get;
 use clap::{CommandFactory, Parser};
 use clap_complete::{Shell, generate as generate_complete};
 use crete::cluster::Cluster;
 use crete::environment::PathEnvironment;
-use crete::tftp::ServerError;
+use crete::talosconfig::{get_current_context, set_context};
 use crete::{get_configs_path, get_repo_path, set_repo_path, tftp};
+use futures::StreamExt;
+use futures::future::join_all;
 use minijinja::context;
-use regex::Regex;
-use thiserror::Error;
 
 use crate::cli::{Cli, Commands, GlobalOpts};
-
-#[derive(Debug, Error)]
-enum Error {
-    #[error("No clusters where found")]
-    NoClustersFound,
-    #[error("Server error: {0}")]
-    Server(#[from] ServerError),
-}
-
-async fn run_command(mut command: Command) {
-    let output = tokio::task::spawn_blocking(move || command.output().unwrap())
-        .await
-        .unwrap();
-
-    if !output.stdout.is_empty() {
-        println!("{}", String::from_utf8_lossy(&output.stdout).trim_end());
-    }
-    if !output.stderr.is_empty() {
-        println!("{}", String::from_utf8_lossy(&output.stderr).trim_end());
-    }
-}
+use crate::error::Error;
+use crate::file::get_file;
+use crate::http::handler;
 
 async fn generate(opts: &GlobalOpts) -> Result<(), Error> {
-    set_repo_path(&opts.repo);
-
-    let clusters = Cluster::get_all();
+    let clusters = Cluster::get_all().await;
 
     if clusters.is_empty() {
         return Err(Error::NoClustersFound);
     }
 
     let path = opts.repo.join("rendered");
-    if path.exists() {
-        std::fs::remove_dir_all(&path).unwrap();
-    }
-    std::fs::create_dir(&path).unwrap();
+    // We don't really care if this fails, as that likely mean that the directory did not exist
+    tokio::fs::remove_dir_all(&path).await.ok();
+    tokio::fs::create_dir_all(&path).await.unwrap();
 
     // Render templates
     let template_env = PathEnvironment::new(&get_repo_path().join("templates"));
-    for template_name in &template_env {
+
+    let mut stream = pin!(template_env.files());
+    while let Some(template_name) = stream.next().await {
         let template = template_env.get_template(&template_name).unwrap();
 
         let content = template
@@ -62,30 +49,42 @@ async fn generate(opts: &GlobalOpts) -> Result<(), Error> {
             })
             .unwrap();
 
-        std::fs::write(path.join(template_name), content).unwrap();
+        tokio::fs::write(path.join(template_name), content)
+            .await
+            .unwrap();
     }
 
+    let context = get_current_context().await;
+
     // Remove existing config files and create output directory
     let path = get_configs_path();
-    if path.exists() {
-        std::fs::remove_dir_all(&path).unwrap();
-    }
-    std::fs::create_dir(&path).unwrap();
+    tokio::fs::remove_dir_all(&path).await.ok();
+    tokio::fs::create_dir_all(&path).await.unwrap();
 
     // Generate config files
-    for cluster in clusters.values() {
-        for node in cluster.nodes() {
-            let config = node.talosctl_gen_config(cluster).await;
-            let path = node.config_path(cluster);
-            std::fs::create_dir_all(path.parent().expect("Config should have parent directory"))
-                .unwrap();
+    join_all(clusters.values().map(|cluster| async move {
+        join_all(cluster.nodes().map(|node| {
+            let cluster = cluster.clone();
+            async move {
+                node.config_write(&cluster).await;
+            }
+        }))
+        .await;
 
-            std::fs::write(path, config).unwrap();
-        }
+        // Run these commands in parallel with the the node commands
+        // NOTE: These do need to happen in the correct order
+        cluster.talosconfig_write().await;
+    }))
+    .await;
 
-        run_command(cluster.talosctl_gen_config_command()).await;
-        run_command(cluster.talosctl_add_endpoint_command()).await;
-        run_command(cluster.talosctl_merge_command()).await;
+    // Merge all the cluster talosconfig files into a single file
+    // Since this all modifies the same output file this has to happen sequentially
+    for (_, cluster) in clusters {
+        cluster.talosconfig_merge().await;
+    }
+
+    if let Some(context) = context {
+        set_context(context).await;
     }
 
     Ok(())
@@ -95,43 +94,30 @@ async fn generate(opts: &GlobalOpts) -> Result<(), Error> {
 async fn main() -> Result<(), Error> {
     let cli = Cli::parse();
 
+    set_repo_path(&cli.global_opts.repo);
+
     match cli.command {
-        Commands::Generate => generate(&cli.global_opts).await.unwrap(),
+        Commands::Generate => generate(&cli.global_opts).await?,
         Commands::ShellCompletions => generate_complete(
             Shell::from_env().unwrap_or(Shell::Bash),
             &mut Cli::command(),
             "crete",
             &mut std::io::stdout(),
         ),
-        Commands::Serve => {
-            set_repo_path(&cli.global_opts.repo);
+        Commands::Serve { port, ip } => {
+            tokio::spawn(async move {
+                let app = Router::new().fallback_service(get(handler));
+                let addr: SocketAddr = (ip, port).into();
+                let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
 
-            tftp::serve(|filename| {
-                let filename = filename.to_owned();
+                println!("Http server started on {addr}");
+                axum::serve(listener, app).await.unwrap();
+            });
 
-                async move {
-                    let re = Regex::new(r"talos/(?<cluster>.+)/(?<node>.+)\.ya?ml")
-                        .expect("Regex should be valid");
-
-                    if let Some(caps) = re.captures(&filename) {
-                        let cluster = &caps["cluster"];
-                        let node = &caps["node"];
-
-                        let clusters = Cluster::get_all();
-                        let cluster = clusters.get(cluster)?;
-                        let node = cluster.node(node)?;
-
-                        let config = node.talosctl_gen_config(cluster).await;
-
-                        Some(config.into())
-                    } else {
-                        match filename.as_str() {
-                            "ipxe.pxe" => Some(include_bytes!("../bin/ipxe.pxe").into()),
-                            "test" => Some(vec![1, 2, 3, 4]),
-                            _ => None,
-                        }
-                    }
-                }
+            tftp::serve(ip, move |filename, ip| async move {
+                get_file(filename, format!("http://{ip}:{port}"))
+                    .await
+                    .map(|(file, _)| file)
             })
             .await?;
         }

src/node.rs

@@ -11,18 +11,7 @@ use crate::cluster::{Base, Cluster};
 use crate::patch::{OptionalPatches, OptionalPatchesString, Patches};
 use crate::schematic::Schematic;
 use crate::secret::Secret;
-use crate::{get_configs_path, get_talos_path};
-
-async fn get_output(mut command: Command) -> String {
-    let output = command.output().await.unwrap();
-    if !output.stderr.is_empty() {
-        println!("{}", String::from_utf8_lossy(&output.stderr).trim_end());
-    }
-
-    String::from_utf8_lossy(&output.stdout)
-        .trim_end()
-        .to_owned()
-}
+use crate::{get_configs_path, get_talos_path, run_command};
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema, Clone, Copy, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
@@ -102,7 +91,7 @@ pub(crate) struct NodeDeserialize {
     sops: Secret,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct Node {
     hostname: String,
@@ -118,9 +107,9 @@ pub struct Node {
 }
 
 impl Node {
-    pub(crate) fn get(
+    pub(crate) async fn get(
         node_name: &str,
-        env: &Environment,
+        env: &Environment<'static>,
         cluster: &Cluster,
         default: &OptionalNodeDeserialize,
         base: &Base,
@@ -133,7 +122,7 @@ impl Node {
             .to_string();
 
         path.add_extension("yaml");
-        let content = std::fs::read_to_string(path).unwrap();
+        let content = tokio::fs::read_to_string(path).await.unwrap();
 
         let node: OptionalNodeDeserialize = serde_yaml::from_str(&content).unwrap();
 
@@ -184,7 +173,7 @@ impl Node {
         };
 
         // Render patches
-        let patches = patches.render(env, cluster, &node);
+        let patches = patches.render(env, cluster, &node).await;
 
         Node { patches, ..node }
     }
@@ -193,7 +182,7 @@ impl Node {
         &self.hostname
     }
 
-    pub async fn talosctl_gen_config(&self, cluster: &Cluster) -> String {
+    pub async fn config(&self, cluster: &Cluster) -> String {
         let mut command = Command::new("talosctl");
         command.args([
             "gen",
@@ -217,7 +206,7 @@ impl Node {
             "--with-docs=false",
             "--with-examples=false",
             "-o",
-            "-", // path.to_str().expect("Path should be valid utf-8"),
+            "-",
         ]);
 
         for patch in &self.patches.all {
@@ -231,7 +220,7 @@ impl Node {
             ]);
         }
 
-        get_output(command).await
+        run_command(command).await
     }
 
     pub fn config_path(&self, cluster: &Cluster) -> PathBuf {
@@ -240,6 +229,17 @@ impl Node {
 
         path
     }
+
+    pub async fn config_write(&self, cluster: &Cluster) {
+        let config = self.config(cluster).await;
+
+        let path = self.config_path(cluster);
+        tokio::fs::create_dir_all(path.parent().expect("config should have parent"))
+            .await
+            .unwrap();
+
+        tokio::fs::write(path, config).await.unwrap();
+    }
 }
 
 impl JsonSchema for Node {

src/patch.rs

@@ -16,27 +16,36 @@ pub(crate) struct Patches<T> {
 
 pub(crate) type OptionalPatchesString = OptionalPatches<String>;
 
-fn render(
+async fn render(
     patches: Vec<String>,
-    env: &Environment,
+    env: &Environment<'static>,
     cluster: &Cluster,
     node: &Node,
 ) -> Vec<serde_yaml::Value> {
-    patches
-        .into_iter()
-        .map(|name| {
-            let content = env
-                .get_template(&name)
-                .unwrap()
-                .render(context! {
-                    node,
-                    cluster
-                })
-                .unwrap();
+    let env = env.clone();
+    let cluster = cluster.clone();
+    let node = node.clone();
 
-            serde_yaml::from_str(&content).unwrap()
-        })
-        .collect()
+    // Minijinja will still have blocking I/O internally
+    tokio::task::spawn_blocking(move || {
+        patches
+            .into_iter()
+            .map(move |name| {
+                let content = env
+                    .get_template(&name)
+                    .unwrap()
+                    .render(context! {
+                        node,
+                        cluster
+                    })
+                    .unwrap();
+
+                serde_yaml::from_str(&content).unwrap()
+            })
+            .collect()
+    })
+    .await
+    .unwrap()
 }
 
 impl Patches<String> {
@@ -50,15 +59,15 @@ impl Patches<String> {
         }
     }
 
-    pub(crate) fn render(
+    pub(crate) async fn render(
         self,
-        env: &Environment,
+        env: &Environment<'static>,
         cluster: &Cluster,
         node: &Node,
     ) -> Patches<serde_yaml::Value> {
         Patches {
-            all: render(self.all.clone(), env, cluster, node),
-            control_plane: render(self.control_plane.clone(), env, cluster, node),
+            all: render(self.all.clone(), env, cluster, node).await,
+            control_plane: render(self.control_plane.clone(), env, cluster, node).await,
         }
     }
 }

src/schematic.rs

@@ -21,27 +21,29 @@ where
         .build()
         .unwrap();
 
-    let res = tokio::task::block_in_place(|| {
-        Handle::current().block_on(async {
-            client
-                .post("https://factory.talos.dev/schematics")
-                .body(content)
-                .send()
-                .await
-        })
-    })
-    .map_err(serde::de::Error::custom)?;
-
     #[derive(Debug, Deserialize)]
     struct Response {
         id: String,
     }
 
-    let text =
-        tokio::task::block_in_place(|| Handle::current().block_on(async { res.text().await }))
+    // We can't use async directly inside a custom deserializer, and using the blocking client also
+    // does not work as it will try to start tokio inside of tokio.
+    // So we have do this to work around it.
+    // NOTE: This requires that the deserialization happens inside spawn_blocking
+    let response = Handle::current().block_on(async {
+        let res = client
+            .post("https://factory.talos.dev/schematics")
+            .body(content)
+            .send()
+            .await
             .map_err(serde::de::Error::custom)?;
 
-    let response: Response = serde_json::from_str(&text).map_err(serde::de::Error::custom)?;
+        let response: Response =
+            serde_json::from_str(&res.text().await.map_err(serde::de::Error::custom)?)
+                .map_err(serde::de::Error::custom)?;
+
+        Ok(response)
+    })?;
 
     Ok(response.id)
 }

src/talosconfig.rs

@@ -0,0 +1,40 @@
+use std::path::PathBuf;
+
+use serde::Deserialize;
+use tokio::process::Command;
+
+use crate::{get_configs_path, run_command};
+
+#[derive(Debug, Deserialize)]
+pub struct TalosConfig {
+    context: String,
+}
+
+impl TalosConfig {
+    pub fn merged_path() -> PathBuf {
+        get_configs_path().join("talosconfig")
+    }
+}
+
+pub async fn get_current_context() -> Option<String> {
+    tokio::fs::read(&TalosConfig::merged_path())
+        .await
+        .ok()
+        .and_then(|config| serde_yaml::from_slice(&config).ok())
+        .map(|config: TalosConfig| config.context)
+}
+
+pub async fn set_context(context: String) {
+    let mut command = Command::new("talosctl");
+    command.args([
+        "config",
+        "--talosconfig",
+        TalosConfig::merged_path()
+            .to_str()
+            .expect("Path should be valid utf-8"),
+        "context",
+        &context,
+    ]);
+
+    run_command(command).await;
+}

src/tftp/packet.rs

@@ -310,8 +310,8 @@ impl Packet {
     }
 
     pub async fn recv_from(socket: &UdpSocket) -> Result<(Self, SocketAddr), Error> {
-        let mut buf = Vec::with_capacity(PACKET_SIZE);
-        let (_, src) = socket.recv_buf_from(&mut buf).await?;
+        let mut buf = [0u8; PACKET_SIZE];
+        let (_, src) = socket.recv_from(&mut buf).await?;
 
         let packet = buf.try_into()?;
 
@@ -342,10 +342,12 @@ impl TryFrom<&Packet> for Vec<u8> {
     }
 }
 
-impl TryFrom<Vec<u8>> for Packet {
+impl TryFrom<[u8; PACKET_SIZE]> for Packet {
     type Error = Error;
 
-    fn try_from(buf: Vec<u8>) -> Result<Self, <Packet as TryFrom<Vec<u8>>>::Error> {
+    fn try_from(
+        buf: [u8; PACKET_SIZE],
+    ) -> Result<Self, <Packet as TryFrom<[u8; PACKET_SIZE]>>::Error> {
         let mut reader = BufReader::new(Cursor::new(buf));
 
         Packet::decode(&mut reader)

src/tftp/server.rs

@@ -1,11 +1,14 @@
 use std::io;
-use std::net::SocketAddr;
+use std::net::{IpAddr, SocketAddr};
 use std::time::Duration;
 
+use socket_pktinfo::{PktInfo, PktInfoUdpSocket};
+use socket2::Domain;
 use thiserror::Error;
+use tokio::io::unix::AsyncFd;
 use tokio::net::UdpSocket;
 
-use crate::tftp::packet::{ErrorCode, Mode};
+use crate::tftp::packet::{ErrorCode, Mode, PACKET_SIZE};
 use crate::tftp::{self, Packet};
 
 #[derive(Debug, Error)]
@@ -29,23 +32,25 @@ pub enum Error {
 }
 
 pub async fn handle_connection<F, Fut>(
-    src: SocketAddr,
+    info: PktInfo,
     packet: Packet,
     callback: F,
 ) -> Result<(), Error>
 where
-    F: Fn(&str) -> Fut,
+    F: Fn(String, IpAddr) -> Fut,
     Fut: Future<Output = Option<Vec<u8>>>,
 {
-    let socket = UdpSocket::bind("127.0.0.1:0").await?;
+    let src = info.addr_src;
+    let socket = UdpSocket::bind((info.addr_dst, 0)).await?;
     println!(
-        "{src}: Connecting from {}",
-        socket.local_addr().expect("Socket is bound")
+        "{}: Connecting back from {}",
+        src,
+        socket.local_addr().expect("Local addr should be set")
     );
 
     let Packet::Read(request) = packet else {
         Packet::error(ErrorCode::NotDefined, "Operation not supported")
-            .send_to(&socket, &src)
+            .send_to(&socket, &info.addr_src)
             .await?;
 
         return Err(Error::UnsupportedOperation(packet));
@@ -54,7 +59,7 @@ where
     let filename = request.filename();
     println!("{src}: {filename} [{:?}]", request.mode());
 
-    let Some(data) = callback(filename).await else {
+    let Some(data) = callback(filename.to_string(), info.addr_dst).await else {
         Packet::error(ErrorCode::FileNotFound, "Unknown file")
             .send_to(&socket, &src)
             .await?;
@@ -85,7 +90,7 @@ where
     let mut timeout = 0;
 
     loop {
-        // Send the first byte
+        // Send the first chunk
         if let Some((index, chunk)) = chunk {
             Packet::data((index + 1) as u16, chunk)
                 .send_to(&socket, &src)
@@ -145,21 +150,36 @@ where
     Ok(())
 }
 
-pub async fn serve<F, Fut>(callback: F) -> Result<!, Error>
+pub async fn serve<F, Fut>(ip: IpAddr, callback: F) -> Result<!, Error>
 where
-    F: (Fn(&str) -> Fut) + Clone + Send + 'static,
+    F: Fn(String, IpAddr) -> Fut + Clone + Send + 'static,
     Fut: Future<Output = Option<Vec<u8>>> + Send + 'static,
 {
-    let socket = UdpSocket::bind("127.0.0.1:69").await?;
+    let socket = PktInfoUdpSocket::new(Domain::IPV4)?;
+    socket.set_nonblocking(true)?;
 
-    println!("Server started");
+    let addr: SocketAddr = (ip, 69).into();
+    socket.bind(&addr.into())?;
+
+    let async_fd = AsyncFd::new(socket)?;
+    let mut buf = [0u8; PACKET_SIZE];
+
+    println!("Tftp server started on {addr}");
     loop {
-        let (packet, src) = Packet::recv_from(&socket).await?;
+        let mut guard = async_fd.readable().await?;
+
+        let (packet, info) = match guard.try_io(|inner| inner.get_ref().recv(&mut buf)) {
+            Ok(Ok((_, info))) => (buf.try_into()?, info),
+            Ok(Err(e)) => return Err(e)?,
+            // Socket was not ready
+            Err(_would_block) => continue,
+        };
 
         let callback = callback.clone();
+        let src = info.addr_src;
         tokio::spawn({
             async move {
-                if let Err(err) = handle_connection(src, packet, callback).await {
+                if let Err(err) = handle_connection(info, packet, callback).await {
                     println!("{src}: {err}")
                 }
             }

test

@@ -1 +0,0 @@
-


typos.toml

@@ -0,0 +1,2 @@
+[default.extend-words]
+rela = "rela"

xtask/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-repo_path = "1.2.4"
+repo_path = "1.4.1"
 schemars = { workspace = true }
 serde_json = { workspace = true }
 crete = { path = ".." }