Skip to content
1        10        20        30        40        50        60        70        80        901//! Real-Docker checks for the environment API. Each run gets its own namespace2//! and proxy on random host ports, and removes everything it created.34use std::{5    collections::{BTreeMap, HashMap},6    net::TcpListener,7    sync::Arc,8    time::{SystemTime, UNIX_EPOCH},9};1011use bollard::{12    Docker,13    models::{14        ContainerCreateBody, EndpointSettings, HostConfig, Mount, MountType, NetworkingConfig,15        PortBinding, RestartPolicy, RestartPolicyNameEnum,16    },17    query_parameters::{18        CreateContainerOptionsBuilder, ListContainersOptionsBuilder, ListVolumesOptionsBuilder,19        RemoveContainerOptionsBuilder, RemoveVolumeOptionsBuilder,20    },21};2223use super::{app_environment, deploy_api, set_env_api};24use crate::commands::once::{25    cli::SettingsFlags,26    docker::DockerEngine,27    error::OnceError,28    model::{ONCE_LABEL, ProxySettings},29    namespace::Namespace,30};3132const APP_IMAGE: &str = "ghcr.io/basecamp/writebook:latest";33const APP_HOST: &str = "localhost";3435#[tokio::test]36async fn environment_changes_redeploy_with_only_the_requested_variables() {37    let unique = SystemTime::now()38        .duration_since(UNIX_EPOCH)39        .unwrap()40        .as_nanos();41    let namespace = format!("ino-env-test-{}-{unique}", std::process::id());42    let docker = Docker::connect_with_local_defaults().unwrap();43    let engine = Arc::new(DockerEngine::connect().unwrap());4445    let listeners = (0..3)46        .map(|_| TcpListener::bind(("127.0.0.1", 0)).unwrap())47        .collect::<Vec<_>>();48    let ports = listeners49        .iter()50        .map(|listener| listener.local_addr().unwrap().port())51        .collect::<Vec<_>>();52    drop(listeners);5354    engine.ensure_network(&namespace).await.unwrap();55    create_isolated_proxy(&docker, &engine, &namespace, [ports[0], ports[1], ports[2]]).await;5657    let outcome = exercise_environment(engine.clone(), namespace.clone()).await;58    cleanup(&docker, &engine, &namespace).await;59    outcome.expect("environment API should work against real Docker");60}6162async fn exercise_environment(engine: Arc<DockerEngine>, namespace: String) -> Result<(), String> {63    let map_error = |error: OnceError| error.to_string();64    let mut namespace = Namespace::restore(engine.clone(), namespace)65        .await66        .map_err(map_error)?;67    namespace.setup().await.map_err(map_error)?;6869    let flags = SettingsFlags {70        host: Some(APP_HOST.to_owned()),71        disable_tls: Some(true),72        env: Some(vec!["MODE=one".to_owned(), "NOTE=first".to_owned()]),73        ..Default::default()74    };75    deploy_api(&mut namespace, APP_IMAGE, &flags)76        .await77        .map_err(map_error)?;78    namespace.refresh().await.map_err(map_error)?;79    let deployed = app_environment(&namespace, APP_HOST).map_err(map_error)?;80    expect_eq(81        &deployed.env,82        &env_of(&[("MODE", "one"), ("NOTE", "first")]),83        "deployed variables",84    )?;85    let first_container = container_id(&namespace)?;8687    let replacement = env_of(&[("MODE", "two"), ("API_TOKEN", "abc")]);88    set_env_api(&mut namespace, APP_HOST, &replacement)89        .await90        .map_err(map_error)?;91    namespace.refresh().await.map_err(map_error)?;92    let current = app_environment(&namespace, APP_HOST).map_err(map_error)?;93    expect_eq(&current.env, &replacement, "saved variables")?;94    let redeployed = container_id(&namespace)?;95    if redeployed == first_container {96        return Err("setting variables should redeploy the app in a new container".to_owned());97    }98    let runtime = engine99        .container_environment(&redeployed)100        .await101        .map_err(map_error)?;102    if !runtime.iter().any(|entry| entry == "MODE=two")103        || runtime.iter().any(|entry| entry == "NOTE=first")104    {105        return Err(format!(106            "container environment was not replaced: {runtime:?}"107        ));108    }109    if !runtime110        .iter()111        .any(|entry| entry.starts_with("SECRET_KEY_BASE="))112    {113        return Err("Once-managed SECRET_KEY_BASE should still be in the container".to_owned());114    }115    if !namespace116        .applications117        .iter()118        .any(|app| app.settings.host == APP_HOST && app.running)119    {120        return Err("the redeployed app should be running".to_owned());121    }122123    let reserved = set_env_api(124        &mut namespace,125        APP_HOST,126        &env_of(&[("SECRET_KEY_BASE", "override")]),127    )128    .await;129    if !matches!(reserved, Err(OnceError::ReservedEnvironment(_))) {130        return Err(format!(131            "reserved names should be refused, got {reserved:?}"132        ));133    }134    namespace.refresh().await.map_err(map_error)?;135    if container_id(&namespace)? != redeployed {136        return Err("a refused change should leave the container alone".to_owned());137    }138139    engine140        .stop_container(&redeployed)141        .await142        .map_err(map_error)?;143    namespace.refresh().await.map_err(map_error)?;144    let stopped = set_env_api(&mut namespace, APP_HOST, &env_of(&[("MODE", "three")])).await;145    if !matches!(stopped, Err(OnceError::ApplicationNotRunning(_))) {146        return Err(format!(147            "a stopped app should refuse changes, got {stopped:?}"148        ));149    }150    Ok(())151}152153fn container_id(namespace: &Namespace) -> Result<String, String> {154    namespace155        .applications156        .iter()157        .find(|app| app.settings.host == APP_HOST)158        .map(|app| app.container_id.clone())159        .ok_or_else(|| "deployed app was not found".to_owned())160}161162fn env_of(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {163    pairs164        .iter()165        .map(|(key, value)| ((*key).to_owned(), (*value).to_owned()))166        .collect()167}168169fn expect_eq(170    actual: &BTreeMap<String, String>,171    expected: &BTreeMap<String, String>,172    what: &str,173) -> Result<(), String> {174    if actual == expected {175        Ok(())176    } else {177        Err(format!(178            "unexpected {what}: {actual:?}, wanted {expected:?}"179        ))180    }181}182183/// Starts a kamal-proxy whose labels point at the test ports, so `Namespace::setup`184/// reuses it instead of binding the host's ports 80 and 443.185#[allow(clippy::similar_names)]186async fn create_isolated_proxy(187    docker: &Docker,188    engine: &DockerEngine,189    namespace: &str,190    [http_port, https_port, metrics_port]: [u16; 3],191) {192    let proxy_name = format!("{namespace}-proxy");193    engine194        .ensure_volume(&proxy_name, HashMap::new())195        .await196        .unwrap();197    let settings = ProxySettings {198        http_port,199        https_port,200        metrics_port,201    };202    let binding = |host_port: u16, host_ip: Option<&str>| {203        Some(vec![PortBinding {204            host_ip: host_ip.map(str::to_owned),205            host_port: Some(host_port.to_string()),206        }])207    };208    let config = ContainerCreateBody {209        image: Some("basecamp/kamal-proxy:once-01".to_owned()),210        cmd: Some(vec![211            "kamal-proxy".to_owned(),212            "run".to_owned(),213            "--metrics-port".to_owned(),214            metrics_port.to_string(),215        ]),216        labels: Some(HashMap::from([(217            ONCE_LABEL.to_owned(),218            serde_json::to_string(&settings).unwrap(),219        )])),220        exposed_ports: Some(vec![221            "80/tcp".to_owned(),222            "443/tcp".to_owned(),223            format!("{metrics_port}/tcp"),224        ]),225        host_config: Some(HostConfig {226            port_bindings: Some(HashMap::from([227                ("80/tcp".to_owned(), binding(http_port, None)),228                ("443/tcp".to_owned(), binding(https_port, None)),229                (230                    format!("{metrics_port}/tcp"),231                    binding(metrics_port, Some("127.0.0.1")),232                ),233            ])),234            restart_policy: Some(RestartPolicy {235                name: Some(RestartPolicyNameEnum::ALWAYS),236                maximum_retry_count: None,237            }),238            mounts: Some(vec![Mount {239                typ: Some(MountType::VOLUME),240                source: Some(proxy_name.clone()),241                target: Some("/home/kamal-proxy/.config/kamal-proxy".to_owned()),242                ..Default::default()243            }]),244            ..Default::default()245        }),246        networking_config: Some(NetworkingConfig {247            endpoints_config: Some(HashMap::from([(248                namespace.to_owned(),249                EndpointSettings::default(),250            )])),251        }),252        ..Default::default()253    };254    let options = CreateContainerOptionsBuilder::default()255        .name(&proxy_name)256        .build();257    let created = docker258        .create_container(Some(options), config)259        .await260        .expect("create isolated proxy");261    docker262        .start_container(&created.id, None)263        .await264        .expect("start isolated proxy");265}266267async fn cleanup(docker: &Docker, engine: &DockerEngine, namespace: &str) {268    let containers = docker269        .list_containers(Some(270            ListContainersOptionsBuilder::default().all(true).build(),271        ))272        .await273        .unwrap_or_default();274    for container in containers {275        let belongs = container.names.unwrap_or_default().iter().any(|name| {276            name.trim_start_matches('/')277                .starts_with(&format!("{namespace}-"))278        });279        if let Some(id) = container.id.filter(|_| belongs) {280            let options = RemoveContainerOptionsBuilder::default().force(true).build();281            let _ = docker.remove_container(&id, Some(options)).await;282        }283    }284    // App volumes carry the random suffix Ino gives each app name, so match by prefix.285    if let Ok(response) = docker286        .list_volumes(Some(ListVolumesOptionsBuilder::default().build()))287        .await288    {289        for volume in response.volumes.unwrap_or_default() {290            if volume.name.starts_with(&format!("{namespace}-")) {291                let options = RemoveVolumeOptionsBuilder::default().force(true).build();292                let _ = docker.remove_volume(&volume.name, Some(options)).await;293            }294        }295    }296    let _ = engine.remove_network(namespace).await;297}