ping-rust 0.2.1

Menu-driven installer and manager for the shoes proxy server
use std::{collections::BTreeSet, error::Error, fmt, path::Path};

use anyhow::{bail, Result};

use crate::{
    chain_proxy::ChainProxyChange,
    config::{self, GenerationRequest, GenerationResult, ProfileChange},
    performance, service, utils,
};
use uuid::Uuid;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ApplyOperation {
    AddOrEdit,
    Delete,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ApplyStrategy {
    NoServiceAction,
    Activate,
    Stop,
    HotReload,
}

fn plan_apply(
    operation: ApplyOperation,
    runtime_changed: bool,
    was_active: bool,
    remaining_profiles: usize,
    hot_reload_ready: bool,
) -> ApplyStrategy {
    if !runtime_changed || (operation == ApplyOperation::Delete && !was_active) {
        ApplyStrategy::NoServiceAction
    } else if operation == ApplyOperation::Delete && remaining_profiles == 0 {
        ApplyStrategy::Stop
    } else if was_active && hot_reload_ready {
        ApplyStrategy::HotReload
    } else {
        ApplyStrategy::Activate
    }
}

fn capture_reload_readiness(snapshot: &service::ServiceSnapshot) -> service::HotReloadReadiness {
    service::capture_hot_reload_snapshot(snapshot).unwrap_or_else(|error| {
        service::HotReloadReadiness::Unavailable(service::HotReloadReason::InspectionFailed(
            format!("{error:#}"),
        ))
    })
}

#[derive(Debug)]
pub(crate) struct ActivationFailure {
    message: String,
    source: anyhow::Error,
}

impl ActivationFailure {
    pub(crate) fn new(message: impl Into<String>, source: anyhow::Error) -> Self {
        Self {
            message: message.into(),
            source,
        }
    }
}

impl fmt::Display for ActivationFailure {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(&self.message)
    }
}

impl Error for ActivationFailure {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        Some(self.source.as_ref())
    }
}

pub async fn generate_and_activate(request: GenerationRequest) -> Result<GenerationResult> {
    utils::require_linux_root()?;
    let lock = utils::exclusive_lock(Path::new(utils::LOCK_FILE))?;
    let service_snapshot = service::capture_snapshot()?;
    let hot_reload_snapshot = capture_reload_readiness(&service_snapshot).filter(|snapshot| {
        config::load_state().is_ok_and(|state| {
            state
                .profiles
                .iter()
                .all(|profile| snapshot.listening_ports.contains(&profile.port))
        })
    });
    let mut result = config::generate_locked(request, lock).await?;
    let strategy = plan_apply(
        ApplyOperation::AddOrEdit,
        true,
        service_snapshot.was_active(),
        1,
        hot_reload_snapshot.is_ready(),
    );
    let activation = if strategy == ApplyStrategy::HotReload {
        let snapshot = hot_reload_snapshot
            .into_snapshot()
            .expect("hot reload strategy requires a snapshot");
        let mut expected = snapshot.listening_ports.clone();
        expected.insert(result.profile.port);
        service::hot_reload_and_verify(snapshot, &expected, &BTreeSet::new())
    } else {
        hot_reload_snapshot.report_controlled_restart(service_snapshot.was_active());
        service::activate_and_verify()
    };
    if let Err(activation) = activation {
        let _rollback_timer = performance::stage("rollback_restore");
        let config_rollback = result.rollback_managed();
        let service_rollback = service::restore_snapshot(service_snapshot);
        let message = match (config_rollback, service_rollback) {
            (Ok(()), Ok(())) => "shoes 激活失败,配置和服务状态已回滚".to_owned(),
            (Err(config), Ok(())) => {
                format!("shoes 激活失败,服务状态已恢复,但配置回滚失败:配置={config:#}")
            }
            (Ok(()), Err(service)) => {
                format!("shoes 激活失败,配置已回滚,但服务状态恢复失败:服务={service:#}")
            }
            (Err(config), Err(service)) => format!(
                "shoes 激活失败,配置与服务状态回滚均失败:配置={config:#};服务={service:#}"
            ),
        };
        return Err(anyhow::Error::new(ActivationFailure::new(
            message, activation,
        )));
    }
    Ok(result)
}

