domani/src/domain/manager.rs

use crate::domain::{self, checker, config};
use crate::origin;
use std::error::Error;
use std::future::Future;
use std::{pin, sync};

#[derive(thiserror::Error, Debug)]
pub enum GetConfigError {
    #[error("not found")]
    NotFound,

    #[error(transparent)]
    Unexpected(Box<dyn Error>),
}

impl From<config::GetError> for GetConfigError {
    fn from(e: config::GetError) -> GetConfigError {
        match e {
            config::GetError::NotFound => GetConfigError::NotFound,
            config::GetError::Unexpected(e) => GetConfigError::Unexpected(e),
        }
    }
}

#[derive(thiserror::Error, Debug)]
pub enum GetOriginError {
    #[error("not found")]
    NotFound,

    #[error(transparent)]
    Unexpected(Box<dyn Error>),
}

impl From<config::GetError> for GetOriginError {
    fn from(e: config::GetError) -> GetOriginError {
        match e {
            config::GetError::NotFound => GetOriginError::NotFound,
            config::GetError::Unexpected(e) => GetOriginError::Unexpected(e),
        }
    }
}

#[derive(thiserror::Error, Debug)]
pub enum SyncError {
    #[error("not found")]
    NotFound,

    #[error("already in progress")]
    AlreadyInProgress,

    #[error(transparent)]
    Unexpected(Box<dyn Error>),
}

impl From<config::GetError> for SyncError {
    fn from(e: config::GetError) -> SyncError {
        match e {
            config::GetError::NotFound => SyncError::NotFound,
            config::GetError::Unexpected(e) => SyncError::Unexpected(e),
        }
    }
}

#[derive(thiserror::Error, Debug)]
pub enum SyncWithConfigError {
    #[error("invalid url")]
    InvalidURL,

    #[error("invalid branch name")]
    InvalidBranchName,

    #[error("already in progress")]
    AlreadyInProgress,

    #[error("target A/AAAA not set")]
    TargetANotSet,

    #[error("challenge token not set")]
    ChallengeTokenNotSet,

    #[error(transparent)]
    Unexpected(Box<dyn Error>),
}

impl From<origin::store::SyncError> for SyncWithConfigError {
    fn from(e: origin::store::SyncError) -> SyncWithConfigError {
        match e {
            origin::store::SyncError::InvalidURL => SyncWithConfigError::InvalidURL,
            origin::store::SyncError::InvalidBranchName => SyncWithConfigError::InvalidBranchName,
            origin::store::SyncError::AlreadyInProgress => SyncWithConfigError::AlreadyInProgress,
            origin::store::SyncError::Unexpected(e) => SyncWithConfigError::Unexpected(e),
        }
    }
}

impl From<checker::CheckDomainError> for SyncWithConfigError {
    fn from(e: checker::CheckDomainError) -> SyncWithConfigError {
        match e {
            checker::CheckDomainError::TargetANotSet => SyncWithConfigError::TargetANotSet,
            checker::CheckDomainError::ChallengeTokenNotSet => {
                SyncWithConfigError::ChallengeTokenNotSet
            }
            checker::CheckDomainError::Unexpected(e) => SyncWithConfigError::Unexpected(e),
        }
    }
}

impl From<config::SetError> for SyncWithConfigError {
    fn from(e: config::SetError) -> SyncWithConfigError {
        match e {
            config::SetError::Unexpected(e) => SyncWithConfigError::Unexpected(e),
        }
    }
}

//#[mockall::automock]
pub trait Manager {
    fn get_config(&self, domain: &domain::Name) -> Result<config::Config, GetConfigError>;
    fn get_origin(
        &self,
        domain: &domain::Name,
    ) -> Result<Box<dyn origin::Origin + '_>, GetOriginError>;
    fn sync(&self, domain: &domain::Name) -> Result<(), SyncError>;
    fn sync_with_config(
        &self,
        domain: domain::Name,
        config: config::Config,
    ) -> pin::Pin<Box<dyn Future<Output = Result<(), SyncWithConfigError>> + Send + '_>>;
}

pub trait BoxedManager: Manager + Send + Sync + Clone {}

struct ManagerImpl<OriginStore, DomainConfigStore>
where
    OriginStore: origin::store::BoxedStore,
    DomainConfigStore: config::BoxedStore,
{
    origin_store: OriginStore,
    domain_config_store: DomainConfigStore,
    domain_checker: checker::DNSChecker,
}

pub fn new<OriginStore, DomainConfigStore>(
    origin_store: OriginStore,
    domain_config_store: DomainConfigStore,
    domain_checker: checker::DNSChecker,
) -> impl BoxedManager
where
    OriginStore: origin::store::BoxedStore,
    DomainConfigStore: config::BoxedStore,
{
    sync::Arc::new(ManagerImpl {
        origin_store,
        domain_config_store,
        domain_checker,
    })
}

impl<OriginStore, DomainConfigStore> BoxedManager
    for sync::Arc<ManagerImpl<OriginStore, DomainConfigStore>>
where
    OriginStore: origin::store::BoxedStore,
    DomainConfigStore: config::BoxedStore,
{
}

impl<OriginStore, DomainConfigStore> Manager
    for sync::Arc<ManagerImpl<OriginStore, DomainConfigStore>>
where
    OriginStore: origin::store::BoxedStore,
    DomainConfigStore: config::BoxedStore,
{
    fn get_config(&self, domain: &domain::Name) -> Result<config::Config, GetConfigError> {
        Ok(self.domain_config_store.get(domain)?)
    }

    fn get_origin(
        &self,
        domain: &domain::Name,
    ) -> Result<Box<dyn origin::Origin + '_>, GetOriginError> {
        let config = self.domain_config_store.get(domain)?;
        let origin = self
            .origin_store
            .get(config.origin_descr)
            // if there's a config there should be an origin, any error here is unexpected
            .map_err(|e| GetOriginError::Unexpected(Box::from(e)))?;
        Ok(Box::from(origin))
    }

    fn sync(&self, domain: &domain::Name) -> Result<(), SyncError> {
        let config = self.domain_config_store.get(domain)?;
        self.origin_store
            .sync(config.origin_descr, origin::store::Limits {})
            .map_err(|e| match e {
                origin::store::SyncError::AlreadyInProgress => SyncError::AlreadyInProgress,
                _ => SyncError::Unexpected(Box::from(e)),
            })?;
        Ok(())
    }

    fn sync_with_config(
        &self,
        domain: domain::Name,
        config: config::Config,
    ) -> pin::Pin<Box<dyn Future<Output = Result<(), SyncWithConfigError>> + Send + '_>> {
        Box::pin(async move {
            let config_hash = config
                .hash()
                .map_err(|e| SyncWithConfigError::Unexpected(e))?;

            self.domain_checker
                .check_domain(&domain, &config_hash)
                .await?;

            self.origin_store
                .sync(config.origin_descr.clone(), origin::store::Limits {})?;

            self.domain_config_store.set(&domain, &config)?;

            Ok(())
        })
    }
}