singbox-driver 0.68.5

Engine driver for the sing-box core: control API, configuration codec and process supervision.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

//! CoreScope and live-version fence shared by every sing-box Clash API adapter.

use crate::api::clash_api::SingBoxCoreVersionProvider;
use lurker_core_contract::error::{ErrorCode, Failure};
use lurker_core_contract::identity::{CoreScope, EngineId};
use lurker_core_ports::core_scope::{CoreScopeObservation, CoreScopeSource};
use lurker_core_ports::error::PortError;

pub(crate) fn engine_id() -> EngineId {
    EngineId::sing_box()
}

pub(crate) fn rejected(code: ErrorCode, message: impl Into<String>) -> PortError {
    PortError::Rejected(Failure::new(code, message, false))
}

pub(crate) fn verify_owner_scope(
    scope_source: &dyn CoreScopeSource,
    requested: &CoreScope,
) -> Result<(), PortError> {
    if requested.identity.engine != engine_id() {
        return Err(rejected(
            ErrorCode::InvalidState,
            "sing-box Clash API adapter received a scope for another engine",
        ));
    }
    if requested.identity.version.is_none() {
        return Err(rejected(
            ErrorCode::NotReady,
            "sing-box Clash API operations require an observed core version in CoreScope",
        ));
    }
    match scope_source.scope_observation() {
        CoreScopeObservation::Observed(current) if &current == requested => Ok(()),
        CoreScopeObservation::Observed(_) => Err(rejected(
            ErrorCode::InvalidState,
            "active CoreScope changed during sing-box Clash API operation",
        )),
        CoreScopeObservation::Unavailable => Err(rejected(
            ErrorCode::NotReady,
            "no active CoreScope is available for sing-box Clash API operation",
        )),
    }
}

pub(crate) async fn verify_live_scope(
    version_provider: &SingBoxCoreVersionProvider,
    scope_source: &dyn CoreScopeSource,
    requested: &CoreScope,
) -> Result<(), PortError> {
    verify_owner_scope(scope_source, requested)?;
    let actual = version_provider.observe().await?;
    verify_owner_scope(scope_source, requested)?;
    if requested.identity.version.as_ref() != Some(&actual) {
        return Err(rejected(
            ErrorCode::InvalidState,
            "live sing-box version differs from the observed CoreScope version",
        ));
    }
    Ok(())
}