LINE1 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 1601use std::{collections::HashMap, sync::Arc};23use super::{4 docker::{ContainerRecord, DockerEngine},5 error::OnceError,6 model::{AppSettings, Keys, ONCE_LABEL, ProxySettings, SERVER_LABEL},7};89const DEFAULT_NAMESPACE: &str = "once";1011#[derive(Debug, Clone, PartialEq, Eq)]12pub struct Application {13 pub container_id: String,14 pub settings: AppSettings,15 pub running: bool,16 pub created: i64,17 pub is_server: bool,18}1920impl Application {21 pub fn url(&self, proxy: Option<&ProxySettings>) -> String {22 self.settings.url(proxy).unwrap_or_default()23 }24}2526pub struct Namespace {27 pub name: String,28 pub applications: Vec<Application>,29 pub proxy_settings: Option<ProxySettings>,30 pub engine: Arc<DockerEngine>,31}3233impl Namespace {34 pub async fn restore(engine: Arc<DockerEngine>, name: String) -> Result<Self, OnceError> {35 let name = if name.is_empty() {36 DEFAULT_NAMESPACE.to_owned()37 } else {38 name39 };40 if !valid_namespace(&name) {41 return Err(OnceError::InvalidNamespace(name));42 }4344 let containers = engine.list_containers().await?;45 let (mut applications, proxy_settings) = restore_records(&name, containers)?;46 for app in &mut applications {47 if app.settings.keys == Keys::default() {48 let volume_name = format!("{}-app-{}", name, app.settings.name);49 if let Ok(Some(label)) = engine.volume_label(&volume_name, ONCE_LABEL).await {50 restore_legacy_keys(&mut app.settings, &label);51 }52 }53 }5455 Ok(Self {56 name,57 applications,58 proxy_settings,59 engine,60 })61 }6263 pub async fn setup(&mut self) -> Result<(), OnceError> {64 self.engine.ensure_network(&self.name).await?;65 super::proxy::boot(self).await66 }6768 pub async fn refresh(&mut self) -> Result<(), OnceError> {69 let containers = self.engine.list_containers().await?;70 let (applications, proxy_settings) = restore_records(&self.name, containers)?;71 self.applications = applications;72 self.proxy_settings = proxy_settings;73 Ok(())74 }75}7677fn restore_legacy_keys(settings: &mut AppSettings, label: &str) {78 if settings.keys == Keys::default()79 && let Ok(keys) = serde_json::from_str::<Keys>(label)80 {81 settings.keys = keys;82 }83}8485fn restore_records(86 name: &str,87 containers: Vec<ContainerRecord>,88) -> Result<(Vec<Application>, Option<ProxySettings>), OnceError> {89 let proxy_name = format!("{name}-proxy");90 let app_prefix = format!("{name}-app-");91 let mut proxy_settings = None;92 let mut apps_by_name: HashMap<String, Application> = HashMap::new();9394 for container in containers {95 for raw_name in &container.names {96 let container_name = raw_name.trim_start_matches('/');97 if container_name == proxy_name {98 if let Some(label) = container.labels.get(ONCE_LABEL).filter(|s| !s.is_empty()) {99 proxy_settings = Some(serde_json::from_str(label)?);100 }101 break;102 }103104 if !container_name.starts_with(&app_prefix) {105 continue;106 }107 let Some(label) = container.labels.get(ONCE_LABEL).filter(|s| !s.is_empty()) else {108 break;109 };110 let settings: AppSettings = serde_json::from_str(label)?;111 let app = Application {112 container_id: container.id.clone(),113 settings: settings.clone(),114 running: container.state == "running",115 created: container.created,116 is_server: container117 .labels118 .get(SERVER_LABEL)119 .is_some_and(|value| value == "true"),120 };121122 match apps_by_name.get(&settings.name) {123 Some(existing) if existing.created >= app.created => {}124 _ => {125 apps_by_name.insert(settings.name, app);126 }127 }128 break;129 }130 }131132 let mut applications = apps_by_name.into_values().collect::<Vec<_>>();133 applications.sort_by(|a, b| a.settings.host.cmp(&b.settings.host));134135 Ok((applications, proxy_settings))136}137138fn valid_namespace(name: &str) -> bool {139 let mut chars = name.chars();140 matches!(chars.next(), Some('a'..='z' | '0'..='9'))141 && chars.all(|character| matches!(character, 'a'..='z' | '0'..='9' | '-'))142}143144#[cfg(test)]145mod tests {146 use std::collections::HashMap;147148 use super::{Application, restore_legacy_keys, restore_records, valid_namespace};149 use crate::commands::once::docker::ContainerRecord;150 use crate::commands::once::model::{AppSettings, Keys, ProxySettings};151152 #[test]153 fn validates_once_namespace_names() {154 assert!(valid_namespace("once"));155 assert!(valid_namespace("my-app-2"));156 assert!(!valid_namespace("-bad"));157 assert!(!valid_namespace("Bad"));158 assert!(!valid_namespace("bad_name"));159 }160161 #[test]162 fn application_url_matches_proxy_ports_and_local_tls_rules() {163 let app = Application {164 container_id: "id".into(),165 settings: AppSettings {166 host: "books.example.com".into(),167 ..Default::default()168 },169 running: true,170 created: 1,171 is_server: false,172 };173 let proxy = ProxySettings {174 http_port: 8080,175 https_port: 8443,176 metrics_port: 1318,177 };178 assert_eq!(app.url(Some(&proxy)), "https://books.example.com:8443");179 }180181 #[test]182 fn does_not_enable_tls_for_local_hosts() {183 let app = Application {184 container_id: "id".into(),185 settings: AppSettings {186 host: "app.localhost".into(),187 ..Default::default()188 },189 running: true,190 created: 1,191 is_server: false,192 };193 assert_eq!(app.url(None), "http://app.localhost");194 }195196 #[test]197 fn discovers_once_apps_deduplicates_old_containers_and_restores_proxy_settings() {198 let app_json =199 include_str!("../../../tests/fixtures/once-v0.3.4/application-settings.json");200 let proxy_json = include_str!("../../../tests/fixtures/once-v0.3.4/proxy-settings.json");201 let records = vec![202 ContainerRecord {203 id: "old-container".into(),204 names: vec!["/once-app-writer-old".into()],205 state: "exited".into(),206 created: 10,207 labels: HashMap::from([("once".into(), app_json.into())]),208 },209 ContainerRecord {210 id: "new-container".into(),211 names: vec!["/once-app-writer-new".into()],212 state: "running".into(),213 created: 20,214 labels: HashMap::from([("once".into(), app_json.into())]),215 },216 ContainerRecord {217 id: "proxy".into(),218 names: vec!["/once-proxy".into()],219 state: "running".into(),220 created: 5,221 labels: HashMap::from([("once".into(), proxy_json.into())]),222 },223 ContainerRecord {224 id: "foreign".into(),225 names: vec!["/other-app-writer-foreign".into()],226 state: "running".into(),227 created: 30,228 labels: HashMap::new(),229 },230 ];231232 let (apps, proxy) = restore_records("once", records).unwrap();233 assert_eq!(apps.len(), 1);234 assert_eq!(apps[0].container_id, "new-container");235 assert!(apps[0].running);236 assert_eq!(apps[0].settings.name, "writer");237 assert_eq!(proxy.unwrap().https_port, 443);238 }239240 #[test]241 fn discovers_apps_with_null_once_settings_fields() {242 let (apps, _) = restore_records(243 "once",244 vec![ContainerRecord {245 id: "container".into(),246 names: vec!["/once-app-writer".into()],247 state: "running".into(),248 created: 1,249 labels: HashMap::from([(250 "once".into(),251 r#"{"name":"writer","host":"books.example.test","env":null,"smtp":null,"resources":null,"backup":null,"keys":null,"registry":null}"#.into(),252 )]),253 }],254 )255 .unwrap();256257 assert_eq!(apps.len(), 1);258 assert_eq!(apps[0].settings.name, "writer");259 assert!(apps[0].settings.env_vars.is_empty());260 assert_eq!(apps[0].settings.host, "books.example.test");261 }262263 #[test]264 fn restores_the_internal_server_marker_without_putting_it_in_app_settings() {265 let settings = serde_json::json!({266 "name": "ino-server",267 "image": "silenloc/ino:0.5.0",268 "host": "ino.example.test",269 "env": {"PORT": "80"}270 });271 let (apps, _) = restore_records(272 "once",273 vec![ContainerRecord {274 id: "server-container".into(),275 names: vec!["/once-app-ino-server-123456".into()],276 state: "running".into(),277 created: 1,278 labels: HashMap::from([279 ("once".into(), settings.to_string()),280 ("ino.server".into(), "true".into()),281 ]),282 }],283 )284 .unwrap();285286 assert_eq!(apps.len(), 1);287 assert!(apps[0].is_server);288 assert_eq!(289 apps[0].settings.env_vars.get("PORT").map(String::as_str),290 Some("80")291 );292 let persisted_settings = serde_json::to_string(&apps[0].settings).unwrap();293 assert!(!persisted_settings.contains("INO_API_KEY"));294 }295296 #[test]297 fn restores_legacy_keys_from_volume_label_only_when_app_label_is_empty() {298 let mut settings = AppSettings::default();299 restore_legacy_keys(300 &mut settings,301 r#"{"secretKeyBase":"legacy","vapidPublicKey":"pub","vapidPrivateKey":"priv"}"#,302 );303 assert_eq!(settings.keys.secret_key_base, "legacy");304305 settings.keys = Keys {306 secret_key_base: "current".into(),307 ..Default::default()308 };309 restore_legacy_keys(&mut settings, r#"{"secretKeyBase":"legacy"}"#);310 assert_eq!(settings.keys.secret_key_base, "current");311 }312}