Skip to main content

qualia_core_db/net/peer/runtime/
resources.rs

1//! Admission helpers: essential reclaim floor and transient unknown-sender charge.
2//!
3//! Unknown senders charge the ledger transient pool first (`verified_peer = false`).
4//! Data-class work cannot consume the essential floor reserved for cancel,
5//! completion, and reclamation progress.
6
7use crate::net::qdnf::errors::QdnfError;
8
9use super::ledger::{ReservationLedger, ResourceBudget};
10use super::scheduler::WorkClass;
11
12pub struct ResourceGovernor {
13    essential_floor_bytes: u64,
14}
15
16impl ResourceGovernor {
17    /// Creates a default `ResourceGovernor`.
18    pub const fn new(essential_floor_bytes: u64) -> Self {
19        Self {
20            essential_floor_bytes,
21        }
22    }
23
24    /// Charge an unknown sender against the transient pool (not a verified peer).
25    pub fn charge_unknown(
26        ledger: &mut ReservationLedger,
27        add: ResourceBudget,
28    ) -> Result<crate::net::peer::runtime::ReservationHandle, QdnfError> {
29        ledger.reserve(add, false)
30    }
31
32    /// Admit `add` then reserve it. Control may use the essential floor; other
33    /// classes must leave that floor free on the host.
34    pub fn admit_and_reserve(
35        &self,
36        ledger: &mut ReservationLedger,
37        add: ResourceBudget,
38        class: WorkClass,
39        verified_peer: bool,
40    ) -> Result<crate::net::peer::runtime::ReservationHandle, QdnfError> {
41        if class != WorkClass::Control {
42            let remaining = ledger.host_remaining_bytes();
43            if remaining.saturating_sub(add.bytes) < self.essential_floor_bytes {
44                return Err(QdnfError::BudgetExhausted);
45            }
46        }
47        ledger.reserve(add, verified_peer)
48    }
49}
50
51impl Default for ResourceGovernor {
52    fn default() -> Self {
53        Self::new(0)
54    }
55}
56
57#[cfg(test)]
58mod tests {
59    use super::*;
60
61    fn ledger(bytes: u64) -> ReservationLedger {
62        let cap = ResourceBudget {
63            bytes,
64            work: 16,
65            io: 16,
66        };
67        ReservationLedger::new(cap, cap, cap, cap, cap)
68    }
69
70    #[test]
71    fn unknown_sender_charges_transient_pool() {
72        let mut ledger = ledger(100);
73        let add = ResourceBudget {
74            bytes: 60,
75            work: 1,
76            io: 1,
77        };
78        ResourceGovernor::charge_unknown(&mut ledger, add).unwrap();
79        assert_eq!(ledger.transient_used().bytes, 60);
80        assert_eq!(
81            ResourceGovernor::charge_unknown(&mut ledger, add),
82            Err(QdnfError::BudgetExhausted)
83        );
84    }
85
86    #[test]
87    fn data_cannot_consume_essential_floor() {
88        let mut ledger = ledger(100);
89        let gov = ResourceGovernor::new(20);
90        let add = ResourceBudget {
91            bytes: 90,
92            work: 1,
93            io: 1,
94        };
95        assert_eq!(
96            gov.admit_and_reserve(&mut ledger, add, WorkClass::Background, true),
97            Err(QdnfError::BudgetExhausted)
98        );
99        gov.admit_and_reserve(&mut ledger, add, WorkClass::Control, true)
100            .unwrap();
101        assert_eq!(ledger.used().host.bytes, 90);
102    }
103}