From bfe0424217556fbb37f1129bc892c8d275ff0477 Mon Sep 17 00:00:00 2001 From: namilsk Date: Sun, 8 Mar 2026 18:19:22 +0300 Subject: Fixed build with `integrated-router` feature, CI pipelines, clippy warnings and some minor edits --- src/main.rs | 554 ++++++++++++++++++++++++------------------------ src/openpgp/trusted.rs | 2 +- src/pkgtoolkit/build.rs | 7 +- src/router/manager.rs | 2 + src/router/mod.rs | 3 +- 5 files changed, 279 insertions(+), 289 deletions(-) (limited to 'src') diff --git a/src/main.rs b/src/main.rs index 88d9240..c9031f6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -6,18 +6,17 @@ mod router; use crate::cfg::config::Config; use crate::net::{http_package::HTTPPackage, i2p_package::I2PPackage}; +use crate::pkgtoolkit::Package; use crate::pkgtoolkit::archive::ArchiveOperations; use crate::pkgtoolkit::build::BuildOperations; use crate::pkgtoolkit::git_source::GitSource; use crate::pkgtoolkit::index::IndexOperations; use crate::pkgtoolkit::install::InstallOperations; -use crate::pkgtoolkit::Package; #[cfg(feature = "integrated-router")] use crate::router::manager::RouterManager; use clap::{Args, Parser, Subcommand}; -use mesk::cfg::config; use std::io::Write; use std::path::Path; @@ -81,79 +80,145 @@ struct RemoteInstallArgs { clean: bool, } +/// Helper to initialize router manager when integrated-router feature is enabled +#[cfg(feature = "integrated-router")] +async fn init_router_manager( + config: &Config, +) -> Result, Box> { + if !config.router.integrated_router { + return Ok(None); + } + + println!("Starting integrated router..."); + match RouterManager::new(config).await { + Ok(manager) => { + println!("Router manager initialized"); + Ok(Some(manager)) + } + Err(e) => { + eprintln!("Failed to initialize router manager: {}", e); + Err(e) + } + } +} + +/// Helper to check if router is running (integrated-router feature only) +#[cfg(feature = "integrated-router")] +async fn ensure_router_ready( + manager: &Option, +) -> Result<(), Box> { + if let Some(m) = manager { + if !m.is_running() { + eprintln!("Router is not running, cannot proceed with I2P operation"); + return Err(std::io::Error::other("Router not running").into()); + } + } + Ok(()) +} + #[tokio::main] async fn main() -> Result<(), Box> { let cli: Cli = Cli::parse(); - /* - // Parse config once at the beginning - let config = Config::parse()?; - - // Setup integrated router if enabled - let router_manager = if config.router.integrated_router { - println!("Starting integrated router..."); - match RouterManager::new(&config).await { - Ok(manager) => { - println!("Router manager initialized"); - Some(manager) - } - Err(e) => { - eprintln!("Failed to initialize router manager: {}", e); - return Err(e); + match &cli.command { + Commands::Validate { path } => { + println!("Validating {}", path); + match Package::check(path.to_string()) { + Ok(is_valid) => { + if is_valid { + println!("Package archive is valid."); + } else { + println!("Package archive is invalid."); + return Err(std::io::Error::other("Invalid package archive").into()); + } + } + Err(e) => { + eprintln!("Failed to validate package '{}': {}", path, e); + return Err(e.into()); + } } + Ok(()) } - } else { - println!("Integrated router disabled"); - None - }; - */ - - let result = { - match &cli.command { - Commands::Validate { path } => { - println!("Validating {}", path); - match Package::check(path.to_string()) { - Ok(is_valid) => { - if is_valid { - println!("Package archive is valid."); - } else { - println!("Package archive is invalid."); - return Err(std::io::Error::other("Invalid package archive").into()); + Commands::Build { pkgname } => { + println!("Building package from archive: {}", pkgname); + + let config = Config::parse()?; + let path = Path::new(&pkgname); + if !path.exists() { + return Err(std::io::Error::other(format!( + "Package archive not found: {}", + pkgname + )) + .into()); + } + + if !path.is_file() { + return Err( + std::io::Error::other(format!("Path is not a file: {}", pkgname)).into(), + ); + } + + println!("Extracting archive..."); + Package::extract_archive(pkgname)?; + + let cache_dir = &config.paths.cache_dir; + + let mut pkg_dir_name = None; + for entry in std::fs::read_dir(cache_dir)? { + let entry = entry?; + let path = entry.path(); + if path.is_dir() { + let dir_name = path.file_name().unwrap().to_string_lossy(); + if dir_name.contains('-') && dir_name != "temp_extract" { + let install_path = path.join("INSTALL"); + if install_path.exists() { + pkg_dir_name = Some(dir_name.to_string()); + break; } } - Err(e) => { - eprintln!("Failed to validate package '{}': {}", path, e); - return Err(e.into()); - } } - return Ok(()); } - Commands::Build { pkgname } => { - println!("Building package from archive: {}", pkgname); - let config = Config::parse()?; + let pkg_dir_name = pkg_dir_name + .ok_or_else(|| std::io::Error::other("Package directory not found in cache"))?; - let path = Path::new(&pkgname); - if !path.exists() { - return Err(std::io::Error::other(format!( - "Package archive not found: {}", - pkgname - )) - .into()); - } + let install_toml_path = Path::new(cache_dir).join(format!("{}/INSTALL", pkg_dir_name)); - if !path.is_file() { - return Err( - std::io::Error::other(format!("Path is not a file: {}", pkgname)).into(), - ); - } + if !install_toml_path.exists() { + return Err( + std::io::Error::other("INSTALL file not found in package directory").into(), + ); + } + + let install_content = std::fs::read_to_string(&install_toml_path)?; + let install_data: crate::pkgtoolkit::types::Install = toml::from_str(&install_content)?; + + let mut pkg = install_data.package; + + println!("Building package '{}'...", pkg.name); + pkg.build()?; + println!("Package '{}' built successfully.", pkg.name); + Ok(()) + } + Commands::Install { + pkgname, + source: _, + path, + args, + } => { + let config = Config::parse()?; + + #[cfg(feature = "integrated-router")] + let router_manager = init_router_manager(&config).await?; + + if *path { + println!("Installing package from local file: {}", pkgname); println!("Extracting archive..."); Package::extract_archive(pkgname)?; let cache_dir = &config.paths.cache_dir; - // Find the package directory (should be name-version format) let mut pkg_dir_name = None; for entry in std::fs::read_dir(cache_dir)? { let entry = entry?; @@ -175,14 +240,6 @@ async fn main() -> Result<(), Box> { let install_toml_path = Path::new(cache_dir).join(format!("{}/INSTALL", pkg_dir_name)); - - if !install_toml_path.exists() { - return Err(std::io::Error::other( - "INSTALL file not found in package directory", - ) - .into()); - } - let install_content = std::fs::read_to_string(&install_toml_path)?; let install_data: crate::pkgtoolkit::types::Install = toml::from_str(&install_content)?; @@ -191,245 +248,178 @@ async fn main() -> Result<(), Box> { println!("Building package '{}'...", pkg.name); pkg.build()?; - println!("Package '{}' built successfully.", pkg.name); - return Ok(()); - } - Commands::Install { - pkgname, - source: _, - path, - args, - } => { - let config = Config::parse()?; - if *path { - println!("Installing package from local file: {}", pkgname); - - println!("Extracting archive..."); - Package::extract_archive(pkgname)?; - - let cache_dir = &config.paths.cache_dir; - - let mut pkg_dir_name = None; - for entry in std::fs::read_dir(cache_dir)? { - let entry = entry?; - let path = entry.path(); - if path.is_dir() { - let dir_name = path.file_name().unwrap().to_string_lossy(); - if dir_name.contains('-') && dir_name != "temp_extract" { - let install_path = path.join("INSTALL"); - if install_path.exists() { - pkg_dir_name = Some(dir_name.to_string()); - break; - } - } - } - } - - let pkg_dir_name = pkg_dir_name.ok_or_else(|| { - std::io::Error::other("Package directory not found in cache") - })?; - let install_toml_path = - Path::new(cache_dir).join(format!("{}/INSTALL", pkg_dir_name)); - let install_content = std::fs::read_to_string(&install_toml_path)?; - let install_data: crate::pkgtoolkit::types::Install = - toml::from_str(&install_content)?; - - let mut pkg = install_data.package; - - println!("Building package '{}'...", pkg.name); - pkg.build()?; - - println!("Installing package '{}'...", pkg.name); - pkg.install()?; - println!("Package '{}' installed successfully.", pkg.name); - } else { - #[cfg(feature = "integrated-router")] - { - if !args.http && config.router.integrated_router { - if let Some(ref manager) = router_manager { - println!("Waiting for router to be ready..."); - tokio::time::sleep(std::time::Duration::from_secs(3)).await; - if !manager.is_running() { - eprintln!( - "Router is not running, cannot proceed with I2P installation" - ); - return Err(std::io::Error::other("Router not running").into()); - } - } - } - } - if args.http { - println!("Installing {} via non-i2p mirror", pkgname); - let mut http_client = HTTPPackage::new(config); - http_client.fetch_index_http().await?; - println!("Index fetched successfully."); - http_client.fetch_package_http(pkgname).await?; - println!("Package '{}' installed successfully.", pkgname); - } else { - println!("Installing {} via I2P", pkgname); - let mut i2p_client = I2PPackage::new(config); - i2p_client.fetch_index().await?; - println!("Index fetched successfully."); - i2p_client.fetch_package(pkgname).await?; - println!("Package '{}' installed successfully.", pkgname); - } - } - return Ok(()); - } - Commands::Uninstall { pkgname } => { - println!("Uninstalling package: {}", pkgname); - - let installed_packages = Package::list_installed_packages().map_err(|e| { - eprintln!("Failed to list installed packages: {}", e); - e - })?; - - let package_manifest = installed_packages - .iter() - .find(|p| p.name == *pkgname) - .ok_or_else(|| { - std::io::Error::other(format!("Package '{}' is not installed", pkgname)) - })?; - - let package = Package { - name: package_manifest.name.clone(), - version: package_manifest.version.clone(), - ..Default::default() - }; - - match package.uninstall() { - Ok(true) => { - println!("Successfully uninstalled package: {}", pkgname); - Ok(()) - } - Ok(false) => { - eprintln!( - "Some files could not be removed during uninstallation of {}", - pkgname - ); - Err(std::io::Error::other("Partial uninstallation occurred").into()) - } - Err(e) => { - eprintln!("Failed to uninstall package {}: {}", pkgname, e); - Err(e.into()) - } - } - } - Commands::GetSource { pkgname } => { - // Initialize router for I2P connections if enabled - let config = Config::parse()?; + println!("Installing package '{}'...", pkg.name); + pkg.install()?; + println!("Package '{}' installed successfully.", pkg.name); + } else { #[cfg(feature = "integrated-router")] { - if config.router.integrated_router { - if let Some(ref manager) = router_manager { - println!("Waiting for router to be ready..."); - tokio::time::sleep(std::time::Duration::from_secs(2)).await; - if !manager.is_running() { - eprintln!( - "Router is not running, cannot proceed with I2P operation" - ); - return Err(std::io::Error::other("Router not running").into()); - } - } + if !args.http && config.router.integrated_router { + println!("Waiting for router to be ready..."); + tokio::time::sleep(std::time::Duration::from_secs(3)).await; + ensure_router_ready(&router_manager).await?; } - - let source_path = GitSource::get_source_by_name(pkgname, &config)?; } - #[cfg(feature = "minimal")] - { - let package = I2PPackage::new(); - let package_fetch = package.fetch_package(pkgname); + if args.http { + println!("Installing {} via non-i2p mirror", pkgname); + let mut http_client = HTTPPackage::new(config); + http_client.fetch_index_http().await?; + println!("Index fetched successfully."); + http_client.fetch_package_http(pkgname).await?; + println!("Package '{}' installed successfully.", pkgname); + } else { + println!("Installing {} via I2P", pkgname); + let mut i2p_client = I2PPackage::new(config); + i2p_client.fetch_index().await?; + println!("Index fetched successfully."); + i2p_client.fetch_package(pkgname).await?; + println!("Package '{}' installed successfully.", pkgname); } - - println!("Getting source of {}", pkgname); - - println!("Source code successfully downloaded to cachedir"); - return Ok(()); } - Commands::DefaultConfig { - repo, - cachedir, - buildir, - installed_db, - } => { - println!("Generating config file"); - if cachedir.is_none() && repo.is_none() && buildir.is_none() { - let config = Config::default()?; - - println!("---- Start of generated config ----"); - println!("{}", config); - println!("---- End of generated config ----"); - - eprintln!("Writing the default config to /etc/mesk/mesk.toml"); - - let path = Path::new("/etc/mesk/mesk.toml"); - std::fs::create_dir_all(path.parent().unwrap())?; - let mut file = std::fs::File::create(path)?; - file.write_all(config.as_bytes())?; - println!("Config tool ending work."); - } else { - let config = Config::generate(repo, cachedir, buildir, installed_db).unwrap(); - - println!("---- Start of generated config ----"); - println!("{:?}", config); - println!("---- End of generated config ----"); + Ok(()) + } + Commands::Uninstall { pkgname } => { + println!("Uninstalling package: {}", pkgname); + + let installed_packages = Package::list_installed_packages().map_err(|e| { + eprintln!("Failed to list installed packages: {}", e); + e + })?; + + let package_manifest = installed_packages + .iter() + .find(|p| p.name == *pkgname) + .ok_or_else(|| { + std::io::Error::other(format!("Package '{}' is not installed", pkgname)) + })?; - eprintln!("Writing the default config to /etc/mesk/mesk.toml"); + let package = Package { + name: package_manifest.name.clone(), + version: package_manifest.version.clone(), + ..Default::default() + }; - let path = Path::new("/etc/mesk/mesk.toml"); - std::fs::create_dir_all(path.parent().unwrap())?; - let mut file = std::fs::File::create(path)?; - file.write_all(config.as_bytes())?; - println!("Config tool ending work."); + match package.uninstall() { + Ok(true) => { + println!("Successfully uninstalled package: {}", pkgname); + Ok(()) + } + Ok(false) => { + eprintln!( + "Some files could not be removed during uninstallation of {}", + pkgname + ); + Err(std::io::Error::other("Partial uninstallation occurred").into()) + } + Err(e) => { + eprintln!("Failed to uninstall package {}: {}", pkgname, e); + Err(e.into()) } - return Ok(()); } - Commands::Update => { - let config = Config::parse()?; + } + Commands::GetSource { pkgname } => { + let config = Config::parse()?; - #[cfg(feature = "integrated-router")] - { + #[cfg(feature = "integrated-router")] + { + let router_manager = init_router_manager(&config).await?; if config.router.integrated_router { - if let Some(ref manager) = router_manager { - println!("Waiting for router to be ready..."); - tokio::time::sleep(std::time::Duration::from_secs(2)).await; - if !manager.is_running() { - eprintln!("Router is not running, cannot proceed with I2P operation"); - return Err(std::io::Error::other("Router not running").into()); - } - } + println!("Waiting for router to be ready..."); + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + ensure_router_ready(&router_manager).await?; } - } - println!("Updating index from {}", config.repo.repo_url); - let mut i2p_client = I2PPackage::new(config); - i2p_client.fetch_index().await?; - println!("Index updated successfully."); - return Ok(()); + let _source_path = GitSource::get_source_by_name(pkgname, &config)?; } - Commands::Upgrade { pkgname } => { - println!("Upgrading {}", pkgname.as_deref().unwrap_or("all packages")); - return Ok(()); + + #[cfg(not(feature = "integrated-router"))] + { + let _package = I2PPackage::new(config); + let _package_fetch = _package.fetch_package(pkgname); } - Commands::Credits => { - println!( - "CREATED BY: Namilsk as part of the Anthrill independent Global network distribution project" - ); - println!(" "); - println!("The Anthrill project repos: https://codeberg.org/NamelessTeam "); - return Ok(()); + + println!("Getting source of {}", pkgname); + println!("Source code successfully downloaded to cachedir"); + Ok(()) + } + Commands::DefaultConfig { + repo, + cachedir, + buildir, + installed_db, + } => { + println!("Generating config file"); + if cachedir.is_none() && repo.is_none() && buildir.is_none() { + let config = Config::default()?; + + println!("---- Start of generated config ----"); + println!("{}", config); + println!("---- End of generated config ----"); + + eprintln!("Writing the default config to /etc/mesk/mesk.toml"); + + let path = Path::new("/etc/mesk/mesk.toml"); + std::fs::create_dir_all(path.parent().unwrap())?; + let mut file = std::fs::File::create(path)?; + file.write_all(config.as_bytes())?; + println!("Config tool ending work."); + } else { + let config = Config::generate(repo, cachedir, buildir, installed_db).unwrap(); + + println!("---- Start of generated config ----"); + println!("{:?}", config); + println!("---- End of generated config ----"); + + eprintln!("Writing the default config to /etc/mesk/mesk.toml"); + + let path = Path::new("/etc/mesk/mesk.toml"); + std::fs::create_dir_all(path.parent().unwrap())?; + let mut file = std::fs::File::create(path)?; + file.write_all(config.as_bytes())?; + println!("Config tool ending work."); } - Commands::GenIndex { path } => { - println!("Generating index for {}", path); + Ok(()) + } + Commands::Update => { + let config = Config::parse()?; - Package::gen_index(path)?; - println!("Index generated successfully."); - return Ok(()); + #[cfg(feature = "integrated-router")] + { + let router_manager = init_router_manager(&config).await?; + if config.router.integrated_router { + println!("Waiting for router to be ready..."); + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + ensure_router_ready(&router_manager).await?; + } } + + println!("Updating index from {}", config.repo.repo_url); + + let mut i2p_client = I2PPackage::new(config); + i2p_client.fetch_index().await?; + println!("Index updated successfully."); + Ok(()) + } + Commands::Upgrade { pkgname } => { + println!("Upgrading {}", pkgname.as_deref().unwrap_or("all packages")); + Ok(()) } - }; + Commands::Credits => { + println!( + "CREATED BY: Namilsk as part of the Anthrill independent Global network distribution project" + ); + println!(" "); + println!("The Anthrill project repos: https://codeberg.org/NamelessTeam "); + Ok(()) + } + Commands::GenIndex { path } => { + println!("Generating index for {}", path); - result + Package::gen_index(path)?; + println!("Index generated successfully."); + Ok(()) + } + } } diff --git a/src/openpgp/trusted.rs b/src/openpgp/trusted.rs index 003d522..6d118b3 100644 --- a/src/openpgp/trusted.rs +++ b/src/openpgp/trusted.rs @@ -32,7 +32,7 @@ impl OpenPGPOpertaions for Key { fn check_sign( &self, sig_path: &Path, - context: &Context, + _context: &Context, file: &Path, ) -> Result { let mut ctx = Context::from_protocol(gpgme::Protocol::OpenPgp)?; diff --git a/src/pkgtoolkit/build.rs b/src/pkgtoolkit/build.rs index 8a46809..d51f30e 100644 --- a/src/pkgtoolkit/build.rs +++ b/src/pkgtoolkit/build.rs @@ -347,11 +347,8 @@ impl BuildOperations for Package { match strategy { Strategies::Bin => { - if install_meta.install.custom_script.is_none() { - log::info!("Strategy: BIN; No custom script. Running default install hook."); - } else { + if let Some(script) = &install_meta.install.custom_script { log::info!("Strategy: BIN; Running custom script."); - let script = install_meta.install.custom_script.as_ref().unwrap(); // Validate script before execution Self::validate_custom_script(script)?; @@ -398,6 +395,8 @@ impl BuildOperations for Package { ))); } } + } else { + log::info!("Strategy: BIN; No custom script. Running default install hook."); } } diff --git a/src/router/manager.rs b/src/router/manager.rs index 5fb8868..9b23434 100644 --- a/src/router/manager.rs +++ b/src/router/manager.rs @@ -127,8 +127,10 @@ impl RouterManager { } } +/* impl Drop for RouterManager { fn drop(&mut self) { //todooo } } +*/ diff --git a/src/router/mod.rs b/src/router/mod.rs index 6426c2e..ac0dc22 100644 --- a/src/router/mod.rs +++ b/src/router/mod.rs @@ -1,5 +1,4 @@ - -#[cfg(feature = "integrated-router")] +#[cfg(feature = "integrated-router")] pub mod manager; #[cfg(feature = "integrated-router")] pub mod router; -- cgit v1.2.3