sdtn 0.1.4

SpaceArth DTN - A Rust-based implementation of Delay Tolerant Networking (DTN) for resilient communication
Documentation 
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

use crate::bpv7::EndpointId;
use crate::cla::peer::ClaPeer;
use crate::store::bundle_descriptor::BundleDescriptor;
use async_trait::async_trait;
use std::collections::HashMap;

/// Represents a route entry in the routing table
#[derive(Debug, Clone)]
pub struct RouteEntry {
    pub destination: EndpointId,
    pub next_hop: EndpointId,
    pub cla_type: String,
    pub cost: u32,
    pub is_active: bool,
}

/// Routing table that maps destinations to next hops and CLAs
#[derive(Debug, Default)]
pub struct RoutingTable {
    routes: HashMap<EndpointId, Vec<RouteEntry>>,
}

impl RoutingTable {
    pub fn new() -> Self {
        Self {
            routes: HashMap::new(),
        }
    }

    pub fn add_route(&mut self, entry: RouteEntry) {
        self.routes
            .entry(entry.destination.clone())
            .or_default()
            .push(entry);
    }

    pub fn get_routes_for_destination(&self, destination: &EndpointId) -> Vec<&RouteEntry> {
        self.routes
            .get(destination)
            .map(|routes| routes.iter().filter(|r| r.is_active).collect())
            .unwrap_or_default()
    }

    pub fn get_all_routes(&self) -> Vec<&RouteEntry> {
        self.routes
            .values()
            .flatten()
            .filter(|r| r.is_active)
            .collect()
    }

    /// Find the best route for a destination
    pub fn find_best_route(&self, destination: &EndpointId) -> Option<&RouteEntry> {
        self.get_routes_for_destination(destination)
            .into_iter()
            .min_by_key(|route| route.cost)
    }
}

#[async_trait]
pub trait RoutingAlgorithm: Send + Sync {
    fn notify_new_bundle(&mut self, descriptor: &BundleDescriptor);
    fn select_peers_for_forwarding<'a>(
        &self,
        descriptor: &BundleDescriptor,
        all_peers: &'a [Box<dyn ClaPeer>],
    ) -> Vec<&'a dyn ClaPeer>;

    /// Async version that checks connectivity before selecting peers
    async fn select_peers_for_forwarding_async<'a>(
        &self,
        descriptor: &BundleDescriptor,
        all_peers: &'a [Box<dyn ClaPeer>],
    ) -> Vec<&'a dyn ClaPeer> {
        // Default implementation falls back to sync version
        self.select_peers_for_forwarding(descriptor, all_peers)
    }

    /// New method: select routes based on routing table
    fn select_routes_for_forwarding(
        &self,
        descriptor: &BundleDescriptor,
        routing_table: &RoutingTable,
    ) -> Vec<RouteEntry>;
}

#[derive(Debug)]
pub enum RoutingAlgorithmType {
    Epidemic,
    Prophet,
    // SprayAndWait,
}

pub struct RoutingConfig {
    pub algorithm_type: RoutingAlgorithmType,
}

impl RoutingConfig {
    pub fn new(algorithm_type: RoutingAlgorithmType) -> Self {
        Self { algorithm_type }
    }

    pub fn create_algorithm(&self) -> Box<dyn RoutingAlgorithm> {
        match self.algorithm_type {
            RoutingAlgorithmType::Epidemic => Box::new(crate::routing::epidemic::EpidemicRouting),
            RoutingAlgorithmType::Prophet => {
                // TODO: Implement Prophet routing algorithm
                // For now, fall back to epidemic
                eprintln!("Warning: Prophet routing not yet implemented, falling back to epidemic");
                Box::new(crate::routing::epidemic::EpidemicRouting)
            }
        }
    }
}