Skip to content
1        10        20        30        40        50        60        70        80        90        1001use std::io::Read;23use super::{4    cli::SettingsFlags,5    error::OnceError,6    model::{AppSettings, BackupSettings, ContainerResources, RegistrySettings, SmtpSettings},7};89impl SettingsFlags {10    pub fn build_settings(11        &self,12        name: String,13        image: &str,14        host: String,15    ) -> Result<AppSettings, OnceError> {16        let env_vars = parse_env_vars(self.env.as_deref().unwrap_or_default())?;17        if let Some(path) = &self.backup_path18            && !path.is_absolute()19        {20            return Err(OnceError::Io("backup path must be absolute".into()));21        }22        if self.auto_backup.unwrap_or(false) && self.backup_path.is_none() {23            return Err(OnceError::Io(24                "automatic backups require --backup-path".into(),25            ));26        }2728        let registry_password = if self.registry_password_stdin {29            let mut password = String::new();30            std::io::stdin()31                .read_to_string(&mut password)32                .map_err(|error| OnceError::Io(format!("reading registry password: {error}")))?;33            Some(password.trim_end_matches(['\r', '\n']).to_owned())34        } else {35            self.registry_password.clone()36        };37        let has_registry_credentials =38            self.registry_username.is_some() || registry_password.is_some();39        if has_registry_credentials40            && (self41                .registry_username42                .as_deref()43                .unwrap_or_default()44                .is_empty()45                || registry_password.as_deref().unwrap_or_default().is_empty())46        {47            return Err(OnceError::Io(48                "registry username and password must be provided together".into(),49            ));50        }5152        let registry = if has_registry_credentials {53            RegistrySettings {54                host: registry_host(image),55                username: self.registry_username.clone().unwrap_or_default(),56                password: registry_password.unwrap_or_default(),57            }58        } else {59            RegistrySettings::default()60        };6162        Ok(AppSettings {63            name,64            image: image.to_owned(),65            host,66            disable_tls: self.disable_tls.unwrap_or(false),67            env_vars,68            smtp: SmtpSettings {69                server: self.smtp_server.clone().unwrap_or_default(),70                port: self.smtp_port.clone().unwrap_or_default(),71                username: self.smtp_username.clone().unwrap_or_default(),72                password: self.smtp_password.clone().unwrap_or_default(),73                from: self.smtp_from.clone().unwrap_or_default(),74            },75            resources: ContainerResources {76                cpus: self.cpus.unwrap_or_default(),77                memory_mb: self.memory.unwrap_or_default(),78            },79            auto_update: self.auto_update.unwrap_or(true),80            backup: BackupSettings {81                path: self82                    .backup_path83                    .as_deref()84                    .map(|path| path.to_string_lossy().into_owned())85                    .unwrap_or_default(),86                auto_backup: self.auto_backup.unwrap_or(false),87            },88            registry,89            ..Default::default()90        })91    }9293    pub fn apply_changes(94        &self,95        existing: &AppSettings,96        new_image: Option<&str>,97    ) -> Result<AppSettings, OnceError> {98        let mut settings = existing.clone();99        if let Some(image) = new_image {100            image.clone_into(&mut settings.image);101        }102        if let Some(host) = &self.host {103            settings.host.clone_from(host);104        }105        if let Some(disable_tls) = self.disable_tls {106            settings.disable_tls = disable_tls;107        }108        if let Some(env) = &self.env {109            settings.env_vars = parse_env_vars(env)?;110        }111        if let Some(value) = &self.smtp_server {112            settings.smtp.server.clone_from(value);113        }114        if let Some(value) = &self.smtp_port {115            settings.smtp.port.clone_from(value);116        }117        if let Some(value) = &self.smtp_username {118            settings.smtp.username.clone_from(value);119        }120        if let Some(value) = &self.smtp_password {121            settings.smtp.password.clone_from(value);122        }123        if let Some(value) = &self.smtp_from {124            settings.smtp.from.clone_from(value);125        }126        if let Some(value) = self.cpus {127            settings.resources.cpus = value;128        }129        if let Some(value) = self.memory {130            settings.resources.memory_mb = value;131        }132        if let Some(value) = self.auto_update {133            settings.auto_update = value;134        }135        if let Some(path) = &self.backup_path {136            if !path.as_os_str().is_empty() && !path.is_absolute() {137                return Err(OnceError::Io("backup path must be absolute".into()));138            }139            settings.backup.path = path.to_string_lossy().into_owned();140        }141        if let Some(value) = self.auto_backup {142            settings.backup.auto_backup = value;143        }144145        let registry_changed = self.registry_username.is_some()146            || self.registry_password.is_some()147            || self.registry_password_stdin;148        if registry_changed {149            let password = if self.registry_password_stdin {150                let mut password = String::new();151                std::io::stdin()152                    .read_to_string(&mut password)153                    .map_err(|error| {154                        OnceError::Io(format!("reading registry password: {error}"))155                    })?;156                password.trim_end_matches(['\r', '\n']).to_owned()157            } else {158                self.registry_password.clone().unwrap_or_default()159            };160            let username = self.registry_username.clone().unwrap_or_default();161            if username.is_empty() != password.is_empty() {162                return Err(OnceError::Io(163                    "registry username and password must be provided together".into(),164                ));165            }166            if username.is_empty() {167                settings.registry = RegistrySettings::default();168            } else {169                settings.registry = RegistrySettings {170                    host: registry_host(&settings.image),171                    username,172                    password,173                };174            }175        }176177        if settings.backup.auto_backup && settings.backup.path.is_empty() {178            return Err(OnceError::Io(179                "automatic backups require --backup-path".into(),180            ));181        }182        Ok(settings)183    }184}185186pub fn parse_env_vars(187    values: &[String],188) -> Result<std::collections::HashMap<String, String>, OnceError> {189    let mut env = std::collections::HashMap::with_capacity(values.len());190    for value in values {191        let Some((key, value)) = value.split_once('=') else {192            return Err(OnceError::Io(format!(193                "invalid environment variable {value:?}: expected KEY=VALUE"194            )));195        };196        if key.is_empty() {197            return Err(OnceError::Io(198                "environment variable key must not be empty".into(),199            ));200        }201        env.insert(key.to_owned(), value.to_owned());202    }203    Ok(env)204}205206pub fn registry_host(image: &str) -> String {207    let image = image.split('@').next().unwrap_or(image);208    let first = image.split('/').next().unwrap_or(image);209    if image.contains('/') && (first.contains('.') || first.contains(':') || first == "localhost") {210        first.to_owned()211    } else {212        "docker.io".to_owned()213    }214}215216#[cfg(test)]217mod tests {218    use std::path::PathBuf;219220    use super::{parse_env_vars, registry_host};221    use crate::commands::once::cli::SettingsFlags;222223    #[test]224    fn parses_repeatable_environment_values_with_equals() {225        let vars = parse_env_vars(&["A=1".into(), "B=x=y".into()]).unwrap();226        assert_eq!(vars["A"], "1");227        assert_eq!(vars["B"], "x=y");228    }229230    #[test]231    fn rejects_invalid_environment_values() {232        assert!(parse_env_vars(&["missing-equals".into()]).is_err());233        assert!(parse_env_vars(&["=empty-key".into()]).is_err());234    }235236    #[test]237    fn derives_registry_host_using_docker_image_reference_rules() {238        assert_eq!(239            registry_host("ghcr.io/basecamp/writebook:latest"),240            "ghcr.io"241        );242        assert_eq!(registry_host("localhost:5000/team/app"), "localhost:5000");243        assert_eq!(registry_host("basecamp/writebook:latest"), "docker.io");244    }245246    #[test]247    fn builds_once_compatible_settings_from_cli_flags() {248        let flags = SettingsFlags {249            host: Some("books.example.test".into()),250            env: Some(vec!["MODE=prod".into()]),251            smtp_server: Some("smtp.example.test".into()),252            smtp_port: Some("587".into()),253            cpus: Some(2),254            memory: Some(1024),255            backup_path: Some(PathBuf::from("/var/backups")),256            auto_backup: Some(true),257            registry_username: Some("robot".into()),258            registry_password: Some("token".into()),259            ..Default::default()260        };261        let settings = flags262            .build_settings(263                "writer.a1b2c3".into(),264                "ghcr.io/basecamp/writebook:latest",265                "books.example.test".into(),266            )267            .unwrap();268269        assert_eq!(settings.name, "writer.a1b2c3");270        assert_eq!(settings.env_vars["MODE"], "prod");271        assert_eq!(settings.resources.cpus, 2);272        assert_eq!(settings.resources.memory_mb, 1024);273        assert!(settings.auto_update);274        assert!(settings.backup.auto_backup);275        assert_eq!(settings.registry.host, "ghcr.io");276        assert_eq!(settings.registry.username, "robot");277        assert_eq!(settings.registry.password, "token");278    }279280    #[test]281    fn rejects_relative_and_incomplete_backup_settings() {282        let relative = SettingsFlags {283            backup_path: Some(PathBuf::from("backups")),284            ..Default::default()285        };286        assert!(287            relative288                .build_settings("app.a1b2c3".into(), "org/app", "app.localhost".into())289                .is_err()290        );291292        let no_path = SettingsFlags {293            auto_backup: Some(true),294            ..Default::default()295        };296        assert!(297            no_path298                .build_settings("app.a1b2c3".into(), "org/app", "app.localhost".into())299                .is_err()300        );301    }302303    #[test]304    fn rejects_unpaired_registry_credentials() {305        let flags = SettingsFlags {306            registry_username: Some("robot".into()),307            ..Default::default()308        };309        assert!(310            flags311                .build_settings(312                    "app.a1b2c3".into(),313                    "ghcr.io/org/app",314                    "app.localhost".into()315                )316                .is_err()317        );318    }319320    #[test]321    fn applying_partial_update_settings_preserves_omitted_fields() {322        let existing = SettingsFlags {323            host: Some("old.example.test".into()),324            env: Some(vec!["OLD=value".into()]),325            disable_tls: Some(true),326            cpus: Some(2),327            auto_update: Some(false),328            ..Default::default()329        }330        .build_settings(331            "writer.a1b2c3".into(),332            "basecamp/writebook:latest",333            "old.example.test".into(),334        )335        .unwrap();336        let updated = SettingsFlags {337            host: Some("new.example.test".into()),338            ..Default::default()339        }340        .apply_changes(&existing, None)341        .unwrap();342343        assert_eq!(updated.image, existing.image);344        assert_eq!(updated.host, "new.example.test");345        assert!(updated.disable_tls);346        assert_eq!(updated.env_vars, existing.env_vars);347        assert_eq!(updated.resources.cpus, 2);348        assert!(!updated.auto_update);349    }350}