more office wip, only wss proxy missing it seems

src/cloud.rs

@@ -78,10 +78,6 @@ impl CloudOptions {
             app_packages: app_package,
         })
     }
-
-    pub fn with_php(self, php: PhpVersion) -> Self {
-        CloudOptions { php, ..self }
-    }
 }
 
 #[test]
@@ -392,13 +388,7 @@ impl Cloud {
             }
         });
 
-        let clean_id = id.strip_prefix("haze-").unwrap_or(&id);
-
-        let address = match (&config.proxy.address, config.proxy.https) {
-            (public, true) if !public.is_empty() => format!("https://{clean_id}.{public}"),
-            (public, false) if !public.is_empty() => format!("http://{clean_id}.{public}"),
-            _ => format!("http://{ip}"),
-        };
+        let address = config.proxy.addr(&id, ip);
 
         Ok(Cloud {
             id,
@@ -543,18 +533,10 @@ impl Cloud {
                     == 1;
 
                 let ip = network_info.ip_address.as_ref()?.parse().ok();
-
-                let clean_id = id.strip_prefix("haze-").unwrap_or(&id);
-
-                let address = match (&config.proxy.address, config.proxy.https, ip) {
-                    (public, true, Some(_)) if !public.is_empty() => {
-                        format!("https://{clean_id}.{public}")
-                    }
-                    (public, false, Some(_)) if !public.is_empty() => {
-                        format!("http://{clean_id}.{public}")
-                    }
-                    (_, _, Some(ip)) => format!("http://{ip}"),
-                    _ => "Not running".into(),
+                let address = if let Some(ip) = ip {
+                    config.proxy.addr(&id, ip)
+                } else {
+                    "Not running".into()
                 };
 
                 service_ids.push(id.clone());

src/config.rs

@@ -5,6 +5,7 @@ use serde::Deserialize;
 use std::convert::TryFrom;
 use std::env::var;
 use std::fs::{read, read_to_string};
+use std::net::IpAddr;
 
 #[derive(Debug, Deserialize)]
 #[serde(from = "RawHazeConfig")]
@@ -160,6 +161,27 @@ pub struct ProxyConfig {
     pub https: bool,
 }
 
+impl ProxyConfig {
+    /// Get a public address for a service, either with direct ip or through the proxy
+    pub fn addr(&self, id: &str, ip: IpAddr) -> String {
+        let clean_id = id.strip_prefix("haze-").unwrap_or(&id);
+        match (&self.address, self.https) {
+            (public, true) if !public.is_empty() => format!("https://{clean_id}.{public}"),
+            (public, false) if !public.is_empty() => format!("http://{clean_id}.{public}"),
+            _ => format!("http://{ip}"),
+        }
+    }
+
+    pub fn addr_with_port(&self, id: &str, ip: IpAddr, port: u16) -> String {
+        let clean_id = id.strip_prefix("haze-").unwrap_or(&id);
+        match (&self.address, self.https) {
+            (public, true) if !public.is_empty() => format!("https://{clean_id}.{public}"),
+            (public, false) if !public.is_empty() => format!("http://{clean_id}.{public}"),
+            _ => format!("http://{ip}:{port}"),
+        }
+    }
+}
+
 impl HazeConfig {
     pub fn load() -> Result<Self> {
         let dirs = ProjectDirs::from("nl", "icewind", "haze").unwrap();

src/main.rs

@@ -374,7 +374,7 @@ async fn setup(docker: &mut Docker, options: CloudOptions, config: &HazeConfig)
             }
         }
         for service in &cloud.services {
-            for cmd in service.post_setup(&docker, &cloud.id).await? {
+            for cmd in service.post_setup(&docker, &cloud.id, config).await? {
                 cloud
                     .exec(docker, shell_words::split(&cmd).into_diagnostic()?, false)
                     .await?;

src/proxy.rs

@@ -1,3 +1,4 @@
+use crate::service::ServiceTrait;
 use crate::{Cloud, HazeConfig};
 use crate::{Result, Service};
 use bollard::Docker;
@@ -63,6 +64,20 @@ impl ActiveInstances {
                 .next()?;
             let ip = push.get_ip(&self.docker, &cloud.id).await.ok()?;
             SocketAddr::new(ip, 7867)
+        } else if let Some(name) = name.strip_suffix("-office") {
+            let cloud = Cloud::get_by_filter(&self.docker, Some(name.into()), &self.config)
+                .await
+                .ok()?;
+            let office = cloud
+                .services
+                .iter()
+                .filter_map(|service| match service {
+                    Service::Office(office) => Some(office),
+                    _ => None,
+                })
+                .next()?;
+            let ip = office.get_ip(&self.docker, &cloud.id).await.ok()?;
+            SocketAddr::new(ip, 9980)
         } else {
             SocketAddr::new(
                 Cloud::get_by_filter(&self.docker, Some(name.into()), &self.config)

src/service.rs

@@ -19,7 +19,8 @@ use crate::service::smb::Smb;
 use bollard::models::ContainerState;
 use bollard::Docker;
 use enum_dispatch::enum_dispatch;
-use miette::{IntoDiagnostic, Result, WrapErr};
+use miette::{IntoDiagnostic, Report, Result, WrapErr};
+use std::net::IpAddr;
 use std::time::Duration;
 use tokio::time::{sleep, timeout};
 
@@ -64,9 +65,78 @@ pub trait ServiceTrait {
         &[]
     }
 
-    async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
+    async fn post_setup(
+        &self,
+        _docker: &Docker,
+        _cloud_id: &str,
+        _config: &HazeConfig,
+    ) -> Result<Vec<String>> {
         Ok(Vec::new())
     }
+
+    async fn is_running(&self, docker: &Docker, cloud_id: &str) -> Result<bool> {
+        let info = docker
+            .inspect_container(&self.container_name(cloud_id), None)
+            .await
+            .into_diagnostic()?;
+        Ok(matches!(
+            info.state,
+            Some(ContainerState {
+                running: Some(true),
+                ..
+            })
+        ))
+    }
+
+    async fn wait_for_running(&self, docker: &Docker, cloud_id: &str) -> Result<()> {
+        timeout(Duration::from_secs(30), async {
+            while !self.is_running(docker, cloud_id).await? {
+                sleep(Duration::from_millis(100)).await
+            }
+            Ok(())
+        })
+        .await
+        .into_diagnostic()
+        .wrap_err("Timeout after 30 seconds")?
+    }
+
+    async fn get_ip(&self, docker: &Docker, cloud_id: &str) -> Result<IpAddr> {
+        docker
+            .start_container::<String>(&self.container_name(cloud_id), None)
+            .await
+            .into_diagnostic()?;
+        self.wait_for_running(docker, cloud_id).await?;
+
+        sleep(Duration::from_millis(100)).await;
+
+        let info = docker
+            .inspect_container(&self.container_name(cloud_id), None)
+            .await
+            .into_diagnostic()?;
+        if matches!(
+            info.state,
+            Some(ContainerState {
+                running: Some(true),
+                ..
+            })
+        ) {
+            info.network_settings
+                .unwrap()
+                .networks
+                .unwrap()
+                .values()
+                .next()
+                .unwrap()
+                .ip_address
+                .clone()
+                .unwrap()
+                .parse()
+                .into_diagnostic()
+                .wrap_err("Invalid ip address")
+        } else {
+            Err(Report::msg("service not started"))
+        }
+    }
 }
 
 #[enum_dispatch]

src/service/clam.rs

@@ -78,7 +78,12 @@ impl ServiceTrait for ClamIcap {
         &["files_antivirus"]
     }
 
-    async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
+    async fn post_setup(
+        &self,
+        _docker: &Docker,
+        _cloud_id: &str,
+        _config: &HazeConfig,
+    ) -> Result<Vec<String>> {
         Ok(vec![
             "occ config:app:set files_antivirus av_mode --value=icap".into(),
             "occ config:app:set files_antivirus av_host --value=clamav-icap".into(),

src/service/kaspersky.rs

@@ -91,7 +91,12 @@ impl ServiceTrait for Kaspersky {
         &["files_antivirus"]
     }
 
-    async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
+    async fn post_setup(
+        &self,
+        _docker: &Docker,
+        _cloud_id: &str,
+        _config: &HazeConfig,
+    ) -> Result<Vec<String>> {
         Ok(vec![
             "occ config:app:set files_antivirus av_mode --value=kaspersky".into(),
             "occ config:app:set files_antivirus av_host --value=kaspersky".into(),
@@ -186,7 +191,12 @@ impl ServiceTrait for KasperskyIcap {
         &["files_antivirus"]
     }
 
-    async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
+    async fn post_setup(
+        &self,
+        _docker: &Docker,
+        _cloud_id: &str,
+        _config: &HazeConfig,
+    ) -> Result<Vec<String>> {
         Ok(vec![
             "occ config:app:set files_antivirus av_mode --value=icap".into(),
             "occ config:app:set files_antivirus av_host --value=kaspersky-icap".into(),

src/service/office.rs

@@ -26,16 +26,34 @@ impl ServiceTrait for Office {
         docker: &Docker,
         cloud_id: &str,
         network: &str,
-        _config: &HazeConfig,
+        config: &HazeConfig,
     ) -> Result<String> {
         let image = "collabora/code";
         pull_image(docker, image).await?;
+        let container_id = self.container_name(cloud_id);
         let options = Some(CreateContainerOptions {
-            name: self.container_name(cloud_id),
+            name: container_id.clone(),
         });
+        let mut env = vec!["extra_params=--o:ssl.enable=false --o:ssl.termination=true"];
+
+        let clean_id = container_id.strip_prefix("haze-").unwrap_or(&container_id);
+        let server_name_opt = match (&config.proxy.address, config.proxy.https) {
+            (public, true) if !public.is_empty() => {
+                format!("server_name={clean_id}.{public}")
+            }
+            (public, false) if !public.is_empty() => {
+                format!("server_name={clean_id}.{public}")
+            }
+            _ => "".to_string(),
+        };
+
+        if !server_name_opt.is_empty() {
+            env.push(&server_name_opt);
+        }
+
         let config = Config {
             image: Some(image),
-            env: Some(vec!["extra_params=--o:ssl.enable=false"]),
+            env: Some(env),
             host_config: Some(HostConfig {
                 network_mode: Some(network.to_string()),
                 ..Default::default()
@@ -74,9 +92,15 @@ impl ServiceTrait for Office {
         &["richdocuments"]
     }
 
-    async fn post_setup(&self, docker: &Docker, cloud_id: &str) -> Result<Vec<String>> {
+    async fn post_setup(
+        &self,
+        docker: &Docker,
+        cloud_id: &str,
+        config: &HazeConfig,
+    ) -> Result<Vec<String>> {
+        let container = &self.container_name(cloud_id);
         let info = docker
-            .inspect_container(&self.container_name(cloud_id), None)
+            .inspect_container(container, None)
             .await
             .into_diagnostic()?;
         let ip = if matches!(
@@ -96,6 +120,8 @@ impl ServiceTrait for Office {
                 .ip_address
                 .clone()
                 .unwrap()
+                .parse()
+                .into_diagnostic()?
         } else {
             return Err(Report::msg("office not started"));
         };
@@ -105,8 +131,8 @@ impl ServiceTrait for Office {
                 ip
             ),
             format!(
-                r#"occ config:app:set richdocuments public_wopi_url --value="http://{}:9980""#,
-                ip
+                r#"occ config:app:set richdocuments public_wopi_url --value="{}""#,
+                config.proxy.addr_with_port(container, ip, 9980)
             ),
             format!(
                 r#"occ config:app:set richdocuments wopi_root --value="http://{}""#,

src/service/onlyoffice.rs

@@ -73,7 +73,12 @@ impl ServiceTrait for OnlyOffice {
         &["onlyoffice"]
     }
 
-    async fn post_setup(&self, docker: &Docker, cloud_id: &str) -> Result<Vec<String>> {
+    async fn post_setup(
+        &self,
+        docker: &Docker,
+        cloud_id: &str,
+        _config: &HazeConfig,
+    ) -> Result<Vec<String>> {
         let info = docker
             .inspect_container(&self.container_name(cloud_id), None)
             .await

src/service/push.rs

@@ -2,13 +2,10 @@ use crate::config::HazeConfig;
 use crate::image::pull_image;
 use crate::service::ServiceTrait;
 use bollard::container::{Config, CreateContainerOptions, NetworkingConfig};
-use bollard::models::{ContainerState, EndpointSettings, HostConfig};
+use bollard::models::{EndpointSettings, HostConfig};
 use bollard::Docker;
 use maplit::hashmap;
-use miette::{IntoDiagnostic, Report, Result, WrapErr};
-use std::net::IpAddr;
-use std::time::Duration;
-use tokio::time::{sleep, timeout};
+use miette::{IntoDiagnostic, Result};
 
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct NotifyPush;
@@ -85,7 +82,12 @@ impl ServiceTrait for NotifyPush {
         Ok(true)
     }
 
-    async fn post_setup(&self, docker: &Docker, cloud_id: &str) -> Result<Vec<String>> {
+    async fn post_setup(
+        &self,
+        docker: &Docker,
+        cloud_id: &str,
+        _config: &HazeConfig,
+    ) -> Result<Vec<String>> {
         let ip = self.get_ip(docker, cloud_id).await?;
         Ok(vec![
             format!("occ config:system:set trusted_proxies 1 --value {}", ip),
@@ -93,69 +95,3 @@ impl ServiceTrait for NotifyPush {
         ])
     }
 }
-
-impl NotifyPush {
-    async fn is_push_running(&self, docker: &Docker, cloud_id: &str) -> Result<bool> {
-        let info = docker
-            .inspect_container(&self.container_name(cloud_id), None)
-            .await
-            .into_diagnostic()?;
-        Ok(matches!(
-            info.state,
-            Some(ContainerState {
-                running: Some(true),
-                ..
-            })
-        ))
-    }
-
-    async fn wait_for_push(&self, docker: &Docker, cloud_id: &str) -> Result<()> {
-        timeout(Duration::from_secs(30), async {
-            while !self.is_push_running(docker, cloud_id).await? {
-                sleep(Duration::from_millis(100)).await
-            }
-            Ok(())
-        })
-        .await
-        .into_diagnostic()
-        .wrap_err("Timeout after 30 seconds")?
-    }
-
-    pub async fn get_ip(&self, docker: &Docker, cloud_id: &str) -> Result<IpAddr> {
-        docker
-            .start_container::<String>(&self.container_name(cloud_id), None)
-            .await
-            .into_diagnostic()?;
-        self.wait_for_push(docker, cloud_id).await?;
-
-        sleep(Duration::from_millis(100)).await;
-
-        let info = docker
-            .inspect_container(&self.container_name(cloud_id), None)
-            .await
-            .into_diagnostic()?;
-        if matches!(
-            info.state,
-            Some(ContainerState {
-                running: Some(true),
-                ..
-            })
-        ) {
-            info.network_settings
-                .unwrap()
-                .networks
-                .unwrap()
-                .values()
-                .next()
-                .unwrap()
-                .ip_address
-                .clone()
-                .unwrap()
-                .parse()
-                .into_diagnostic()
-                .wrap_err("Invalid ip address")
-        } else {
-            Err(Report::msg("notify_push not started"))
-        }
-    }
-}

src/service/smb.rs

@@ -79,7 +79,12 @@ impl ServiceTrait for Smb {
         Ok(true)
     }
 
-    async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
+    async fn post_setup(
+        &self,
+        _docker: &Docker,
+        _cloud_id: &str,
+        _config: &HazeConfig,
+    ) -> Result<Vec<String>> {
         Ok(vec![
             "occ files_external:create smb smb password::password".into(),
             "occ files_external:config 1 host smb".into(),