prns-runtime-tokio 0.3.6

Tokio host runtime for Personal Reticulum
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

use super::*;
use std::time::Duration;
use tokio::sync::mpsc::UnboundedSender;
#[cfg(feature = "runtime-metrics")]
use tokio::sync::oneshot;

use crate::engine::test_support::{
    bytes_from_hex, pin_transport_id, TestStorageLayout, RNS_1_4_2_ANNOUNCE,
    RNS_1_4_2_RATCHETED_ANNOUNCE, TEST_TRANSPORT_ID,
};
#[cfg(feature = "runtime-metrics")]
use crate::engine::AnnounceOrigin;
use crate::engine::{Departure, IssuedCommand, RouteRemovalCause};
use crate::interfaces::{
    AnnounceBandwidthCap, BitrateBps, EgressCapability, IngressCapability, InterfaceCapabilities,
    InterfaceMode, TransportCapability,
};
use crate::manifold::interface_seam::{Interface, InterfaceSeam, MAX_WIRE_FRAME_LEN};
#[cfg(feature = "runtime-metrics")]
use crate::runtime::AnnounceEgressOutcome;
use crate::runtime::{DropRouteOutcome, PrnsNodeHandle, RoutingControl};
use crate::wire::{DestinationHash, PacketType, WirePacketHeader};

use tokio::sync::mpsc;

fn descriptor(id: InterfaceId) -> InterfaceDescriptor {
    InterfaceDescriptor {
        id,
        capabilities: InterfaceCapabilities {
            ingress: IngressCapability::Enabled,
            egress: EgressCapability::Enabled(TransportCapability::CrossInterfaceOnly),
        },
        mode: InterfaceMode::Full,
        gravity: crate::interfaces::InterfaceGravity::ZERO,
        bitrate: BitrateBps::guess(1_000_000_000),
        hardware_mtu: None,
        announce_rate_limit: None,
        announce_bandwidth_cap: AnnounceBandwidthCap::Unlimited,
        airtime_duty_cycle: None,
        common: crate::interfaces::InterfaceCommonPolicy::RNS_DEFAULT,
    }
}

struct LoopbackInterface {
    descriptor: InterfaceDescriptor,
    wire_in: UnboundedReceiver<std::vec::Vec<u8>>,
    wire_out: UnboundedSender<std::vec::Vec<u8>>,
}

impl Interface for LoopbackInterface {
    const HW_MTU: usize = crate::wire::BROADCAST_MTU;
    const KIND: crate::interfaces::InterfaceKind = crate::interfaces::InterfaceKind::Loopback;

    fn descriptor(&self) -> InterfaceDescriptor {
        self.descriptor
    }

    fn channel_tag(&self) -> &[u8] {
        self.descriptor.id.as_bytes()
    }

    async fn run<Seam: InterfaceSeam>(mut self, mut seam: Seam) {
        loop {
            tokio::select! {
                received = self.wire_in.recv() => {
                    match received {
                        Some(bytes) => seam.next_inbound(&bytes).await,
                        None => return,
                    }
                }
                outbound = seam.next_outbound() => {
                    let _ = self.wire_out.send(outbound.to_vec());
                }
            }
        }
    }
}

mod announces;
mod interfaces;
mod links;
mod routes;
mod transport;