dtn7 0.21.0

Rust delay-tolerant-networking daemon and CLI tools implementing Bundle Protocol Version 7 (RFC9171)
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

pub mod epidemic;
pub mod erouting;
pub mod external;
pub mod flooding;
pub mod sink;
pub mod sprayandwait;
pub mod static_routing;

use crate::cla::ClaSenderTask;
use crate::core::bundlepack::BundlePack;
use crate::BundleID;
use async_trait::async_trait;
use bp7::Bundle;
use bp7::EndpointID;
use enum_dispatch::enum_dispatch;
use epidemic::EpidemicRoutingAgent;
use external::ExternalRoutingAgent;
use flooding::FloodingRoutingAgent;
use sink::SinkRoutingAgent;
use sprayandwait::SprayAndWaitRoutingAgent;
use static_routing::StaticRoutingAgent;
use std::fmt::Debug;
use std::fmt::Display;
use tokio::sync::{mpsc, oneshot};

#[derive(Debug)]
pub enum RoutingNotifcation {
    SendingFailed(BundleID, String),
    SendingSucceeded(BundleID, String),
    IncomingBundle(Bundle),
    IncomingBundleWithoutPreviousNode(BundleID, String),
    EncounteredPeer(EndpointID),
    DroppedPeer(EndpointID),
}

#[enum_dispatch]
#[derive(Debug)]
pub enum RoutingAgentsEnum {
    EpidemicRoutingAgent,
    FloodingRoutingAgent,
    SinkRoutingAgent,
    ExternalRoutingAgent,
    SprayAndWaitRoutingAgent,
    StaticRoutingAgent,
}

impl Display for RoutingAgentsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

pub enum RoutingCmd {
    SenderForBundle(BundlePack, oneshot::Sender<(Vec<ClaSenderTask>, bool)>),
    Notify(RoutingNotifcation),
    Command(String),
    GetData(String, oneshot::Sender<String>),
    Shutdown,
}

/*
impl std::fmt::Display for RoutingAgentsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}
*/

#[async_trait]
#[enum_dispatch(RoutingAgentsEnum)]
pub trait RoutingAgent: Debug + Display {
    fn channel(&self) -> mpsc::Sender<RoutingCmd>;
}

pub fn routing_algorithms() -> Vec<&'static str> {
    vec![
        "epidemic",
        "flooding",
        "sink",
        "external",
        "sprayandwait",
        "static",
    ]
}

pub fn routing_options() -> Vec<&'static str> {
    vec!["sprayandwait.num_copies=<int>", "static.routes=<file>"]
}

pub fn new(routingagent: &str) -> RoutingAgentsEnum {
    match routingagent {
        "flooding" => FloodingRoutingAgent::new().into(),
        "epidemic" => EpidemicRoutingAgent::new().into(),
        "sink" => SinkRoutingAgent::new().into(),
        "static" => StaticRoutingAgent::new().into(),
        "external" => ExternalRoutingAgent::new().into(),
        "sprayandwait" => SprayAndWaitRoutingAgent::new().into(),
        _ => panic!("Unknown routing agent {}", routingagent),
    }
}