128 lines
4.8 KiB
Rust
128 lines
4.8 KiB
Rust
use anyhow::Result;
|
|
use tracing::info;
|
|
|
|
use crate::Router;
|
|
|
|
/// Which package manager is available on this router.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum PkgManager {
|
|
/// Traditional opkg (OpenWrt ≤24.x).
|
|
Opkg,
|
|
/// OpenWrt 25.x+ — apk is the native manager, opkg is not in repos.
|
|
ApkNative,
|
|
}
|
|
|
|
impl Router {
|
|
/// Detect which package manager is available.
|
|
///
|
|
/// - If `/usr/bin/opkg` exists → `PkgManager::Opkg` (nothing to do).
|
|
/// - If `/usr/bin/apk` exists → run `apk update` (switching repos to HTTP
|
|
/// first to work around missing CA bundle on fresh images), then try
|
|
/// `apk add opkg`. If opkg is in the repos → `Opkg`. If not (OpenWrt
|
|
/// 25.x) → `ApkNative`.
|
|
/// - Neither found → error.
|
|
pub fn opkg_check(&self) -> Result<PkgManager> {
|
|
let (_, code) = self.run("test -x /usr/bin/opkg")?;
|
|
if code == 0 {
|
|
return Ok(PkgManager::Opkg);
|
|
}
|
|
|
|
let (_, apk_code) = self.run("test -x /usr/bin/apk")?;
|
|
if apk_code == 0 {
|
|
info!("[{}] opkg not found — using apk (OpenWrt 25.x+)", self.host);
|
|
// Fresh images ship without a CA bundle; switch repos to HTTP so
|
|
// apk's wget can reach the package index without TLS verification.
|
|
self.run_ok("sed -i 's|https://|http://|g' /etc/apk/repositories 2>/dev/null || true")?;
|
|
let (update_out, update_code) = self.run("/usr/bin/apk update 2>&1")?;
|
|
if update_code != 0 {
|
|
anyhow::bail!(
|
|
"apk update failed (exit {}) — router may have no internet access. \
|
|
Ensure WAN/internet is working on the router before provisioning.\n{}",
|
|
update_code,
|
|
update_out.trim()
|
|
);
|
|
}
|
|
// Try to install opkg (only available on some 25.x builds).
|
|
let (add_out, add_code) = self.run("/usr/bin/apk add opkg 2>&1")?;
|
|
if add_code == 0 {
|
|
return Ok(PkgManager::Opkg);
|
|
}
|
|
if add_out.contains("no such package") || add_out.contains("unable to select") {
|
|
info!(
|
|
"[{}] opkg not in apk repos — staying in apk-native mode",
|
|
self.host
|
|
);
|
|
return Ok(PkgManager::ApkNative);
|
|
}
|
|
anyhow::bail!(
|
|
"apk add opkg failed (exit {}): {}",
|
|
add_code,
|
|
add_out.trim()
|
|
);
|
|
}
|
|
|
|
anyhow::bail!(
|
|
"opkg not found at /usr/bin/opkg — this router's firmware may not \
|
|
support package management (TollGate requires a standard OpenWrt build)"
|
|
);
|
|
}
|
|
|
|
/// `opkg update` — refresh package lists.
|
|
pub fn opkg_update(&self) -> Result<()> {
|
|
info!("[{}] opkg update", self.host);
|
|
self.run_ok("/usr/bin/opkg update")?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Install a package, skipping if already installed.
|
|
pub fn opkg_install(&self, package: &str) -> Result<()> {
|
|
// Check if already installed to avoid unnecessary network traffic.
|
|
let (_, code) = self.run(&format!(
|
|
"/usr/bin/opkg list-installed | grep -q '^{} '",
|
|
package
|
|
))?;
|
|
if code == 0 {
|
|
info!("[{}] {} already installed", self.host, package);
|
|
return Ok(());
|
|
}
|
|
|
|
info!("[{}] opkg install {}", self.host, package);
|
|
self.run_ok(&format!("/usr/bin/opkg install {}", package))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Remove a package.
|
|
pub fn opkg_remove(&self, package: &str) -> Result<()> {
|
|
info!("[{}] opkg remove {}", self.host, package);
|
|
self.run_ok(&format!("/usr/bin/opkg remove {}", package))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Install a standard OpenWrt package via whichever manager is active.
|
|
///
|
|
/// Unlike `tollgate-module-basic-go` itself (which falls back to manual
|
|
/// `.ipk` extraction and therefore skips dependency resolution — see
|
|
/// `tollgate::install`), packages like `nodogsplash` are in every
|
|
/// upstream OpenWrt feed, so a plain `apk add` / `opkg install` works
|
|
/// even in `ApkNative` mode.
|
|
pub fn install_package(&self, pkg_mgr: PkgManager, package: &str) -> Result<()> {
|
|
match pkg_mgr {
|
|
PkgManager::Opkg => self.opkg_install(package),
|
|
PkgManager::ApkNative => self.apk_install(package),
|
|
}
|
|
}
|
|
|
|
/// `apk add <package>`, skipping if already installed.
|
|
pub fn apk_install(&self, package: &str) -> Result<()> {
|
|
let (_, code) = self.run(&format!("apk info -e {} >/dev/null 2>&1", package))?;
|
|
if code == 0 {
|
|
info!("[{}] {} already installed", self.host, package);
|
|
return Ok(());
|
|
}
|
|
|
|
info!("[{}] apk add {}", self.host, package);
|
|
self.run_ok(&format!("/usr/bin/apk add {}", package))?;
|
|
Ok(())
|
|
}
|
|
}
|