Skip to content
1        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}