feat(caddy): add ingress apply and stop commands

Author: andrasbacsai

coold/src/grpc/handlers.rs

@@ -1,14 +1,16 @@
 use std::sync::Arc;
 
-use anyhow::Result;
+use anyhow::{anyhow, Context, Result};
 use futures_util::future::join_all;
 use tokio::sync::mpsc;
+use tokio::{fs, process::Command};
 use tracing::{debug, warn};
 
 use crate::builder::BuilderCtx;
 use crate::grpc::proto::{
-    client_msg, response, server_msg, BuildResponseBody, ClientMsg, ContainerSummary, Error,
-    ListContainersResp, Response,
+    client_msg, response, server_msg, ApplyCaddyIngressResp, BuildResponseBody,
+    CaddyAppIngressFile, ClientMsg, ContainerSummary, Error, ListContainersResp, Response,
+    StopCaddyIngressResp,
 };
 use crate::podman::PodmanClient;
 
@@ -37,6 +39,40 @@ pub async fn handle(
             )
             .await;
         }
+        server_msg::Command::ApplyCaddyIngress(req) => {
+            let body = match apply_caddy_ingress(req.caddyfile, req.apps, req.mesh_network).await {
+                Ok(output) => response::Body::ApplyCaddyIngress(ApplyCaddyIngressResp { output }),
+                Err(e) => response::Body::Error(Error {
+                    code: 500,
+                    message: format!("{e:#}"),
+                }),
+            };
+            send_response(
+                &tx,
+                Response {
+                    request_id,
+                    body: Some(body),
+                },
+            )
+            .await;
+        }
+        server_msg::Command::StopCaddyIngress(_) => {
+            let body = match stop_caddy_ingress().await {
+                Ok(output) => response::Body::StopCaddyIngress(StopCaddyIngressResp { output }),
+                Err(e) => response::Body::Error(Error {
+                    code: 500,
+                    message: format!("{e:#}"),
+                }),
+            };
+            send_response(
+                &tx,
+                Response {
+                    request_id,
+                    body: Some(body),
+                },
+            )
+            .await;
+        }
         server_msg::Command::Build(req) => match builder_ctx {
             Some(ctx) => ctx.dispatch(request_id, req, tx),
             None => {
@@ -80,6 +116,212 @@ async fn send_response(tx: &mpsc::Sender<ClientMsg>, response: Response) {
     }
 }
 
+async fn apply_caddy_ingress(
+    caddyfile: String,
+    apps: Vec<CaddyAppIngressFile>,
+    mesh_network: String,
+) -> Result<String> {
+    if caddyfile.trim().is_empty() {
+        return Err(anyhow!("caddyfile is empty"));
+    }
+
+    if caddyfile.len() > 256 * 1024 || apps.iter().any(|app| app.caddyfile.len() > 256 * 1024) {
+        return Err(anyhow!("caddyfile is too large"));
+    }
+
+    if !is_valid_podman_network_name(&mesh_network) {
+        return Err(anyhow!("invalid mesh network name"));
+    }
+
+    let base_path = std::path::Path::new("/data/coolify/v5/ingress/caddy");
+    let apps_path = base_path.join("apps");
+    let caddyfile_path = base_path.join("Caddyfile");
+    let temp_caddyfile_path = base_path.join("Caddyfile.tmp");
+
+    fs::create_dir_all(&apps_path)
+        .await
+        .context("create Caddy app config directory")?;
+    fs::create_dir_all(base_path.join("data"))
+        .await
+        .context("create Caddy data directory")?;
+    fs::create_dir_all(base_path.join("config"))
+        .await
+        .context("create Caddy config directory")?;
+
+    let mut expected_files = std::collections::HashSet::new();
+    for app in apps {
+        let file_name = caddy_app_file_name(&app.name)?;
+        expected_files.insert(file_name.clone());
+        fs::write(apps_path.join(file_name), app.caddyfile)
+            .await
+            .context("write Caddy app config")?;
+    }
+
+    let mut entries = fs::read_dir(&apps_path)
+        .await
+        .context("read Caddy app config directory")?;
+    while let Some(entry) = entries
+        .next_entry()
+        .await
+        .context("read Caddy app config")?
+    {
+        let file_name = entry.file_name().to_string_lossy().to_string();
+        if file_name.ends_with(".caddy") && !expected_files.contains(&file_name) {
+            fs::remove_file(entry.path())
+                .await
+                .context("remove stale Caddy app config")?;
+        }
+    }
+
+    fs::write(&temp_caddyfile_path, caddyfile)
+        .await
+        .context("write temporary Caddyfile")?;
+
+    run_command(Command::new("podman").args(["pull", "docker.io/library/caddy:2-alpine"]))
+        .await
+        .context("pull Caddy image")?;
+
+    run_command(Command::new("podman").args([
+        "run",
+        "--rm",
+        "-v",
+        &format!("{}:/etc/caddy:ro", base_path.display()),
+        "docker.io/library/caddy:2-alpine",
+        "caddy",
+        "validate",
+        "--config",
+        "/etc/caddy/Caddyfile.tmp",
+    ]))
+    .await
+    .context("validate Caddyfile")?;
+
+    fs::rename(&temp_caddyfile_path, &caddyfile_path)
+        .await
+        .context("install Caddyfile")?;
+
+    start_or_reload_caddy(base_path, &mesh_network).await
+}
+
+async fn start_or_reload_caddy(base_path: &std::path::Path, mesh_network: &str) -> Result<String> {
+    if run_command(Command::new("podman").args(["container", "exists", "coolify-v5-caddy"]))
+        .await
+        .is_ok()
+    {
+        return run_command(Command::new("podman").args([
+            "exec",
+            "coolify-v5-caddy",
+            "caddy",
+            "reload",
+            "--config",
+            "/etc/caddy/Caddyfile",
+        ]))
+        .await
+        .map(|output| {
+            if output.trim().is_empty() {
+                "Caddy ingress applied.".into()
+            } else {
+                output
+            }
+        })
+        .context("reload Caddy ingress");
+    }
+
+    let output = run_command(Command::new("podman").args([
+        "run",
+        "-d",
+        "--replace",
+        "--name",
+        "coolify-v5-caddy",
+        "--network",
+        mesh_network,
+        "--restart",
+        "unless-stopped",
+        "-p",
+        "80:80",
+        "-p",
+        "443:443",
+        "-p",
+        "443:443/udp",
+        "-v",
+        &format!(
+            "{}:/etc/caddy/Caddyfile:ro",
+            base_path.join("Caddyfile").display()
+        ),
+        "-v",
+        &format!("{}:/etc/caddy/apps:ro", base_path.join("apps").display()),
+        "-v",
+        &format!("{}:/data", base_path.join("data").display()),
+        "-v",
+        &format!("{}:/config", base_path.join("config").display()),
+        "docker.io/library/caddy:2-alpine",
+    ]))
+    .await
+    .context("start Caddy ingress")?;
+
+    Ok(if output.trim().is_empty() {
+        "Caddy ingress applied.".into()
+    } else {
+        output
+    })
+}
+
+fn caddy_app_file_name(value: &str) -> Result<String> {
+    if value.is_empty()
+        || value.len() > 128
+        || !value
+            .bytes()
+            .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-'))
+    {
+        return Err(anyhow!("invalid Caddy app file name"));
+    }
+
+    Ok(format!("{value}.caddy"))
+}
+
+async fn stop_caddy_ingress() -> Result<String> {
+    let output = run_command(Command::new("podman").args(["rm", "-f", "coolify-v5-caddy"]))
+        .await
+        .context("stop Caddy ingress")?;
+
+    Ok(if output.trim().is_empty() {
+        "Caddy ingress stopped.".into()
+    } else {
+        output
+    })
+}
+
+fn is_valid_podman_network_name(value: &str) -> bool {
+    !value.is_empty()
+        && value.len() <= 128
+        && value
+            .bytes()
+            .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-'))
+}
+
+async fn run_command(command: &mut Command) -> Result<String> {
+    let output = command.output().await.context("run command")?;
+    let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+    let combined = [stdout.as_str(), stderr.as_str()]
+        .into_iter()
+        .filter(|part| !part.is_empty())
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    if !output.status.success() {
+        return Err(anyhow!(
+            "{}",
+            if combined.is_empty() {
+                format!("command exited with {}", output.status)
+            } else {
+                combined
+            }
+        ));
+    }
+
+    Ok(combined)
+}
+
 async fn list_containers(podman: &PodmanClient) -> Result<ListContainersResp> {
     let containers = podman.list_containers().await?;
 

flux/examples/fake_coold.rs

@@ -75,6 +75,34 @@ async fn main() -> Result<()> {
                 })
                 .await?;
             }
