mod actors; mod config; pub mod gitforge; pub mod types; use actix::prelude::*; use kxio::network::Network; use std::path::PathBuf; use tracing::{error, info, level_filters::LevelFilter}; use crate::{ fs::FileSystem, server::{ actors::webhook, config::{ForgeConfig, ForgeName, GitDir, RepoAlias, ServerStorage, Webhook}, }, }; use self::{actors::repo::RepoActor, config::ServerRepoConfig}; #[derive(Debug, derive_more::Display, derive_more::From)] pub enum Error { #[display("Failed to create data directories")] FailedToCreateDataDirectory(kxio::fs::Error), #[display("The forge data path is not a directory: {path:?}")] ForgeDirIsNotDirectory { path: PathBuf, }, Config(crate::server::config::Error), Io(std::io::Error), } type Result = core::result::Result; pub fn init(fs: FileSystem) { let file_name = "git-next-server.toml"; let pathbuf = PathBuf::from(file_name); let Ok(exists) = fs.path_exists(&pathbuf) else { eprintln!("Could not check if file exist: {}", file_name); return; }; if exists { eprintln!( "The configuration file already exists at {} - not overwritting it.", file_name ); } else { match fs.file_write(&pathbuf, include_str!("../../server-default.toml")) { Ok(_) => println!("Created a default configuration file at {}", file_name), Err(e) => { eprintln!("Failed to write to the configuration file: {}", e) } } } } pub async fn start(fs: FileSystem, net: Network) { init_logging(); info!("Starting Server..."); let server_config = match config::ServerConfig::load(&fs) { Ok(server_config) => server_config, Err(err) => { error!("Failed to load config file. Error: {}", err); return; } }; // Server Storage let dir = server_config.storage().path(); if !dir.exists() { info!(?dir, "server storage doesn't exist - creating it"); if let Err(err) = fs.dir_create(dir) { error!(?err, ?dir, "Failed to create server storage"); return; } } let Ok(canon) = dir.canonicalize() else { error!(?dir, "Failed to confirm servier storage"); return; }; info!(dir = ?canon, "server storage"); // Forge directories in Server Storage let server_storage = server_config.storage(); if let Err(err) = create_forge_data_directories(&server_config, &fs, &dir) { error!(?err, "Failure creating forge storage"); return; } // Webhook Server info!("Starting Webhook Server..."); let webhook_router = webhook::WebhookRouter::new().start(); let webhook = server_config.webhook(); // Forge Actors for (forge_name, forge_config) in server_config.forges() { create_forge_repos( forge_config, forge_name.clone(), server_storage, webhook, &net, ) .into_iter() .map(start_actor) .map(|(alias, addr)| webhook::AddWebhookRecipient(alias, addr.recipient())) .for_each(|msg| webhook_router.do_send(msg)); } let webhook_server = webhook::WebhookActor::new(webhook_router.recipient()).start(); info!("Server running - Press Ctrl-C to stop..."); let _ = actix_rt::signal::ctrl_c().await; info!("Ctrl-C received, shutting down..."); drop(webhook_server); } fn create_forge_data_directories( server_config: &config::ServerConfig, fs: &FileSystem, server_dir: &&std::path::Path, ) -> Result<()> { for (forge_name, _forge_config) in server_config.forges() { let forge_dir: PathBuf = (&forge_name).into(); let path = server_dir.join(&forge_dir); if fs.path_exists(&path)? { if !fs.path_is_dir(&path)? { return Err(Error::ForgeDirIsNotDirectory { path }); } } else { info!(%forge_name, ?path, "creating storage"); fs.dir_create_all(&path)?; } } Ok(()) } fn create_forge_repos( forge_config: &ForgeConfig, forge_name: ForgeName, server_storage: &ServerStorage, webhook: &Webhook, net: &Network, ) -> Vec<(ForgeName, RepoAlias, RepoActor)> { let span = tracing::info_span!("create_forge_repos", name = %forge_name, config = %forge_config); let _guard = span.enter(); info!("Creating Forge"); let mut repos = vec![]; let creator = create_actor( forge_name, forge_config.clone(), server_storage, webhook, net, ); for (repo_alias, server_repo_config) in forge_config.repos() { let forge_repo = creator((repo_alias, server_repo_config)); info!( alias = %forge_repo.1, "Created Repo" ); repos.push(forge_repo); } repos } fn create_actor( forge_name: ForgeName, forge_config: config::ForgeConfig, server_storage: &ServerStorage, webhook: &Webhook, net: &Network, ) -> impl Fn((RepoAlias, &ServerRepoConfig)) -> (ForgeName, RepoAlias, RepoActor) { let server_storage = server_storage.clone(); let webhook = webhook.clone(); let net = net.clone(); move |(repo_alias, server_repo_config)| { let span = tracing::info_span!("create_actor", alias = %repo_alias, config = %server_repo_config); let _guard = span.enter(); info!("Creating Repo"); let gitdir = server_repo_config.gitdir().map_or_else( || { GitDir::from( server_storage .path() .join(forge_name.to_string()) .join(repo_alias.to_string()), ) }, |gitdir| gitdir, ); // INFO: can't canonicalise gitdir as the path needs to exist to do that and we may not // have cloned the repo yet let repo_details = config::RepoDetails::new( &repo_alias, server_repo_config, &forge_name, &forge_config, gitdir, ); info!("Starting Repo Actor"); let actor = actors::repo::RepoActor::new(repo_details, webhook.clone(), net.clone()); (forge_name.clone(), repo_alias, actor) } } fn start_actor( actor: (ForgeName, RepoAlias, actors::repo::RepoActor), ) -> (RepoAlias, Addr) { let (forge_name, repo_alias, actor) = actor; let span = tracing::info_span!("start_actor", forge = %forge_name, repo = %repo_alias); let _guard = span.enter(); info!("Starting"); let addr = actor.start(); addr.do_send(actors::repo::CloneRepo); info!("Started"); (repo_alias, addr) } pub fn init_logging() { use tracing_subscriber::prelude::*; let subscriber = tracing_subscriber::fmt::layer() // NOTE: set RUSTLOG in ${root}/.cargo/config .with_target(false) .with_file(true) .with_line_number(true) .with_filter(LevelFilter::INFO); tracing_subscriber::registry() .with(console_subscriber::ConsoleLayer::builder().spawn()) .with(subscriber) .init(); }