zc2 0.0.51

P2P compute broker with yen-denominated billing, WAL, and broker mesh support
//! The `Connector` seam and backend auto-selection.

use crate::vpn::profile::WgProfile;
use crate::vpn::{Backend, ConnectionInfo, NetError};

/// Forced backend preference from the CLI (`--native` / `--docker`).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Preference {
    Auto,
    Native,
    Docker,
}

/// A tunnel backend. Each impl is independently testable.
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>;
}

/// Pure selection logic: pick a backend given a preference and what's available.
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)
            }
        }
    }
}

/// Build the concrete connector to use, honoring `pref` and real availability.
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),
        // `choose` never picks it: a host tunnel is found, not chosen.
        Backend::Host => Box::new(crate::vpn::host::HostConnector),
    })
}

/// Sharpen a `NoBackend`: when WireGuard is installed and only root is
/// missing, say that instead of "install WireGuard" (zc#380).
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
        ));
        // `--docker` asked for Docker: WireGuard's state is beside the point.
        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)
        ));
    }
}