use crate::vpn::profile::WgProfile;
use crate::vpn::{Backend, ConnectionInfo, NetError};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Preference {
Auto,
Native,
Docker,
}
pub trait Connector {
fn available(&self) -> bool;
fn connect(&self, profile: &WgProfile) -> Result<ConnectionInfo, NetError>;
fn status(&self) -> Result<Option<ConnectionInfo>, NetError>;
fn disconnect(&self) -> Result<(), NetError>;
}
pub(crate) fn choose(
pref: Preference,
native_ok: bool,
docker_ok: bool,
) -> Result<Backend, NetError> {
match pref {
Preference::Native => {
if native_ok {
Ok(Backend::Native)
} else {
Err(NetError::NoBackend)
}
}
Preference::Docker => {
if docker_ok {
Ok(Backend::Docker)
} else {
Err(NetError::NoBackend)
}
}
Preference::Auto => {
if native_ok {
Ok(Backend::Native)
} else if docker_ok {
Ok(Backend::Docker)
} else {
Err(NetError::NoBackend)
}
}
}
}
pub fn select_connector(pref: Preference) -> Result<Box<dyn Connector>, NetError> {
let native = crate::vpn::native::NativeConnector;
let docker = crate::vpn::docker::DockerConnector;
let backend = match choose(pref, native.available(), docker.available()) {
Ok(b) => b,
Err(e) => {
return Err(no_backend_error(
e,
pref,
crate::vpn::native::readiness(),
crate::vpn::native::wg_quick_path,
))
}
};
Ok(match backend {
Backend::Native => Box::new(native),
Backend::Docker => Box::new(docker),
Backend::Host => Box::new(crate::vpn::host::HostConnector),
})
}
pub(crate) fn no_backend_error(
e: NetError,
pref: Preference,
native: crate::vpn::native::Readiness,
wg_quick_path: impl FnOnce() -> Option<String>,
) -> NetError {
match (e, pref, native) {
(
NetError::NoBackend,
Preference::Auto | Preference::Native,
crate::vpn::native::Readiness::NeedsRoot,
) => NetError::NativeNeedsRoot(wg_quick_path()),
(e, _, _) => e,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::vpn::native::Readiness;
#[test]
fn installed_but_not_root_says_root_not_install() {
let path = || Some("/opt/homebrew/bin/wg-quick".to_string());
let e = no_backend_error(
NetError::NoBackend,
Preference::Auto,
Readiness::NeedsRoot,
path,
);
let msg = e.to_string();
assert!(matches!(e, NetError::NativeNeedsRoot(_)));
assert!(msg.contains("/opt/homebrew/bin/wg-quick"), "{msg}");
assert!(msg.contains("sudo zc connect"), "{msg}");
assert!(!msg.contains("install WireGuard"), "{msg}");
}
#[test]
fn missing_wireguard_and_forced_docker_keep_no_backend() {
assert!(matches!(
no_backend_error(
NetError::NoBackend,
Preference::Auto,
Readiness::Missing,
|| None
),
NetError::NoBackend
));
assert!(matches!(
no_backend_error(
NetError::NoBackend,
Preference::Docker,
Readiness::NeedsRoot,
|| None
),
NetError::NoBackend
));
}
#[test]
fn auto_prefers_native_then_docker() {
assert_eq!(
choose(Preference::Auto, true, true).unwrap(),
Backend::Native
);
assert_eq!(
choose(Preference::Auto, false, true).unwrap(),
Backend::Docker
);
assert!(matches!(
choose(Preference::Auto, false, false),
Err(NetError::NoBackend)
));
}
#[test]
fn forced_backends_require_availability() {
assert_eq!(
choose(Preference::Native, true, false).unwrap(),
Backend::Native
);
assert!(matches!(
choose(Preference::Native, false, true),
Err(NetError::NoBackend)
));
assert_eq!(
choose(Preference::Docker, false, true).unwrap(),
Backend::Docker
);
assert!(matches!(
choose(Preference::Docker, true, false),
Err(NetError::NoBackend)
));
}
}