pub async fn update_and_activate(id: Uuid, change: ProfileChange) -> Result<GenerationResult> {
    utils::require_linux_root()?;
    let lock = utils::exclusive_lock(Path::new(utils::LOCK_FILE))?;
    let service_snapshot = service::capture_snapshot()?;
    let observable_port_change = matches!(&change, ProfileChange::Port(_));
    let previous_port = if observable_port_change {
        config::load_state()?
            .profiles
            .iter()
            .find(|profile| profile.id == id)
            .map(|profile| profile.port)
    } else {
        None
    };
    let hot_reload_snapshot = observable_port_change.then(|| {
        capture_reload_readiness(&service_snapshot).filter(|snapshot| {
            previous_port.is_some_and(|port| snapshot.listening_ports.contains(&port))
        })
    });
    let mut result = config::update_profile_locked(id, change, lock).await?;
    let strategy = plan_apply(
        ApplyOperation::AddOrEdit,
        result.runtime_config_changed,
        service_snapshot.was_active(),
        1,
        hot_reload_snapshot
            .as_ref()
            .is_some_and(service::HotReloadReadiness::is_ready),
    );
    if strategy == ApplyStrategy::NoServiceAction {
        result.finish_update();
        return Ok(result);
    }
    let activation = if strategy == ApplyStrategy::HotReload {
        let snapshot = hot_reload_snapshot
            .and_then(service::HotReloadReadiness::into_snapshot)
            .expect("hot reload strategy requires a snapshot");
        let mut expected = snapshot.listening_ports.clone();
        if let Some(previous_port) = previous_port {
            expected.remove(&previous_port);
        }
        expected.insert(result.profile.port);
        let mut removed = BTreeSet::new();
        if let Some(previous_port) = previous_port.filter(|port| *port != result.profile.port) {
            removed.insert(previous_port);
        }
        service::hot_reload_and_verify(snapshot, &expected, &removed)
    } else {
        if let Some(readiness) = &hot_reload_snapshot {
            readiness.report_controlled_restart(service_snapshot.was_active());
        }
        service::activate_and_verify()
    };
    if let Err(activation) = activation {
        let _rollback_timer = performance::stage("rollback_restore");
        let config_rollback = result.rollback_managed();
        let service_rollback = service::restore_snapshot(service_snapshot);
        return match (config_rollback, service_rollback) {
            (Ok(()), Ok(())) => {
                Err(activation.context("shoes 激活失败,配置修改和服务状态已回滚"))
            }
            (Err(config), Ok(())) => bail!(
                "shoes 激活失败,服务状态已恢复,但配置修改回滚失败:激活={activation:#};配置={config:#}"
            ),
            (Ok(()), Err(service)) => bail!(
                "shoes 激活失败,配置修改已回滚,但服务状态恢复失败:激活={activation:#};服务={service:#}"
            ),
            (Err(config), Err(service)) => bail!(
                "shoes 激活失败,配置修改与服务状态回滚均失败:激活={activation:#};配置={config:#};服务={service:#}"
            ),
        };
    }
    result.finish_update();
    Ok(result)
}