+            server_msg::Command::ApplyCaddyIngress(_) => {
+                let resp = Response {
+                    request_id,
+                    body: Some(response::Body::ApplyCaddyIngress(
+                        coolify_proto::agent::v1::ApplyCaddyIngressResp {
+                            output: "Caddy ingress applied.".into(),
+                        },
+                    )),
+                };
+                tx.send(ClientMsg {
+                    payload: Some(client_msg::Payload::Response(resp)),
+                })
+                .await?;
+            }
+            server_msg::Command::StopCaddyIngress(_) => {
+                let resp = Response {
+                    request_id,
+                    body: Some(response::Body::StopCaddyIngress(
+                        coolify_proto::agent::v1::StopCaddyIngressResp {
+                            output: "Caddy ingress stopped.".into(),
+                        },
+                    )),
+                };
+                tx.send(ClientMsg {
+                    payload: Some(client_msg::Payload::Response(resp)),
+                })
+                .await?;
+            }
             server_msg::Command::Build(_) | server_msg::Command::CancelBuild(_) => {
                 // fake_coold does not implement the builder capability.
             }

flux/src/envelope.rs

@@ -32,6 +32,24 @@ pub struct DispatchEnvelope {
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum CommandPayload {
     ListContainers,
+    ApplyCaddyIngress {
+        caddyfile: String,
+        #[serde(default)]
+        apps: Vec<CaddyAppIngressFile>,
+        #[serde(default = "default_caddy_mesh_network")]
+        mesh_network: String,
+    },
+    StopCaddyIngress,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct CaddyAppIngressFile {
+    pub name: String,
+    pub caddyfile: String,
+}
+
+fn default_caddy_mesh_network() -> String {
+    "coolify-default-mesh".into()
 }
 
 #[derive(Debug, Serialize)]
@@ -72,6 +90,12 @@ impl ResponseBody {
                 .unwrap_or(serde_json::Value::Null);
                 Some(ResponseBody::Ok { data })
             }
+            Some(Body::ApplyCaddyIngress(r)) => Some(ResponseBody::Ok {
+                data: serde_json::json!({ "output": r.output }),
+            }),
+            Some(Body::StopCaddyIngress(r)) => Some(ResponseBody::Ok {
+                data: serde_json::json!({ "output": r.output }),
+            }),
             Some(Body::Error(e)) => Some(ResponseBody::Error {
                 code: e.code,
                 message: e.message,