memlink-runtime 0.2.0

Dynamic module loading framework with circuit breaker, caching, pooling, health checks, versioning, and auto-discovery
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Module ABI version checking and compatibility validation.

pub const MEMLINK_ABI_VERSION: u32 = 1;
pub const MIN_SUPPORTED_ABI_VERSION: u32 = 1;
pub const MAX_SUPPORTED_ABI_VERSION: u32 = 1;

#[repr(C)]
#[derive(Debug, Clone, Copy, Default)]
pub struct AbiInfo {
    pub version: u32,
    pub flags: u32,
}

impl AbiInfo {
    pub fn new() -> Self {
        AbiInfo {
            version: MEMLINK_ABI_VERSION,
            flags: 0,
        }
    }

    pub fn with_version_and_flags(version: u32, flags: u32) -> Self {
        AbiInfo { version, flags }
    }

    pub fn is_compatible(&self) -> bool {
        self.version >= MIN_SUPPORTED_ABI_VERSION && self.version <= MAX_SUPPORTED_ABI_VERSION
    }

    pub fn supports_state_serialization(&self) -> bool {
        self.flags & 0x01 != 0
    }

    pub fn supports_async(&self) -> bool {
        self.flags & 0x02 != 0
    }

    pub fn mismatch_severity(&self) -> AbiMismatchSeverity {
        if self.is_compatible() {
            AbiMismatchSeverity::Compatible
        } else if self.version < MIN_SUPPORTED_ABI_VERSION {
            AbiMismatchSeverity::TooOld
        } else {
            AbiMismatchSeverity::TooNew
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AbiMismatchSeverity {
    Compatible,
    TooOld,
    TooNew,
}

pub fn validate_abi_version(module_version: u32) -> Result<(), AbiVersionError> {
    if module_version >= MIN_SUPPORTED_ABI_VERSION && module_version <= MAX_SUPPORTED_ABI_VERSION {
        Ok(())
    } else if module_version < MIN_SUPPORTED_ABI_VERSION {
        Err(AbiVersionError::TooOld {
            module: module_version,
            min_supported: MIN_SUPPORTED_ABI_VERSION,
        })
    } else {
        Err(AbiVersionError::TooNew {
            module: module_version,
            max_supported: MAX_SUPPORTED_ABI_VERSION,
        })
    }
}

#[derive(Debug, Clone, thiserror::Error)]
pub enum AbiVersionError {
    #[error("Module ABI version {module} is too old (minimum supported: {min_supported})")]
    TooOld {
        module: u32,
        min_supported: u32,
    },

    #[error("Module ABI version {module} is too new (maximum supported: {max_supported})")]
    TooNew {
        module: u32,
        max_supported: u32,
    },
}