Skip to content
1        10        20        30        40        50        60        70        80        901use std::{2    collections::HashMap,3    io::{Seek, SeekFrom},4};56use bollard::models::{7    ContainerCreateBody, EndpointSettings, HostConfig, HostConfigLogConfig, Mount, MountType,8    NetworkingConfig, PortBinding, RestartPolicy, RestartPolicyNameEnum,9};1011use super::{12    error::OnceError,13    model::{ONCE_LABEL, OnceState, ProxySettings},14    namespace::{Application, Namespace},15};1617const PROXY_IMAGE: &str = "basecamp/kamal-proxy:once-01";18const STATE_DIRECTORY: &str = "/home/kamal-proxy/.config/kamal-proxy";19const STATE_FILE: &str = "once-state.json";2021pub async fn boot(namespace: &mut Namespace) -> Result<(), OnceError> {22    let proxy_name = format!("{}-proxy", namespace.name);23    if let Some(container) =24        namespace25            .engine26            .list_containers()27            .await?28            .into_iter()29            .find(|container| {30                container31                    .names32                    .iter()33                    .any(|name| name.trim_start_matches('/') == proxy_name)34            })35    {36        if container.state != "running" {37            namespace.engine.start_container(&container.id).await?;38        }39        namespace.proxy_settings = match container.labels.get(ONCE_LABEL) {40            Some(label) if !label.is_empty() => Some(serde_json::from_str(label)?),41            _ => Some(ProxySettings::once_defaults()),42        };43        return Ok(());44    }4546    let settings = ProxySettings::once_defaults();47    namespace.engine.pull_image(PROXY_IMAGE).await?;48    namespace49        .engine50        .ensure_volume(&proxy_name, HashMap::new())51        .await?;5253    let labels = HashMap::from([(ONCE_LABEL.to_owned(), serde_json::to_string(&settings)?)]);54    let exposed_ports = vec![55        "80/tcp".to_owned(),56        "443/tcp".to_owned(),57        format!("{}/tcp", settings.metrics_port),58    ];59    let port_bindings = proxy_port_bindings(&settings);6061    let config = ContainerCreateBody {62        image: Some(PROXY_IMAGE.to_owned()),63        cmd: Some(vec![64            "kamal-proxy".to_owned(),65            "run".to_owned(),66            "--metrics-port".to_owned(),67            settings.metrics_port.to_string(),68        ]),69        labels: Some(labels),70        exposed_ports: Some(exposed_ports),71        host_config: Some(HostConfig {72            port_bindings: Some(port_bindings),73            restart_policy: Some(RestartPolicy {74                name: Some(RestartPolicyNameEnum::ALWAYS),75                maximum_retry_count: None,76            }),77            log_config: Some(HostConfigLogConfig {78                typ: Some("json-file".to_owned()),79                config: Some(HashMap::from([80                    ("max-size".to_owned(), "10m".to_owned()),81                    ("max-file".to_owned(), "1".to_owned()),82                ])),83            }),84            mounts: Some(vec![Mount {85                typ: Some(MountType::VOLUME),86                source: Some(proxy_name.clone()),87                target: Some("/home/kamal-proxy/.config/kamal-proxy".to_owned()),88                ..Default::default()89            }]),90            ..Default::default()91        }),92        networking_config: Some(NetworkingConfig {93            endpoints_config: Some(HashMap::from([(94                namespace.name.clone(),95                EndpointSettings::default(),96            )])),97        }),98        ..Default::default()99    };100101    let id = namespace102        .engine103        .create_container(&proxy_name, config)104        .await?;105    if let Err(error) = namespace.engine.start_container(&id).await {106        let _ = namespace.engine.remove_container(&id).await;107        return Err(error);108    }109    namespace.proxy_settings = Some(settings);110    Ok(())111}112113fn proxy_port_bindings(settings: &ProxySettings) -> HashMap<String, Option<Vec<PortBinding>>> {114    let mut port_bindings = HashMap::new();115    port_bindings.insert(116        "80/tcp".to_owned(),117        Some(vec![PortBinding {118            host_ip: None,119            host_port: Some(settings.http_port.to_string()),120        }]),121    );122    port_bindings.insert(123        "443/tcp".to_owned(),124        Some(vec![PortBinding {125            host_ip: None,126            host_port: Some(settings.https_port.to_string()),127        }]),128    );129    port_bindings.insert(130        format!("{}/tcp", settings.metrics_port),131        Some(vec![PortBinding {132            host_ip: Some("127.0.0.1".to_owned()),133            host_port: Some(settings.metrics_port.to_string()),134        }]),135    );136    port_bindings137}138139/// The Docker-network address of a container's HTTP listener, as kamal-proxy140/// and other containers on the namespace network reach it: the short container141/// id, plus the port when a server app listens somewhere other than 80.142pub fn target_address(app: &Application, target: &str) -> String {143    let short_id = target.chars().take(12).collect::<String>();144    let port = if app.is_server {145        app.settings146            .env_vars147            .get("PORT")148            .and_then(|value| value.parse::<u16>().ok())149            .filter(|port| *port != 80)150    } else {151        None152    };153    port.map_or(short_id.clone(), |port| format!("{short_id}:{port}"))154}155156pub async fn deploy(157    namespace: &Namespace,158    app: &Application,159    target: &str,160) -> Result<(), OnceError> {161    let proxy_target = target_address(app, target);162    let mut command = vec![163        "kamal-proxy".to_owned(),164        "deploy".to_owned(),165        app.settings.name.clone(),166        "--target".to_owned(),167        proxy_target,168        "--deploy-timeout".to_owned(),169        "120s".to_owned(),170    ];171    if !app.settings.host.is_empty() {172        command.push("--host".to_owned());173        command.push(app.settings.host.clone());174    }175    if app.settings.tls_enabled() {176        command.push("--tls".to_owned());177    }178179    let proxy_container = format!("{}-proxy", namespace.name);180    let (exit_code, output) = namespace181        .engine182        .exec_capture(&proxy_container, &command)183        .await?;184    if exit_code != 0 {185        return Err(OnceError::Docker(format!(186            "proxy deploy exited with status {exit_code}: {output}"187        )));188    }189    Ok(())190}191192pub async fn remove(namespace: &Namespace, app_name: &str) -> Result<(), OnceError> {193    let proxy_container = format!("{}-proxy", namespace.name);194    let command = vec![195        "kamal-proxy".to_owned(),196        "remove".to_owned(),197        app_name.to_owned(),198    ];199    let (exit_code, output) = namespace200        .engine201        .exec_capture(&proxy_container, &command)202        .await?;203    if exit_code != 0 {204        return Err(OnceError::Docker(format!(205            "proxy remove exited with status {exit_code}: {output}"206        )));207    }208    Ok(())209}210211pub async fn load_state(namespace: &Namespace) -> Result<OnceState, OnceError> {212    let proxy_container = format!("{}-proxy", namespace.name);213    let state_path = format!("{STATE_DIRECTORY}/{STATE_FILE}");214    if !namespace215        .engine216        .container_path_exists(&proxy_container, &state_path)217        .await?218    {219        return Ok(OnceState::default());220    }221    let mut archive_data = tempfile::tempfile()?;222    namespace223        .engine224        .download_container_path(&proxy_container, &state_path, &mut archive_data)225        .await?;226    archive_data.seek(SeekFrom::Start(0))?;227    let mut archive = tar::Archive::new(archive_data);228    let entry = archive229        .entries()?230        .next()231        .ok_or_else(|| OnceError::InvalidMetadata("proxy state archive is empty".into()))??;232    Ok(serde_json::from_reader(entry)?)233}234235pub async fn save_state(namespace: &Namespace, state: &OnceState) -> Result<(), OnceError> {236    let mut archive_data = tempfile::tempfile()?;237    {238        let data = serde_json::to_vec_pretty(state)?;239        let mut archive = tar::Builder::new(&mut archive_data);240        let mut header = tar::Header::new_gnu();241        header.set_size(data.len() as u64);242        header.set_mode(0o644);243        header.set_cksum();244        archive.append_data(&mut header, STATE_FILE, data.as_slice())?;245        archive.finish()?;246    }247    archive_data.seek(SeekFrom::Start(0))?;248    namespace249        .engine250        .upload_archive_to_container(251            &format!("{}-proxy", namespace.name),252            STATE_DIRECTORY,253            archive_data,254        )255        .await256}257258#[cfg(test)]259mod tests {260    use std::collections::HashMap;261262    use super::*;263    use crate::commands::once::model::AppSettings;264265    fn app(is_server: bool, port: Option<&str>) -> Application {266        let mut env_vars = HashMap::new();267        if let Some(port) = port {268            env_vars.insert("PORT".to_owned(), port.to_owned());269        }270        Application {271            container_id: "0123456789abcdef".into(),272            settings: AppSettings {273                env_vars,274                ..AppSettings::default()275            },276            running: true,277            created: 0,278            is_server,279        }280    }281282    #[test]283    fn target_address_uses_the_short_id_and_a_non_default_server_port() {284        let plain = app(false, None);285        assert_eq!(target_address(&plain, "0123456789abcdef"), "0123456789ab");286        assert_eq!(287            target_address(&app(true, None), "0123456789abcdef"),288            "0123456789ab"289        );290        assert_eq!(291            target_address(&app(true, Some("80")), "0123456789abcdef"),292            "0123456789ab"293        );294        assert_eq!(295            target_address(&app(true, Some("8080")), "0123456789abcdef"),296            "0123456789ab:8080"297        );298        // Non-server apps ignore PORT; kamal-proxy reaches them on the default port.299        assert_eq!(300            target_address(&app(false, Some("8080")), "0123456789abcdef"),301            "0123456789ab"302        );303    }304}