SEDSnet 4.3.3

A memory safe, no_std-capable networking stack with routing, discovery, reliability, and Rust/C/Python bindings.
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

#![cfg(all(feature = "std", feature = "timesync"))]
//! Fail the new record/key allocations with the real global allocator.
use sedsnet::timesync::{NetworkClock, PartialNetworkTime};
use std::alloc::{GlobalAlloc, Layout, System};
use std::cell::Cell;
struct Allocator;
thread_local! {
    static FAIL: Cell<Option<usize>> = const { Cell::new(None) };
    static COUNT: Cell<usize> = const { Cell::new(0) };
    static LIVE: Cell<isize> = const { Cell::new(0) };
}
#[global_allocator]
static ALLOCATOR: Allocator = Allocator;
unsafe impl GlobalAlloc for Allocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        let deny = FAIL
            .try_with(|target| {
                let Some(target) = target.get() else {
                    return false;
                };
                COUNT.with(|count| {
                    count.set(count.get() + 1);
                    count.get() == target
                })
            })
            .unwrap_or(false);
        if deny {
            return std::ptr::null_mut();
        }
        let ptr = unsafe { System.alloc(layout) };
        if !ptr.is_null() {
            let _ = FAIL.try_with(|target| {
                if target.get().is_some() {
                    LIVE.with(|live| live.set(live.get() + layout.size() as isize));
                }
            });
        }
        ptr
    }
    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        let _ = FAIL.try_with(|target| {
            if target.get().is_some() {
                LIVE.with(|live| live.set(live.get() - layout.size() as isize));
            }
        });
        unsafe { System.dealloc(ptr, layout) };
    }
}
fn watch(target: usize) {
    COUNT.with(|v| v.set(0));
    LIVE.with(|v| v.set(0));
    FAIL.with(|v| v.set(Some(target)));
}
fn finish() -> (usize, isize) {
    FAIL.with(|v| v.set(None));
    (COUNT.with(Cell::get), LIVE.with(Cell::get))
}
#[test]
fn null_record_or_key_allocation_keeps_old_clock_and_releases_staging() {
    for target in 1..=2 {
        let mut clock = NetworkClock::default();
        clock
            .try_update_source(
                "BASE",
                10,
                PartialNetworkTime::from_unix_ms(100_000),
                0,
                0,
                None,
            )
            .unwrap();
        let before = clock.current_time(0);
        watch(target);
        let result = clock.try_update_source(
            "NEW",
            0,
            PartialNetworkTime::from_unix_ms(200_000),
            0,
            0,
            None,
        );
        let (count, live) = finish();
        assert!(matches!(
            result,
            Err(sedsnet::TelemetryError::Io("memory pressure"))
        ));
        assert_eq!(count, target);
        assert_eq!(live, 0, "staged storage must be freed");
        assert_eq!(clock.current_time(0), before);
        clock.remove_source("BASE");
        assert_eq!(clock.current_time(0), None);
        clock
            .try_update_source(
                "NEW",
                0,
                PartialNetworkTime::from_unix_ms(200_000),
                0,
                0,
                None,
            )
            .unwrap();
        assert_eq!(clock.current_time(0).unwrap().unix_time_ms, Some(200_000));
    }
}
#[test]
fn known_clock_source_refresh_needs_no_record_or_key_allocation() {
    let mut clock = NetworkClock::default();
    clock
        .try_update_source(
            "BASE",
            10,
            PartialNetworkTime::from_unix_ms(100_000),
            0,
            0,
            None,
        )
        .unwrap();
    watch(1);
    let result = clock.try_update_source(
        "BASE",
        0,
        PartialNetworkTime::from_unix_ms(200_000),
        0,
        0,
        None,
    );
    let (count, live) = finish();
    assert!(result.is_ok());
    assert_eq!((count, live), (0, 0));
    assert_eq!(clock.current_time(0).unwrap().unix_time_ms, Some(200_000));
}