LINE1 10 20 30 40 50 60 70 80 901234use 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(¤t.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}182183184185#[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 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}