lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

status.rs (5651B)

      1 use crate::{
      2     TransportId,
      3     capability::{Availability, Maturity, SinkCapabilities, SourceCapabilities},
      4 };
      5 use alloc::string::String;
      6 use radroots_protocol::capability::v1::TransportDescriptor;
      7 
      8 /// Runtime state shared by source and sink capability reports.
      9 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
     10 #[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
     11 #[derive(Clone, Debug, Eq, PartialEq)]
     12 struct RuntimeStatus {
     13     transport_id: TransportId,
     14     configured: bool,
     15     maturity: Maturity,
     16     availability: Availability,
     17     message: String,
     18 }
     19 
     20 impl RuntimeStatus {
     21     fn new(
     22         transport_id: TransportId,
     23         configured: bool,
     24         maturity: Maturity,
     25         availability: Availability,
     26         message: impl Into<String>,
     27     ) -> Self {
     28         Self {
     29             transport_id,
     30             configured,
     31             maturity,
     32             availability,
     33             message: message.into(),
     34         }
     35     }
     36 
     37     const fn transport_id(&self) -> TransportId {
     38         self.transport_id
     39     }
     40 
     41     const fn is_configured(&self) -> bool {
     42         self.configured
     43     }
     44 
     45     const fn maturity(&self) -> Maturity {
     46         self.maturity
     47     }
     48 
     49     const fn availability(&self) -> Availability {
     50         self.availability
     51     }
     52 
     53     fn message(&self) -> &str {
     54         self.message.as_str()
     55     }
     56 }
     57 
     58 /// Current state and operations supported by an event source.
     59 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
     60 #[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
     61 #[derive(Clone, Debug, Eq, PartialEq)]
     62 pub struct SourceStatus {
     63     #[cfg_attr(feature = "serde", serde(flatten))]
     64     status: RuntimeStatus,
     65     capabilities: SourceCapabilities,
     66 }
     67 
     68 impl SourceStatus {
     69     /// Creates a source-specific status report.
     70     pub fn new(
     71         transport_id: TransportId,
     72         configured: bool,
     73         maturity: Maturity,
     74         availability: Availability,
     75         capabilities: SourceCapabilities,
     76         message: impl Into<String>,
     77     ) -> Self {
     78         Self {
     79             status: RuntimeStatus::new(transport_id, configured, maturity, availability, message),
     80             capabilities,
     81         }
     82     }
     83 
     84     /// Builds source status from the versioned passive capability catalog.
     85     pub fn from_descriptor(
     86         descriptor: &TransportDescriptor,
     87         configured: bool,
     88         message: impl Into<String>,
     89     ) -> Self {
     90         Self::new(
     91             descriptor.kind.into(),
     92             configured,
     93             descriptor.maturity.into(),
     94             descriptor.availability.into(),
     95             SourceCapabilities::from(descriptor),
     96             message,
     97         )
     98     }
     99 
    100     /// Returns the extensible transport identity.
    101     pub const fn transport_id(&self) -> TransportId {
    102         self.status.transport_id()
    103     }
    104 
    105     /// Whether the host has configured this source.
    106     pub const fn is_configured(&self) -> bool {
    107         self.status.is_configured()
    108     }
    109 
    110     /// Returns the source capability's product maturity.
    111     pub const fn maturity(&self) -> Maturity {
    112         self.status.maturity()
    113     }
    114 
    115     /// Returns current source availability.
    116     pub const fn availability(&self) -> Availability {
    117         self.status.availability()
    118     }
    119 
    120     /// Returns the operator-facing status detail.
    121     pub fn message(&self) -> &str {
    122         self.status.message()
    123     }
    124 
    125     /// Returns supported source operations.
    126     pub const fn capabilities(&self) -> SourceCapabilities {
    127         self.capabilities
    128     }
    129 }
    130 
    131 /// Current state and operations supported by an event sink.
    132 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    133 #[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
    134 #[derive(Clone, Debug, Eq, PartialEq)]
    135 pub struct SinkStatus {
    136     #[cfg_attr(feature = "serde", serde(flatten))]
    137     status: RuntimeStatus,
    138     capabilities: SinkCapabilities,
    139 }
    140 
    141 impl SinkStatus {
    142     /// Creates a sink-specific status report.
    143     pub fn new(
    144         transport_id: TransportId,
    145         configured: bool,
    146         maturity: Maturity,
    147         availability: Availability,
    148         capabilities: SinkCapabilities,
    149         message: impl Into<String>,
    150     ) -> Self {
    151         Self {
    152             status: RuntimeStatus::new(transport_id, configured, maturity, availability, message),
    153             capabilities,
    154         }
    155     }
    156 
    157     /// Builds sink status from the versioned passive capability catalog.
    158     pub fn from_descriptor(
    159         descriptor: &TransportDescriptor,
    160         configured: bool,
    161         message: impl Into<String>,
    162     ) -> Self {
    163         Self::new(
    164             descriptor.kind.into(),
    165             configured,
    166             descriptor.maturity.into(),
    167             descriptor.availability.into(),
    168             SinkCapabilities::from(descriptor),
    169             message,
    170         )
    171     }
    172 
    173     /// Returns the extensible transport identity.
    174     pub const fn transport_id(&self) -> TransportId {
    175         self.status.transport_id()
    176     }
    177 
    178     /// Whether the host has configured this sink.
    179     pub const fn is_configured(&self) -> bool {
    180         self.status.is_configured()
    181     }
    182 
    183     /// Returns the sink capability's product maturity.
    184     pub const fn maturity(&self) -> Maturity {
    185         self.status.maturity()
    186     }
    187 
    188     /// Returns current sink availability.
    189     pub const fn availability(&self) -> Availability {
    190         self.status.availability()
    191     }
    192 
    193     /// Returns the operator-facing status detail.
    194     pub fn message(&self) -> &str {
    195         self.status.message()
    196     }
    197 
    198     /// Returns supported sink operations.
    199     pub const fn capabilities(&self) -> SinkCapabilities {
    200         self.capabilities
    201     }
    202 }