harmony/harmony/src/infra/opnsense/http.rs

use async_trait::async_trait;
use log::info;

use crate::{data::FileContent, executors::ExecutorError, topology::HttpServer};

use super::OPNSenseFirewall;
use harmony_types::net::IpAddress;
use harmony_types::net::Url;
const OPNSENSE_HTTP_ROOT_PATH: &str = "/usr/local/http";

#[async_trait]
impl HttpServer for OPNSenseFirewall {
    async fn serve_files(
        &self,
        url: &Url,
        remote_path: &Option<String>,
    ) -> Result<(), ExecutorError> {
        let config = self.opnsense_config.read().await;
        info!("Uploading files from url {url} to {OPNSENSE_HTTP_ROOT_PATH}");
        let remote_upload_path = remote_path
            .clone()
            .map(|r| format!("{OPNSENSE_HTTP_ROOT_PATH}/{r}"))
            .unwrap_or(OPNSENSE_HTTP_ROOT_PATH.to_string());
        match url {
            Url::LocalFolder(path) => {
                config
                    .upload_files(path, &remote_upload_path)
                    .await
                    .map_err(|e| ExecutorError::UnexpectedError(e.to_string()))?;
            }
            Url::Url(_url) => todo!(),
        }
        Ok(())
    }

    async fn serve_file_content(&self, file: &FileContent) -> Result<(), ExecutorError> {
        let path = match &file.path {
            crate::data::FilePath::Relative(path) => {
                format!("{OPNSENSE_HTTP_ROOT_PATH}/{}", path.to_string())
            }
            crate::data::FilePath::Absolute(path) => {
                return Err(ExecutorError::ConfigurationError(format!(
                    "Cannot serve file from http server with absolute path : {path}"
                )));
            }
        };

        let config = self.opnsense_config.read().await;
        info!("Uploading file content to {}", path);
        config
            .upload_file_content(&path, &file.content)
            .await
            .map_err(|e| ExecutorError::UnexpectedError(e.to_string()))?;
        Ok(())
    }

    fn get_ip(&self) -> IpAddress {
        OPNSenseFirewall::get_ip(self)
    }

    async fn commit_config(&self) -> Result<(), ExecutorError> {
        OPNSenseFirewall::commit_config(self).await
    }

    async fn reload_restart(&self) -> Result<(), ExecutorError> {
        self.opnsense_config
            .write()
            .await
            .caddy()
            .reload_restart()
            .await
            .map_err(|e| ExecutorError::UnexpectedError(e.to_string()))
    }

    async fn ensure_initialized(&self) -> Result<(), ExecutorError> {
        let mut config = self.opnsense_config.write().await;
        let caddy = config.caddy();
        if caddy.get_full_config().is_none() {
            info!("Http config not available in opnsense config, installing package");
            config.install_package("os-caddy").await.map_err(|e| {
                ExecutorError::UnexpectedError(format!(
                    "Executor failed when trying to install os-caddy package with error {e:?}"
                ))
            })?;
        } else {
            info!("Http config available in opnsense config, assuming it is already installed");
        }
        info!("Adding custom caddy config files");
        config
            .upload_files(
                "./data/watchguard/caddy_config",
                "/usr/local/etc/caddy/caddy.d/",
            )
            .await
            .map_err(|e| ExecutorError::UnexpectedError(e.to_string()))?;

        info!("Enabling http server");
        config.caddy().enable(true);

        Ok(())
    }
}