pub async fn delete_and_activate(id: Uuid) -> Result<config::ManagedProfile> {
    utils::require_linux_root()?;
    let lock = utils::exclusive_lock(Path::new(utils::LOCK_FILE))?;
    let service_snapshot = service::capture_snapshot()?;
    let was_active = Path::new(utils::SERVICE_FILE).exists() && service::is_active()?;
    let hot_reload_snapshot = capture_reload_readiness(&service_snapshot).filter(|snapshot| {
        config::load_state().is_ok_and(|state| {
            state
                .profiles
                .iter()
                .all(|profile| snapshot.listening_ports.contains(&profile.port))
        })
    });
    let mut result = config::delete_profile_locked(id, lock).await?;
    let strategy = plan_apply(
        ApplyOperation::Delete,
        true,
        was_active,
        result.remaining_profiles,
        hot_reload_snapshot.is_ready(),
    );
    let activation = match strategy {
        ApplyStrategy::NoServiceAction => Ok(()),
        ApplyStrategy::Stop => service::execute(service::ServiceAction::Stop),
        ApplyStrategy::HotReload => {
            let snapshot = hot_reload_snapshot
                .into_snapshot()
                .expect("hot reload strategy requires a snapshot");
            let mut expected = snapshot.listening_ports.clone();
            expected.remove(&result.profile.port);
            let removed = BTreeSet::from([result.profile.port]);
            service::hot_reload_and_verify(snapshot, &expected, &removed)
        }
        ApplyStrategy::Activate => {
            hot_reload_snapshot.report_controlled_restart(was_active);
            service::activate_and_verify()
        }
    };
    if let Err(activation) = activation {
        let _rollback_timer = performance::stage("rollback_restore");
        let config_rollback = result.rollback_managed();
        let service_rollback = service::restore_snapshot(service_snapshot);
        return match (config_rollback, service_rollback) {
            (Ok(()), Ok(())) => {
                Err(activation.context("shoes 切换失败,配置删除和服务状态已回滚"))
            }
            (Err(config), Ok(())) => bail!(
                "shoes 切换失败,服务状态已恢复,但配置删除回滚失败:切换={activation:#};配置={config:#}"
            ),
            (Ok(()), Err(service)) => bail!(
                "shoes 切换失败,配置删除已回滚,但服务状态恢复失败:切换={activation:#};服务={service:#}"
            ),
            (Err(config), Err(service)) => bail!(
                "shoes 切换失败,配置删除与服务状态回滚均失败:切换={activation:#};配置={config:#};服务={service:#}"
            ),
        };
    }
    Ok(result.finish())
}

pub async fn update_chain_proxy(change: ChainProxyChange) -> Result<config::ManagedState> {
    utils::require_linux_root()?;
    let lock = utils::exclusive_lock(Path::new(utils::LOCK_FILE))?;
    let service_snapshot = service::capture_snapshot()?;
    let mut result = config::update_chain_proxy_locked(change, lock).await?;
    if result.configuration_changed && result.profiles_count > 0 {
        if let Err(activation) = service::activate_and_verify() {
            let _rollback_timer = performance::stage("rollback_restore");
            let config_rollback = result.rollback_managed();
            let service_rollback = service::restore_snapshot(service_snapshot);
            return match (config_rollback, service_rollback) {
                (Ok(()), Ok(())) => {
                    Err(activation.context("链式代理切换失败,配置和服务状态已回滚"))
                }
                (Err(config), Ok(())) => bail!(
                    "链式代理切换失败,服务状态已恢复,但配置回滚失败:切换={activation:#};配置={config:#}"
                ),
                (Ok(()), Err(service)) => bail!(
                    "链式代理切换失败,配置已回滚,但服务状态恢复失败:切换={activation:#};服务={service:#}"
                ),
                (Err(config), Err(service)) => bail!(
                    "链式代理切换失败,配置与服务状态回滚均失败:切换={activation:#};配置={config:#};服务={service:#}"
                ),
            };
        }
    }
    Ok(result.finish())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn apply_planner_preserves_start_stop_and_verified_reload_boundaries() {
        let plan = |operation, changed, active, remaining, observable| {
            plan_apply(operation, changed, active, remaining, observable)
        };
        assert_eq!(
            plan(ApplyOperation::AddOrEdit, false, true, 1, true),
            ApplyStrategy::NoServiceAction
        );
        assert_eq!(
            plan(ApplyOperation::AddOrEdit, true, true, 2, true),
            ApplyStrategy::HotReload
        );
        assert_eq!(
            plan(ApplyOperation::AddOrEdit, true, true, 2, false),
            ApplyStrategy::Activate
        );
        assert_eq!(
            plan(ApplyOperation::AddOrEdit, true, false, 1, false),
            ApplyStrategy::Activate
        );
        assert_eq!(
            plan(ApplyOperation::Delete, true, true, 0, true),
            ApplyStrategy::Stop
        );
        assert_eq!(
            plan(ApplyOperation::Delete, true, false, 1, false),
            ApplyStrategy::NoServiceAction
        );
    }
}