domani/src/service.rs

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::error::Error;
use std::sync;
use warp::Filter;

use crate::domain;

pub mod http_tpl;
mod util;

type Handlebars<'a> = sync::Arc<handlebars::Handlebars<'a>>;

struct Renderer<'a, DM>
where
    DM: domain::manager::Manager,
{
    domain_manager: sync::Arc<DM>,
    target_cname: sync::Arc<domain::Name>,
    passphrase: sync::Arc<String>,

    handlebars: Handlebars<'a>,
    query_args: HashMap<String, String>,
}

#[derive(Serialize)]
struct BasePresenter<'a, T> {
    page_name: &'a str,
    query_args: &'a HashMap<String, String>,
    data: &'a T,
}

impl<'a, DM> Renderer<'a, DM>
where
    DM: domain::manager::Manager,
{
    // TODO make this use an io::Write, rather than warp::Reply
    fn render<T>(&self, name: &'_ str, value: &'_ T) -> Box<dyn warp::Reply>
    where
        T: Serialize,
    {
        let rendered = match self.handlebars.render(name, value) {
            Ok(res) => res,
            Err(handlebars::RenderError {
                template_name: None,
                ..
            }) => return self.render_error_page(404, "Static asset not found"),
            Err(err) => {
                return self.render_error_page(500, format!("template error: {err}").as_str())
            }
        };

        let content_type = mime_guess::from_path(name)
            .first_or_octet_stream()
            .to_string();

        let reply = warp::reply::html(rendered);

        Box::from(warp::reply::with_header(
            reply,
            "Content-Type",
            content_type,
        ))
    }

    fn render_error_page(&self, status_code: u16, e: &'_ str) -> Box<dyn warp::Reply> {
        #[derive(Serialize)]
        struct Response<'a> {
            error_msg: &'a str,
        }

        Box::from(warp::reply::with_status(
            self.render(
                "/base.html",
                &BasePresenter {
                    page_name: "/error.html",
                    query_args: &HashMap::default(),
                    data: &Response { error_msg: e },
                },
            ),
            status_code.try_into().unwrap(),
        ))
    }

    fn render_page<T>(&self, name: &'_ str, data: &'_ T) -> Box<dyn warp::Reply>
    where
        T: Serialize,
    {
        self.render(
            "/base.html",
            &BasePresenter {
                page_name: name,
                query_args: &self.query_args,
                data,
            },
        )
    }
}

pub fn new<DM>(
    manager: DM,
    target_cname: domain::Name,
    passphrase: String,
) -> Result<
    impl warp::Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone + 'static,
    Box<dyn Error>,
