prns-core 0.3.4

Pure Reticulum engine and wire contract for Personal Reticulum
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

use crate::engine::InstantMillis;
use crate::interfaces::InterfaceId;
use crate::wire::DestinationHash;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ScheduledAnnounce {
    pub destination: DestinationHash,
    pub due_at: InstantMillis,
    pub source_interface: InterfaceId,
    pub hops: u8,
    pub our_emission_count: u8,
    pub peer_emission_count: u8,
    pub directed_to: Option<InterfaceId>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ScheduleRejection {
    /// A bounded queue is full. Existing entries are left unchanged.
    QueueFull,
}

/// The result of scheduling one destination without changing queue admission policy.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[must_use]
pub enum ScheduleOutcome {
    Inserted,
    Updated,
    Rejected(ScheduleRejection),
}

/// Work removed for one destination from the active queue and its parked flood store.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[must_use]
pub struct ScheduleCancellation {
    pub active_removed: bool,
    pub parked_removed: bool,
}

impl ScheduleCancellation {
    pub const NOT_FOUND: Self = Self {
        active_removed: false,
        parked_removed: false,
    };

    pub const fn removed_any(self) -> bool {
        self.active_removed || self.parked_removed
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EchoOutcome {
    NoPendingEntry,
    PeerEmissionCounted,
    RetransmitCancelled,
    HopsUnrelated,
}

pub trait ScheduledAnnounceQueue {
    fn scheduled_count(&self) -> usize;

    fn schedule(
        &mut self,
        destination: DestinationHash,
        due_at: InstantMillis,
        source_interface: InterfaceId,
        hops: u8,
    ) -> ScheduleOutcome;

    fn schedule_directed(
        &mut self,
        destination: DestinationHash,
        due_at: InstantMillis,
        target: InterfaceId,
        hops: u8,
    ) -> ScheduleOutcome;

    fn schedule_shared_client(
        &mut self,
        destination: DestinationHash,
        due_at: InstantMillis,
        source_interface: InterfaceId,
        hops: u8,
    ) -> ScheduleOutcome;

    fn schedule_directed_shared_client(
        &mut self,
        destination: DestinationHash,
        due_at: InstantMillis,
        target: InterfaceId,
        hops: u8,
    ) -> ScheduleOutcome;

    fn cancel(&mut self, destination: &DestinationHash) -> ScheduleCancellation;

    fn drain_due(&mut self, now: InstantMillis) -> usize;

    fn advance_due_retransmits(
        &mut self,
        now: InstantMillis,
        interval_ms: u64,
        max_our_emission_count: u8,
    ) -> usize;

    fn absorb_echo(
        &mut self,
        destination: &DestinationHash,
        received_hops: u8,
        now: InstantMillis,
        max_peer_emission_count: u8,
    ) -> EchoOutcome;

    fn earliest_due_at(&self) -> Option<InstantMillis>;

    fn iter(&self) -> impl Iterator<Item = ScheduledAnnounce> + '_;
}