LINE1 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}