veilid-core 0.5.3

Core library used to create a Veilid node and operate it as part of an application
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

use super::*;

#[derive(Clone, Debug)]
pub struct ConnectionHandle {
    connection_id: NetworkConnectionId,
    flow: Flow,
    channel: flume::Sender<(Option<Id>, Bytes)>,
}

#[derive(Debug)]
pub enum ConnectionHandleSendResult {
    Sent,
    NotSent(Bytes),
}

impl ConnectionHandle {
    pub(super) fn new(
        connection_id: NetworkConnectionId,
        flow: Flow,
        channel: flume::Sender<(Option<Id>, Bytes)>,
    ) -> Self {
        Self {
            connection_id,
            flow,
            channel,
        }
    }

    #[expect(dead_code)]
    pub fn connection_id(&self) -> NetworkConnectionId {
        self.connection_id
    }

    #[expect(dead_code)]
    pub fn flow(&self) -> Flow {
        self.flow
    }

    pub fn unique_flow(&self) -> UniqueFlow {
        UniqueFlow {
            flow: self.flow,
            connection_id: Some(self.connection_id),
        }
    }

    // #[cfg_attr(feature = "instrument", instrument(level="trace", target="net", skip(self, message), fields(message.len = message.len())))]
    // pub fn send(&self, message: Bytes) -> ConnectionHandleSendResult {
    //     match self.channel.send((Span::current().id(), message)) {
    //         Ok(()) => ConnectionHandleSendResult::Sent,
    //         Err(e) => ConnectionHandleSendResult::NotSent(e.0 .1),
    //     }
    // }

    #[cfg_attr(feature = "instrument", instrument(level="trace", target="net", skip(self, message), fields(message.len = message.len())))]
    pub async fn send_async(&self, message: Bytes) -> ConnectionHandleSendResult {
        match self
            .channel
            .send_async((Span::current().id(), message))
            .await
        {
            Ok(()) => ConnectionHandleSendResult::Sent,
            Err(e) => ConnectionHandleSendResult::NotSent(e.0 .1),
        }
    }
}

impl PartialEq for ConnectionHandle {
    fn eq(&self, other: &Self) -> bool {
        self.connection_id == other.connection_id && self.flow == other.flow
    }
}

impl Eq for ConnectionHandle {}