feat: added CCSDS 734.20-O-1 Bundle Protocol Orange Book compliant management information

gh0st42 · gh0st42 · commit 9dd2f7b02a64 · 2025-07-05T08:50:48.000+02:00
diff --git a/core/dtn7/src/core/mod.rs b/core/dtn7/src/core/mod.rs
@@ -3,14 +3,18 @@ pub mod bundlepack;
 pub mod helpers;
 pub mod peer;
 pub mod processing;
+pub mod stats;
 pub mod store;
 
 use crate::cla::ConvergenceLayerAgent;
 use crate::core::bundlepack::Constraint;
 pub use crate::core::peer::{DtnPeer, PeerType};
+use crate::core::stats::{NodeStats, RegistrationInformation};
 use crate::core::store::BundleStore;
 use crate::routing::RoutingAgentsEnum;
-use crate::{routing_notify, store_delete_expired, store_get_bundle, store_get_metadata, CLAS};
+use crate::{
+    routing_notify, store_delete_expired, store_get_bundle, store_get_metadata, CLAS, DTNCORE,
+};
 pub use crate::{store_has_item, store_push_bundle};
 use crate::{RoutingNotifcation, CONFIG};
 use crate::{PEERS, STORE};
@@ -36,19 +40,49 @@ pub struct DtnStatistics {
     pub delivered: u64,
     pub failed: u64,
     pub broken: u64,
+    pub node: NodeStats,
 }
 
 impl DtnStatistics {
     pub fn new() -> DtnStatistics {
+        let nodestats = NodeStats::new();
         DtnStatistics {
             incoming: 0,
             dups: 0,
             outgoing: 0,
             delivered: 0,
             failed: 0,
             broken: 0,
+            node: nodestats,
         }
     }
+    pub fn update_node_stats(&mut self) {
+        println!("Updating node stats");
+        self.node.error_info.failed_forwards_bundle_count = self.failed;
+        self.node.registrations.clear();
+        let eids = (*DTNCORE.lock()).eids();
+        for eid in eids {
+            if let Some(aa) =
+                (*DTNCORE.lock()).get_endpoint(&EndpointID::try_from(eid.clone()).unwrap())
+            {
+                let singleton = !aa.eid().is_non_singleton();
+                let registration = RegistrationInformation {
+                    eid: eid.clone(),
+                    active: aa.delivery_addr().is_some(),
+                    singleton: singleton,
+                    default_failure_action: stats::FailureAction::Defer,
+                };
+                self.node.registrations.push(registration);
+            }
+        }
+        self.node.bundles.bundles_stored = (*STORE.lock()).count();
+        self.node.bundles.forward_pending_bundle_count = (*STORE.lock()).forwarding().len() as u64;
+        // TODO get correct number of bundles with dispatch pending
+        // self.node.bundles.dispatch_pending_bundle_count = (*STORE.lock()).pending().len() as u64;
+        // TODO get correct number of bundles with reassembly pending
+        // self.node.bundles.reassembly_pending_bundle_count =
+        //     (*STORE.lock()).reassembly_pending().len() as u64;
+    }
 }
 #[derive(Debug)]
 pub struct DtnCore {
diff --git a/core/dtn7/src/core/stats.rs b/core/dtn7/src/core/stats.rs
@@ -0,0 +1,86 @@
+use serde::{Deserialize, Serialize};
+
+use crate::CONFIG;
+
+/// CCSDS 734.20-O-1 Bundle Protocol Orange Book - Annex C Managed Information
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct NodeStats {
+    pub registrations: Vec<RegistrationInformation>,
+    pub node_state: NodeStateInformation,
+    pub error_info: ErrorInformation,
+    pub bundles: BundleStateInformation,
+}
+
+impl NodeStats {
+    pub fn new() -> Self {
+        let mut mib = NodeStats {
+            registrations: Vec::new(),
+            node_state: NodeStateInformation::default(),
+            error_info: ErrorInformation::default(),
+            bundles: BundleStateInformation::default(),
+        };
+        mib.node_state.administrative_eid = CONFIG.lock().host_eid.clone().to_string();
+        mib.node_state.bp_versions = vec![7]; // Bundle Protocol version - fixed to 7 for now
+
+        // mib.error_info.failed_forwards_bundle_count = (*STATS.lock()).failed;
+        return mib;
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum FailureAction {
+    Abandon = 0,
+    Defer = 1,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+/// CCSDS Bundle Protocol Orange Book - Annex C Bundle State Information Table C-1
+pub struct BundleStateInformation {
+    pub forward_pending_bundle_count: u64,
+    pub dispatch_pending_bundle_count: u64,
+    pub reassembly_pending_bundle_count: u64,
+    pub bundles_created: u64,
+    pub bundles_stored: u64,
+    pub bundles_fragmented: u64,
+    pub fragments_created: u64,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+/// CCSDS Bundle Protocol Orange Book - Annex C Error and Reporting Information Table C-2
+pub struct ErrorInformation {
+    /// The number of bundles/bytes that have experienced a forwarding failure at this node.
+    pub failed_forwards_bundle_count: u64,
+    /// The number of bundles/bytes whose delivery has been abandoned at this node.
+    pub abandoned_delivery_bundle_count: u64,
+    /// The number of bundles/bytes discarded at this node.
+    pub discarded_bundle_count: u64,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+/// CCSDS Bundle Protocol Orange Book - Annex C Node State Information Table C-4
+pub struct NodeStateInformation {
+    /// The EID that uniquely and permanently identifies this node’s administrative endpoint.
+    pub administrative_eid: String,
+    /// The number(s) of the version(s) of the BP supported at this node.
+    pub bp_versions: Vec<u8>, // Bundle Protocol version - fixed to 7 for now
+    /// The number of kilobytes of storage allocated to bundle retention at this node and not currently occupied by bundles.
+    pub storage_available: u64,
+    /// The most recent time at which the operation of this node was started or restarted.
+    pub last_up_time: u64,
+    /// The number of different endpoints in which this node has been registered since it was started or restarted.
+    pub registration_count: u64, // optional
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+/// CCSDS Bundle Protocol Orange Book - Annex C Registration Information Table C-4
+pub struct RegistrationInformation {
+    /// The EID of the endpoint for which this registration applies.
+    pub eid: String,
+    /// The current state of the EID, at the time the managed information was queried. True - ACTIVE, False - PASSIVE
+    pub active: bool,
+    /// Whether this EID is a singleton EID.
+    pub singleton: bool,
+    /// The default action to be taken when delivery is not possible.
+    /// One of: ABANDON or DEFER.
+    pub default_failure_action: FailureAction,
+}
diff --git a/core/dtn7/src/dtnd/httpd.rs b/core/dtn7/src/dtnd/httpd.rs
@@ -301,6 +301,7 @@ async fn status_peers() -> String {
 }
 //#[get("/status/info")]
 async fn status_info() -> String {
+    STATS.lock().update_node_stats();
     let stats = &(*STATS.lock()).clone();
     serde_json::to_string_pretty(&stats).unwrap()
 }
@@ -427,7 +428,9 @@ async fn insert_get(extract::RawQuery(query): extract::RawQuery) -> Result<Strin
                     bndl.id(),
                     bndl.primary.destination
                 );
-
+                if bndl.primary.source.node() == (*CONFIG.lock()).host_eid.node() {
+                    STATS.lock().node.bundles.bundles_created += 1;
+                }
                 crate::core::processing::send_bundle(bndl).await;
                 Ok(format!("Sent {} bytes", b_len))
             } else {
@@ -453,6 +456,10 @@ async fn insert_post(body: bytes::Bytes) -> Result<String, (StatusCode, &'static
             bndl.primary.destination
         );
 
+        if bndl.primary.source.node() == (*CONFIG.lock()).host_eid.node() {
+            STATS.lock().node.bundles.bundles_created += 1;
+        }
+
         crate::core::processing::send_bundle(bndl).await;
         Ok(format!("Sent {} bytes", b_len))
     } else {
@@ -525,6 +532,7 @@ async fn send_post(
     );
     let bid = bndl.id();
     crate::core::processing::send_bundle(bndl).await;
+    STATS.lock().node.bundles.bundles_created += 1;
     Ok(format!("Sent ADU in bundle {} with {} bytes", bid, b_len))
 }
 
diff --git a/core/dtn7/src/dtnd/ws.rs b/core/dtn7/src/dtnd/ws.rs
@@ -1,6 +1,7 @@
 use crate::core::application_agent::ApplicationAgent;
 use crate::CONFIG;
 use crate::DTNCORE;
+use crate::STATS;
 
 use anyhow::{bail, Result};
 use axum::extract::ws::{Message, WebSocket};
@@ -353,6 +354,7 @@ impl WsAASession {
                                 async move { crate::core::processing::send_bundle(bndl).await },
                             );
                             debug!("sent bundle");
+                            STATS.lock().node.bundles.bundles_created += 1;
 
                             ws_reply_text!(
                                 socket,
@@ -422,6 +424,8 @@ impl WsAASession {
                                 async move { crate::core::processing::send_bundle(bndl).await },
                             );
                             debug!("sent bundle");
+                            STATS.lock().node.bundles.bundles_created += 1;
+
                             //crate::core::processing::send_through_task(bndl);
                             ws_reply_text!(
                                 socket,
