LINE1 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}138139140141142pub 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 299 assert_eq!(300 target_address(&app(false, Some("8080")), "0123456789abcdef"),301 "0123456789ab"302 );303 }304}