>
where
    DM: domain::manager::Manager + 'static,
{
    let manager = sync::Arc::new(manager);
    let target_cname = sync::Arc::new(target_cname);
    let passphrase = sync::Arc::new(passphrase);

    let hbs = sync::Arc::new(self::http_tpl::get()?);
    let with_renderer = warp::any()
        .and(warp::query::<HashMap<String, String>>())
        .map(move |query_args: HashMap<String, String>| Renderer {
            domain_manager: manager.clone(),
            target_cname: target_cname.clone(),
            passphrase: passphrase.clone(),
            handlebars: hbs.clone(),
            query_args,
        });

    let static_dir = warp::get()
        .and(with_renderer.clone())
        .and(warp::path("static"))
        .and(warp::path::full())
        .map(|renderer: Renderer<'_, DM>, full: warp::path::FullPath| {
            renderer.render(full.as_str(), &())
        });

    let index = warp::get()
        .and(with_renderer.clone())
        .and(warp::path::end())
        .map(|renderer: Renderer<'_, DM>| renderer.render_page("/index.html", &()));

    #[derive(Deserialize)]
    struct DomainGetNewRequest {
        domain: domain::Name,
    }

    #[derive(Serialize)]
    struct DomainGetNewResponse {
        domain: domain::Name,
        config: Option<domain::config::Config>,
    }

    let domain = warp::get()
        .and(with_renderer.clone())
        .and(warp::path!("domain.html"))
        .and(warp::query::<DomainGetNewRequest>())
        .and(warp::query::<util::FlatConfig>())
        .map(
            |renderer: Renderer<'_, DM>,
             req: DomainGetNewRequest,
             domain_config: util::FlatConfig| {
                match renderer.domain_manager.get_config(&req.domain) {
                    Ok(_config) => renderer.render_error_page(500, "TODO not yet implemented"),
                    Err(domain::manager::GetConfigError::NotFound) => {
                        let domain_config = match domain_config.try_into() {
                            Ok(domain_config) => domain_config,
                            Err(e) => {
                                return renderer.render_error_page(
                                    400,
                                    format!("parsing domain configuration: {}", e).as_str(),
                                )
                            }
                        };

                        renderer.render_page(
                            "/domain.html",
                            &DomainGetNewResponse {
                                domain: req.domain,
                                config: domain_config,
                            },
                        )
                    }
                    Err(domain::manager::GetConfigError::Unexpected(e)) => renderer
                        .render_error_page(
                            500,
                            format!("retrieving configuration: {}", e).as_str(),
                        ),
                }
            },
        );

    #[derive(Deserialize)]
    struct DomainInitRequest {
        domain: domain::Name,
        passphrase: String,
    }

    let domain_init = warp::get()
        .and(with_renderer.clone())
        .and(warp::path!("domain_init.html"))
        .and(warp::query::<DomainInitRequest>())
        .and(warp::query::<util::FlatConfig>())
        .map(
            |renderer: Renderer<'_, DM>,
             req: DomainInitRequest,
             domain_config: util::FlatConfig| {
                if req.passphrase != renderer.passphrase.as_str() {
                    return renderer.render_error_page(401, "Incorrect passphrase");
                }

                #[derive(Serialize)]
                struct Response {
                    domain: domain::Name,
                    flat_config: util::FlatConfig,
                    target_cname: domain::Name,
                    challenge_token: String,
                }

                let config: domain::config::Config = match domain_config.try_into() {
                    Ok(Some(config)) => config,
                    Ok(None) => {
                        return renderer.render_error_page(400, "domain config is required")
                    }
                    Err(e) => {
                        return renderer
                            .render_error_page(400, format!("invalid domain config: {e}").as_str())
                    }
                };

                let config_hash = match config.hash() {
                    Ok(hash) => hash,
                    Err(e) => {
                        return renderer.render_error_page(
                            500,
                            format!("failed to hash domain config: {e}").as_str(),
                        )
                    }
                };

                let target_cname = (*renderer.target_cname).clone();

                return renderer.render_page(
                    "/domain_init.html",
                    &Response {
                        domain: req.domain,
                        flat_config: config.into(),
                        target_cname: target_cname,
                        challenge_token: config_hash,
                    },
                );
            },
        );

    #[derive(Deserialize)]
    struct DomainSyncRequest {
        domain: domain::Name,
    }

    let domain_sync = warp::get()
        .and(with_renderer.clone())
        .and(warp::path!("domain_sync.html"))
        .and(warp::query::<DomainSyncRequest>())
        .and(warp::query::<util::FlatConfig>())
        .map(
            |renderer: Renderer<'_, DM>,
             req: DomainSyncRequest,
             domain_config: util::FlatConfig| {
                let config: domain::config::Config = match domain_config.try_into() {
                    Ok(Some(config)) => config,
                    Ok(None) => {
                        return renderer.render_error_page(400, "domain config is required")
                    }
                    Err(e) => {
                        return renderer
                            .render_error_page(400, format!("invalid domain config: {e}").as_str())
                    }
                };

                let sync_result = renderer
                    .domain_manager
                    .sync_with_config(&req.domain, &config);

                #[derive(Serialize)]
                struct Response {
                    domain: domain::Name,
                    flat_config: util::FlatConfig,
                    error_msg: Option<String>,
                }

                let mut response = Response {
                    domain: req.domain,
                    flat_config: config.into(),
                    error_msg: None,
                };

                response.error_msg = match sync_result
                {
                    Ok(_) => None,
                    Err(domain::manager::SyncWithConfigError::InvalidURL) => Some("Fetching the git repository failed, please double check that you input the correct URL.".to_string()),
                    Err(domain::manager::SyncWithConfigError::InvalidBranchName) => Some("The git repository does not have a branch of the given name, please double check that you input the correct name.".to_string()),
                    Err(domain::manager::SyncWithConfigError::AlreadyInProgress) => Some("The configuration of your domain is still in progress, please refresh in a few minutes.".to_string()),
                    Err(domain::manager::SyncWithConfigError::TargetCNAMENotSet) => Some("The CNAME record is not set correctly on the domain. Please double check that you put the correct value on the record. If the value is correct, then most likely the updated records have not yet propagated. In this case you can refresh in a few minutes to try again.".to_string()),
                    Err(domain::manager::SyncWithConfigError::ChallengeTokenNotSet) => Some("The TXT record is not set correctly on the domain. Please double check that you put the correct value on the record. If the value is correct, then most likely the updated records have not yet propagated. In this case you can refresh in a few minutes to try again.".to_string()),
                    Err(domain::manager::SyncWithConfigError::Unexpected(e)) => Some(format!("An unexpected error occurred: {e}")),
                };

                return renderer.render_page(
                    "/domain_sync.html",
                    &response,
                )
            },
        );

    let not_found = warp::any()
        .and(with_renderer.clone())
        .map(|renderer: Renderer<'_, DM>| renderer.render_error_page(404, "Page not found"));

    Ok(static_dir
        .or(index)
        .or(domain)
        .or(domain_init)
        .or(domain_sync)
        .or(not_found))
}