Skip to main content

qualia_core_db/net/peer/fabric/
intent.rs

1//! Connection intent: who, why, under which constraints. Not reachability.
2
3use crate::net::peer::connectivity::policy::Disclosure;
4use crate::net::peer::runtime::ResourceBudget;
5use crate::q_hash;
6
7pub type PeerId = [u8; 32];
8
9#[repr(u8)]
10#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11pub enum PurposeClass {
12    Ordinary = 1,
13    Clinical = 2,
14    Infrastructure = 3,
15}
16
17#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18pub struct Purpose {
19    pub iri_hash: u64,
20    pub class: PurposeClass,
21}
22
23impl Purpose {
24    /// `Purpose::ordinary`.
25    pub const fn ordinary() -> Self {
26        Self {
27            iri_hash: q_hash("q42:purpose/ordinary"),
28            class: PurposeClass::Ordinary,
29        }
30    }
31
32    /// `Purpose::clinical`.
33    pub const fn clinical() -> Self {
34        Self {
35            iri_hash: q_hash("q42:purpose/clinical"),
36            class: PurposeClass::Clinical,
37        }
38    }
39}
40
41/// Disclosure plus whether public DHT publication is admitted for this call.
42#[derive(Debug, Clone, Copy, PartialEq, Eq)]
43pub struct ProtectionPolicy {
44    pub disclosure: Disclosure,
45    pub require_e2e_session: bool,
46    pub public_dht: bool,
47}
48
49impl ProtectionPolicy {
50    pub const ORDINARY: Self = Self {
51        disclosure: Disclosure::DirectPermitted,
52        require_e2e_session: true,
53        public_dht: false,
54    };
55
56    pub const RELAY_ONLY: Self = Self {
57        disclosure: Disclosure::ApprovedRelaysOnly,
58        require_e2e_session: true,
59        public_dht: false,
60    };
61
62    pub const ISOLATED: Self = Self {
63        disclosure: Disclosure::Isolated,
64        require_e2e_session: true,
65        public_dht: false,
66    };
67}
68
69#[derive(Debug, Clone, Copy, PartialEq, Eq)]
70pub struct ConnectionIntent {
71    pub peer: PeerId,
72    pub purpose: Purpose,
73    pub authority: u64,
74    pub protection: ProtectionPolicy,
75    pub deadline_ms: u64,
76    pub budget: ResourceBudget,
77    pub created_ms: u64,
78}
79
80impl ConnectionIntent {
81    /// Creates a default `ConnectionIntent`.
82    pub const fn new(
83        peer: PeerId,
84        purpose: Purpose,
85        protection: ProtectionPolicy,
86        budget: ResourceBudget,
87        now_ms: u64,
88        deadline_ms: u64,
89    ) -> Self {
90        Self {
91            peer,
92            purpose,
93            authority: 0,
94            protection,
95            deadline_ms,
96            budget,
97            created_ms: now_ms,
98        }
99    }
100
101    /// `ConnectionIntent::expired`.
102    pub const fn expired(&self, now_ms: u64) -> bool {
103        now_ms >= self.deadline_ms
104    }
105}
106
107#[cfg(test)]
108mod tests {
109    use super::*;
110
111    #[test]
112    fn ordinary_does_not_enable_public_dht() {
113        assert!(!ProtectionPolicy::ORDINARY.public_dht);
114        assert!(!ProtectionPolicy::RELAY_ONLY.public_dht);
115        assert_ne!(Purpose::ordinary().iri_hash, Purpose::clinical().iri_hash);
116    }
117}