fix: Only connections from localhost are allowed

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

@@ -14,6 +14,6 @@ jobs:
     - uses: actions/checkout@v6
       with:
         fetch-depth: 0
-      - uses: crate-ci/committed@v1.1.11
+    - uses: crate-ci/committed@master
       with:
         commits: "origin/${{ gitea.base_ref }}..HEAD"

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "ipxe/ipxe"]
+	path = ipxe/ipxe
+	url = git@github.com:rkubes/ipxe

.pre-commit-config.yaml

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

CHANGELOG.md

@@ -7,16 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.1.4](https://git.huizinga.dev/infra/crete/compare/v0.1.3...v0.1.4) - 2026-10-04
-
-### <!-- 2 -->Bug Fixes
-
-- Pin committed action
-
-### <!-- 5 -->Miscellaneous Tasks
-
-- Migrate to rust audit fork
-
 ## [0.1.3](https://git.huizinga.dev/infra/crete/compare/v0.1.2...v0.1.3) - 2026-04-21
 
 ### <!-- 0 -->Features

Cargo.toml

@@ -1,36 +1,41 @@
 [package]
 name = "crete"
-version = "0.1.4"
+version = "0.1.3"
 edition = "2024"
 default-run = "crete"
 publish = ["infra"]
 license = "GPL-3.0-or-later"
 
 [workspace]
-members = ["xtask"]
+members = ["ipxe", "xtask"]
 
 [workspace.dependencies]
-schemars = { version = "1.2.2", features = ["semver1"] }
-serde_json = "1.0.151"
+schemars = { version = "1.2.1", features = ["semver1"] }
+serde_json = "1.0.149"
 
 [dependencies]
-clap = { version = "4.6.7", features = ["derive"] }
-clap_complete = "4.6.11"
-gix-discover = { version = "0.56.0", features = ["sha1"] }
-minijinja = { version = "2.24.0", features = ["json", "loader"] }
+async-walkdir = "2.1.0"
+byteorder = "1.5.0"
+clap = { version = "4.6.0", features = ["derive"] }
+clap_complete = "4.6.0"
+futures = "0.3.34"
+gix-discover = { version = "0.55.0", features = ["sha1"] }
+minijinja = { version = "2.18.0", features = ["json", "loader"] }
+netascii = "0.1.0"
+num_enum = "0.7.6"
 optional_struct = "0.5.2"
-reqwest = { version = "0.13.5", default-features = false, features = [
-  "blocking",
-  "stream",
+regex = "1.13.1"
+reqwest = { version = "0.13.2", default-features = false, features = [
   "native-tls",
 ] }
 schemars = { workspace = true }
-semver = { version = "1.0.28", features = ["serde"] }
-serde = { version = "1.0.229", features = ["derive"] }
+semver = { version = "1.0.27", features = ["serde"] }
+serde = { version = "1.0.228", features = ["derive"] }
 serde_json = { workspace = true }
 serde_yaml = "0.9.34"
-thiserror = "2.0.21"
-walkdir = "2.5.0"
+thiserror = "2.0.18"
+tokio = { version = "1.52.1", features = ["full"] }
+ipxe = { path = "./ipxe" }
 
 [lib]
 test = false

ipxe/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "ipxe"
+version = "0.1.0"
+edition = "2024"
+
+[build-dependencies]
+build-print = "1.0.1"
+
+[dependencies]
+include_dir = "0.7.4"

ipxe/build.rs

@@ -0,0 +1,57 @@
+use std::env;
+use std::path::PathBuf;
+use std::process::{Command, Stdio};
+
+use build_print::error;
+
+fn main() {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap())
+        .canonicalize()
+        .unwrap();
+    let src_dir = manifest_dir.join("ipxe").join("src");
+
+    let mut command = Command::new("make");
+    command
+        .stdout(Stdio::piped())
+        .current_dir(&src_dir)
+        .env_remove("DEBUG")
+        .env_remove("PROFILE")
+        .args([
+            "-j",
+            &std::thread::available_parallelism()
+                .unwrap()
+                .get()
+                .to_string(),
+        ])
+        .arg(format!(
+            "EMBED={}",
+            manifest_dir
+                .join("src")
+                .join("embed.ipxe")
+                .to_string_lossy(),
+        ));
+
+    let files = ["bin/ipxe.pxe", "bin-x86_64-efi/ipxe.efi"].map(PathBuf::from);
+    for file in &files {
+        command.arg(file);
+    }
+
+    let output = command.output().unwrap();
+    if !output.status.success() {
+        error!("{}", String::from_utf8_lossy(&output.stderr));
+    }
+
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap())
+        .canonicalize()
+        .unwrap()
+        .join("ipxe");
+
+    std::fs::remove_dir_all(&out_dir).ok();
+    for file in &files {
+        let input = src_dir.join(file);
+        let output = out_dir.join(file.file_name().unwrap());
+
+        std::fs::create_dir_all(output.parent().unwrap()).unwrap();
+        std::fs::copy(input, output).unwrap();
+    }
+}

ipxe/src/embed.ipxe

@@ -0,0 +1,5 @@
+#!ipxe
+
+dhcp
+
+echo "Hello, World!"

ipxe/src/lib.rs

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

rust-toolchain.toml

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

src/cli.rs

@@ -49,4 +49,6 @@ pub enum Commands {
     Generate,
     /// Generate completions for your current shell
     ShellCompletions,
+    /// Serve config files over tftp
+    Serve,
 }

src/cluster.rs

@@ -1,18 +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)]
@@ -68,31 +72,35 @@ struct ClusterDeserialize {
     base: Base,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct Cluster {
     pub(crate) name: String,
     pub(crate) version: Version,
-    nodes: Vec<Node>,
+    nodes: HashMap<String, Node>,
     cluster_env: ClusterEnv,
     pub(crate) control_plane_ip: Ipv4Addr,
     pub(crate) secrets_file: PathBuf,
 }
 
 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();
 
@@ -114,28 +122,32 @@ impl Cluster {
         let cluster = Self {
             name: cluster_name.into(),
             version: cluster.version,
-            nodes: vec![],
+            nodes: Default::default(),
             cluster_env: cluster.cluster_env,
             control_plane_ip: cluster.control_plane_ip,
             secrets_file,
         };
 
-        let nodes = nodes
-            .iter()
-            .map(|name| Node::get(name, env, &cluster, &default, &base))
-            .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() -> Vec<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("");
 
@@ -145,18 +157,35 @@ impl Cluster {
                     return None;
                 }
 
-                Some(Cluster::get(&name, &env))
+                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) -> &[Node] {
-        &self.nodes
+    pub fn nodes(&self) -> impl Iterator<Item = &Node> {
+        self.nodes.values()
     }
 
-    pub fn talosctl_gen_config_command(&self) -> Command {
-        let path = get_configs_path().join(&self.name).join("talosconfig");
+    pub fn node(&self, node: &str) -> Option<&Node> {
+        self.nodes.get(node)
+    }
 
+    pub async fn talosconfig(&self) -> String {
         let mut command = Command::new("talosctl");
         command.args([
             "gen",
@@ -168,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,
@@ -76,6 +78,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 +105,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/lib.rs

@@ -1,13 +1,17 @@
-#![feature(impl_trait_in_assoc_type, path_absolute_method)]
+#![feature(path_absolute_method, never_type)]
 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();
 
@@ -28,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,13 +1,19 @@
 mod cli;
 
-use std::process::Command;
+use std::pin::pin;
 
 use clap::{CommandFactory, Parser};
 use clap_complete::{Shell, generate as generate_complete};
 use crete::cluster::Cluster;
 use crete::environment::PathEnvironment;
-use crete::{get_configs_path, get_repo_path, set_repo_path};
+use crete::talosconfig::{get_current_context, set_context};
+use crete::tftp::ServerError;
+use crete::{get_configs_path, get_repo_path, set_repo_path, tftp};
+use futures::StreamExt;
+use futures::future::join_all;
+use ipxe::IPXE_DIR;
 use minijinja::context;
+use regex::Regex;
 use thiserror::Error;
 
 use crate::cli::{Cli, Commands, GlobalOpts};
@@ -16,80 +22,122 @@ use crate::cli::{Cli, Commands, GlobalOpts};
 enum Error {
     #[error("No clusters where found")]
     NoClustersFound,
+    #[error("Server error: {0}")]
+    ServerError(#[from] ServerError),
 }
 
-fn run_command(mut command: Command) {
-    let output = command.output().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());
-    }
-}
-
-fn generate(opts: &GlobalOpts) -> Result<(), Error> {
-    set_repo_path(&opts.repo);
-
-    let clusters = Cluster::get_all();
+async fn generate(opts: &GlobalOpts) -> Result<(), Error> {
+    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
             .render(context! {
-                clusters,
+                clusters => clusters.values().collect::<Vec<_>>(),
                 root => opts.repo
             })
             .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 {
-        for node in cluster.nodes() {
-            run_command(node.talosctl_gen_config_command(&cluster));
+    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;
+
+        // 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;
+
+    // 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;
     }
 
-        run_command(cluster.talosctl_gen_config_command());
-        run_command(cluster.talosctl_add_endpoint_command());
-        run_command(cluster.talosctl_merge_command());
+    if let Some(context) = context {
+        set_context(context).await;
     }
 
     Ok(())
 }
 
-fn main() -> Result<(), Error> {
+#[tokio::main]
+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)?,
+        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 => {
+            let re = Regex::new(r"talos/(?<cluster>.+)/(?<node>.+)\.ya?ml")
+                .expect("regex should be valid");
+
+            tftp::serve(move |filename| {
+                let filename = filename.to_owned();
+                let re = re.clone();
+
+                async move {
+                    const IPXE_PATTERN: &str = "ipxe/";
+                    if let Some(filename) = filename.strip_prefix(IPXE_PATTERN) {
+                        Some(IPXE_DIR.get_file(filename)?.contents().to_owned())
+                    } 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())
+                    } else {
+                        None
+                    }
+                }
+            })
+            .await?
+        }
     };
 
     Ok(())

src/node.rs

@@ -1,16 +1,17 @@
 use std::net::Ipv4Addr;
-use std::process::Command;
+use std::path::PathBuf;
 
 use minijinja::Environment;
 use optional_struct::{Applicable, optional_struct};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+use tokio::process::Command;
 
 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};
+use crate::{get_configs_path, get_talos_path, run_command};
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema, Clone, Copy, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
@@ -90,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,
@@ -106,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,
@@ -121,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();
 
@@ -172,15 +173,16 @@ impl Node {
         };
 
         // Render patches
-        let patches = patches.render(env, cluster, &node);
+        let patches = patches.render(env, cluster, &node).await;
 
         Node { patches, ..node }
     }
 
-    pub fn talosctl_gen_config_command(&self, cluster: &Cluster) -> Command {
-        let mut path = get_configs_path().join(&cluster.name).join(&self.hostname);
-        path.add_extension("yaml");
+    pub fn hostname(&self) -> &str {
+        &self.hostname
+    }
 
+    pub async fn config(&self, cluster: &Cluster) -> String {
         let mut command = Command::new("talosctl");
         command.args([
             "gen",
@@ -204,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 {
@@ -218,7 +220,25 @@ impl Node {
             ]);
         }
 
-        command
+        run_command(command).await
+    }
+
+    pub fn config_path(&self, cluster: &Cluster) -> PathBuf {
+        let mut path = get_configs_path().join(&cluster.name).join(&self.hostname);
+        path.add_extension("yaml");
+
+        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();
     }
 }
 

src/patch.rs

@@ -16,15 +16,21 @@ 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> {
+    let env = env.clone();
+    let cluster = cluster.clone();
+    let node = node.clone();
+
+    // Minijinja will still have blocking I/O internally
+    tokio::task::spawn_blocking(move || {
         patches
             .into_iter()
-        .map(|name| {
+            .map(move |name| {
                 let content = env
                     .get_template(&name)
                     .unwrap()
@@ -37,6 +43,9 @@ fn render(
                 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

@@ -1,5 +1,6 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Deserializer, Serialize};
+use tokio::runtime::Handle;
 
 use crate::get_talos_path;
 
@@ -11,7 +12,7 @@ where
     let path = get_talos_path().join("schematics").join(name);
     let content = std::fs::read_to_string(path).unwrap().trim().to_owned();
 
-    let client = reqwest::blocking::ClientBuilder::new()
+    let client = reqwest::ClientBuilder::new()
         .user_agent(format!(
             "{}/{}",
             std::env!("CARGO_PKG_NAME"),
@@ -20,20 +21,30 @@ where
         .build()
         .unwrap();
 
-    let res = client
-        .post("https://factory.talos.dev/schematics")
-        .body(content)
-        .send()
-        .map_err(serde::de::Error::custom)?;
-
     #[derive(Debug, Deserialize)]
     struct Response {
         id: String,
     }
 
-    let response: Response = serde_json::from_str(&res.text().map_err(serde::de::Error::custom)?)
+    // 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(&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/error.rs

@@ -0,0 +1,20 @@
+use std::io;
+use std::string::FromUtf8Error;
+
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("Invalid op code '{0}'")]
+    InvalidOpCode(u16),
+    #[error("Invalid error code '{0}'")]
+    InvalidErrorCode(u16),
+    #[error("Invalid mode '{0}'")]
+    InvalidMode(String),
+    #[error("String contains invalid characters")]
+    InvalidString(#[from] FromUtf8Error),
+    #[error("Unterminated string")]
+    UnterminatedString,
+    #[error("Io error: {0}")]
+    Io(#[from] io::Error),
+}

src/tftp/mod.rs

@@ -0,0 +1,7 @@
+mod error;
+mod packet;
+mod server;
+
+pub use error::Error;
+pub use packet::Packet;
+pub use server::{Error as ServerError, serve};

src/tftp/packet.rs

@@ -0,0 +1,353 @@
+use std::io::{BufRead, BufReader, BufWriter, Cursor, Read, Write};
+use std::net::SocketAddr;
+
+use byteorder::{NetworkEndian, ReadBytesExt, WriteBytesExt};
+use num_enum::{IntoPrimitive, TryFromPrimitive};
+use tokio::net::UdpSocket;
+
+use crate::tftp::Error;
+
+// 2 bytes op code + 2 bytes block number + max 512 bytes data
+pub(crate) const PACKET_SIZE: usize = 2 + 2 + 512;
+
+fn decode_null_terminated<R>(reader: &mut BufReader<R>) -> Result<String, Error>
+where
+    R: Read + ?Sized,
+{
+    let mut text = Vec::new();
+    reader.read_until(0, &mut text)?;
+
+    // Make sure we ended with a null terminator
+    match text.pop() {
+        Some(0) => {}
+        None | Some(_) => return Err(Error::UnterminatedString),
+    }
+
+    Ok(String::from_utf8(text)?)
+}
+
+fn encode_null_terminated<W>(writer: &mut BufWriter<W>, text: impl AsRef<str>) -> Result<(), Error>
+where
+    W: Write + ?Sized,
+{
+    let text = text.as_ref().as_bytes();
+    writer.write_all(text)?;
+
+    // Add null terminator
+    writer.write_u8(0)?;
+
+    Ok(())
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Mode {
+    NetAscii,
+    Octet,
+    Mail,
+}
+
+impl Mode {
+    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
+    where
+        R: Read + ?Sized,
+    {
+        let mut mode = decode_null_terminated(reader)?;
+        mode.make_ascii_lowercase();
+        let mode = mode;
+
+        Ok(match mode.as_str() {
+            "netascii" => Self::NetAscii,
+            "octet" => Self::Octet,
+            "mail" => Self::Mail,
+            _ => return Err(Error::InvalidMode(mode)),
+        })
+    }
+
+    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
+    where
+        W: Write + ?Sized,
+    {
+        let mode = match &self {
+            Mode::NetAscii => "netascii",
+            Mode::Octet => "octet",
+            Mode::Mail => "mail",
+        };
+
+        encode_null_terminated(writer, mode)?;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Request {
+    filename: String,
+    mode: Mode,
+}
+
+impl Request {
+    pub fn filename(&self) -> &str {
+        &self.filename
+    }
+
+    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
+    where
+        R: Read + ?Sized,
+    {
+        let filename = decode_null_terminated(reader)?;
+        let mode = Mode::decode(reader)?;
+
+        Ok(Self { filename, mode })
+    }
+
+    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
+    where
+        W: Write + ?Sized,
+    {
+        encode_null_terminated(writer, &self.filename)?;
+        self.mode.encode(writer)?;
+
+        Ok(())
+    }
+
+    pub fn mode(&self) -> Mode {
+        self.mode
+    }
+}
+
+#[derive(Debug)]
+pub struct Data {
+    block: u16,
+    data: Vec<u8>,
+}
+
+impl Data {
+    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
+    where
+        R: Read + ?Sized,
+    {
+        let block = reader.read_u16::<NetworkEndian>()?;
+
+        let mut data = Vec::new();
+        reader.read_to_end(&mut data)?;
+
+        Ok(Self { data, block })
+    }
+
+    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
+    where
+        W: Write + ?Sized,
+    {
+        writer.write_u16::<NetworkEndian>(self.block)?;
+        writer.write_all(&self.data)?;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct Ack(u16);
+
+impl Ack {
+    pub fn block(&self) -> u16 {
+        self.0
+    }
+
+    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
+    where
+        R: Read + ?Sized,
+    {
+        let number = reader.read_u16::<NetworkEndian>()?;
+
+        Ok(Self(number))
+    }
+
+    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
+    where
+        W: Write + ?Sized,
+    {
+        writer.write_u16::<NetworkEndian>(self.0)?;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, TryFromPrimitive, IntoPrimitive, Clone, Copy)]
+#[repr(u16)]
+pub enum ErrorCode {
+    NotDefined,
+    FileNotFound,
+    AccessViolation,
+    DiskFull,
+    Illegal,
+    UnknownTransferId,
+    FileAlreadyExists,
+    NoSuchUser,
+}
+
+impl ErrorCode {
+    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
+    where
+        R: Read + ?Sized,
+    {
+        let code = reader.read_u16::<NetworkEndian>()?;
+        Self::try_from_primitive(code).map_err(|err| Error::InvalidErrorCode(err.number))
+    }
+
+    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
+    where
+        W: Write + ?Sized,
+    {
+        let code: u16 = (*self).into();
+
+        writer.write_u16::<NetworkEndian>(code)?;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct ErrorMessage {
+    code: ErrorCode,
+    message: String,
+}
+
+impl ErrorMessage {
+    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
+    where
+        R: Read + ?Sized,
+    {
+        let code = ErrorCode::decode(reader)?;
+        let message = decode_null_terminated(reader)?;
+
+        Ok(Self { code, message })
+    }
+
+    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
+    where
+        W: Write + ?Sized,
+    {
+        self.code.encode(writer)?;
+
+        encode_null_terminated(writer, &self.message)?;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub enum Packet {
+    Read(Request),
+    Write(Request),
+    Data(Data),
+    Ack(Ack),
+    Error(ErrorMessage),
+}
+
+impl Packet {
+    pub fn data(block: u16, data: &[u8]) -> Self {
+        Self::Data(Data {
+            block,
+            data: data.into(),
+        })
+    }
+
+    pub fn ack(block: u16) -> Self {
+        Self::Ack(Ack(block))
+    }
+
+    pub fn error(code: ErrorCode, message: impl Into<String>) -> Self {
+        Self::Error(ErrorMessage {
+            code,
+            message: message.into(),
+        })
+    }
+
+    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
+    where
+        R: Read + ?Sized,
+    {
+        let op_code = reader.read_u16::<NetworkEndian>()?;
+
+        Ok(match op_code {
+            1 => Self::Read(Request::decode(reader)?),
+            2 => Self::Write(Request::decode(reader)?),
+            3 => Self::Data(Data::decode(reader)?),
+            4 => Self::Ack(Ack::decode(reader)?),
+            5 => Self::Error(ErrorMessage::decode(reader)?),
+            _ => return Err(Error::InvalidOpCode(op_code)),
+        })
+    }
+
+    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
+    where
+        W: Write + ?Sized,
+    {
+        match &self {
+            Self::Read(inner) => {
+                writer.write_u16::<NetworkEndian>(1)?;
+                inner.encode(writer)?;
+            }
+            Self::Write(inner) => {
+                writer.write_u16::<NetworkEndian>(2)?;
+                inner.encode(writer)?;
+            }
+            Self::Data(inner) => {
+                writer.write_u16::<NetworkEndian>(3)?;
+                inner.encode(writer)?;
+            }
+            Self::Ack(inner) => {
+                writer.write_u16::<NetworkEndian>(4)?;
+                inner.encode(writer)?;
+            }
+            Self::Error(inner) => {
+                writer.write_u16::<NetworkEndian>(5)?;
+                inner.encode(writer)?;
+            }
+        };
+
+        Ok(())
+    }
+
+    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 packet = buf.try_into()?;
+
+        Ok((packet, src))
+    }
+
+    pub async fn send_to(&self, socket: &UdpSocket, src: &SocketAddr) -> Result<(), Error> {
+        let buf: Vec<_> = self.try_into()?;
+        socket.send_to(&buf, src).await?;
+
+        Ok(())
+    }
+}
+
+impl TryFrom<&Packet> for Vec<u8> {
+    type Error = Error;
+
+    fn try_from(packet: &Packet) -> Result<Self, Self::Error> {
+        let mut buf = Vec::with_capacity(PACKET_SIZE);
+        let mut writer = BufWriter::new(Cursor::new(&mut buf));
+        packet.encode(&mut writer)?;
+
+        // Normally the writer would get dropped after we return, but since it has a mutable
+        // borrow in buf we have to drop it first.
+        drop(writer);
+
+        Ok(buf)
+    }
+}
+
+impl TryFrom<Vec<u8>> for Packet {
+    type Error = Error;
+
+    fn try_from(buf: Vec<u8>) -> Result<Self, <Packet as TryFrom<Vec<u8>>>::Error> {
+        let mut reader = BufReader::new(Cursor::new(buf));
+
+        Packet::decode(&mut reader)
+    }
+}

src/tftp/server.rs

@@ -0,0 +1,168 @@
+use std::io;
+use std::net::SocketAddr;
+use std::time::Duration;
+
+use thiserror::Error;
+use tokio::net::UdpSocket;
+
+use crate::tftp::packet::{ErrorCode, Mode};
+use crate::tftp::{self, Packet};
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("{0}")]
+    Tftp(#[from] tftp::Error),
+    #[error("Io error: {0}")]
+    Io(#[from] io::Error),
+    #[error("Unsupported operation: {0:#?}")]
+    UnsupportedOperation(Packet),
+    #[error("File not found: {0}")]
+    FileNotFound(String),
+    #[error("Unsupported mode: {0:?}")]
+    UnsupportedMode(Mode),
+    #[error("Source changed: {0}")]
+    SourceChanged(SocketAddr),
+    #[error("UnexpectedPacket: {0:#?}")]
+    UnexpectedPacket(Packet),
+    #[error("Timeout")]
+    Timeout,
+}
+
+pub async fn handle_connection<F, Fut>(
+    src: SocketAddr,
+    packet: Packet,
+    callback: F,
+) -> Result<(), Error>
+where
+    F: Fn(&str) -> Fut,
+    Fut: Future<Output = Option<Vec<u8>>>,
+{
+    let socket = UdpSocket::bind("0.0.0.0:0").await?;
+    println!(
+        "{src}: Connecting from {}",
+        socket.local_addr().expect("Socket is bound")
+    );
+
+    let Packet::Read(request) = packet else {
+        Packet::error(ErrorCode::NotDefined, "Operation not supported")
+            .send_to(&socket, &src)
+            .await?;
+
+        return Err(Error::UnsupportedOperation(packet));
+    };
+
+    let filename = request.filename();
+    println!("{src}: {filename} [{:?}]", request.mode());
+
+    let Some(data) = callback(filename).await else {
+        Packet::error(ErrorCode::FileNotFound, "Unknown file")
+            .send_to(&socket, &src)
+            .await?;
+
+        return Err(Error::FileNotFound(filename.into()));
+    };
+
+    let mode = request.mode();
+    let data = match mode {
+        // In case of netascii mode we need to re-encode to escape certain sequences
+        Mode::NetAscii => netascii::Netascii::from_bytes(data).collect(),
+        Mode::Octet => data,
+        _ => {
+            Packet::error(
+                ErrorCode::NotDefined,
+                format!("Mode {mode:?} is not supported"),
+            )
+            .send_to(&socket, &src)
+            .await?;
+
+            return Err(Error::UnsupportedMode(mode));
+        }
+    };
+
+    let mut chunks = data.chunks(512).enumerate();
+    let mut chunk = chunks.next();
+
+    let mut timeout = 0;
+
+    loop {
+        // Send the first chunk
+        if let Some((index, chunk)) = chunk {
+            Packet::data((index + 1) as u16, chunk)
+                .send_to(&socket, &src)
+                .await?;
+        }
+
+        tokio::select! {
+            recv = Packet::recv_from(&socket) => {
+                timeout = 0;
+                let (packet, new_src) = recv?;
+
+                // I think this is might technically be possible and fine, but I don't
+                // really know how to test it properly so we don't support it.
+                if new_src != src {
+                    Packet::error(ErrorCode::Illegal, "Source changed")
+                        .send_to(&socket, &src)
+                        .await?;
+
+                    return Err(Error::SourceChanged(new_src));
+                }
+
+                match packet {
+                    Packet::Ack(ack) => {
+                        // If we receive an ack for the current chunk go to the next one
+                        if let Some((index, _)) = chunk
+                            && (index + 1) as u16 == ack.block()
+                        {
+                            chunk = chunks.next();
+                        }
+
+                        if chunk.is_none() {
+                            break;
+                        }
+                    }
+                    _ => {
+                        Packet::error(ErrorCode::Illegal, "Unexpected packet")
+                            .send_to(&socket, &src)
+                            .await?;
+
+
+                        return Err(Error::UnexpectedPacket(packet));
+                    }
+                }
+            },
+            _ = tokio::time::sleep(Duration::from_secs(1)) => {
+                timeout += 1;
+
+                if timeout == 5 {
+                    return Err(Error::Timeout);
+                }
+            }
+        }
+    }
+
+    println!("{src}: Transmission complete");
+
+    Ok(())
+}
+
+pub async fn serve<F, Fut>(callback: F) -> Result<!, Error>
+where
+    F: Fn(&str) -> Fut + Clone + Send + 'static,
+    Fut: Future<Output = Option<Vec<u8>>> + Send + 'static,
+{
+    let socket = UdpSocket::bind("0.0.0.0:69").await?;
+
+    println!("Server started");
+    loop {
+        let (packet, src) = Packet::recv_from(&socket).await?;
+
+        let callback = callback.clone();
+        tokio::spawn({
+            async move {
+                if let Err(err) = handle_connection(src, packet, callback).await {
+                    println!("{src}: {err}")
+                }
+            }
+        });
+    }
+}

xtask/Cargo.toml

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