git-next/crates/config/src/server.rs

//
use actix::prelude::*;

use std::{
    collections::HashMap,
    net::SocketAddr,
    path::{Path, PathBuf},
    str::FromStr,
};

use kxio::fs::FileSystem;
use tracing::info;

use crate::{ForgeAlias, ForgeConfig, RepoAlias};

#[derive(Debug, derive_more::From, derive_more::Display)]
pub enum Error {
    Io(std::io::Error),
    KxIoFs(kxio::fs::Error),
    TomlDe(toml::de::Error),
    AddressParse(std::net::AddrParseError),
}
impl std::error::Error for Error {}

type Result<T> = core::result::Result<T, Error>;

/// Mapped from the `git-next-server.toml` file
#[derive(Debug, PartialEq, Eq, serde::Deserialize, Message, derive_more::Constructor)]
#[rtype(result = "()")]
pub struct ServerConfig {
    http: Http,
    webhook: Webhook,
    storage: ServerStorage,
    pub forge: HashMap<String, ForgeConfig>,
}
impl ServerConfig {
    #[tracing::instrument(skip_all)]
    pub fn load(fs: &FileSystem) -> Result<Self> {
        let file = fs.base().join("git-next-server.toml");
        info!(?file, "");
        let str = fs.file_read_to_string(&file)?;
        toml::from_str(&str).map_err(Into::into)
    }

    pub fn forges(&self) -> impl Iterator<Item = (ForgeAlias, &ForgeConfig)> {
        self.forge
            .iter()
            .map(|(alias, forge)| (ForgeAlias::new(alias.clone()), forge))
    }

    pub const fn storage(&self) -> &ServerStorage {
        &self.storage
    }

    pub const fn webhook(&self) -> &Webhook {
        &self.webhook
    }

    pub fn http(&self) -> Result<SocketAddr> {
        self.http.socket_addr()
    }
}

/// Defines the port the server will listen to for incoming webhooks messages
#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor)]
pub struct Http {
    addr: String,
    port: u16,
}
impl Http {
    fn socket_addr(&self) -> Result<SocketAddr> {
        Ok(SocketAddr::from_str(&format!(
            "{}:{}",
            self.addr, self.port
        ))?)
    }
}

/// Defines the Webhook Forges should send updates to
/// Must be an address that is accessible from the remote forge
#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor)]
pub struct Webhook {
    url: String,
}
impl Webhook {
    pub fn url(&self, forge_alias: &ForgeAlias, repo_alias: &RepoAlias) -> WebhookUrl {
        let base_url = &self.url;
        WebhookUrl(format!("{base_url}/{forge_alias}/{repo_alias}"))
    }
}

/// The URL for the webhook where forges should send their updates
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize, derive_more::AsRef)]
pub struct WebhookUrl(String);

/// The directory to store server data, such as cloned repos
#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor)]
pub struct ServerStorage {
    path: PathBuf,
}
impl ServerStorage {
    pub fn path(&self) -> &Path {
        self.path.as_path()
    }
}