hyveos_core/
debug.rs

1use libp2p_identity::PeerId;
2#[cfg(feature = "serde")]
3use serde::{Deserialize, Serialize};
4use ulid::Ulid;
5
6use crate::{
7    discovery::NeighbourEvent,
8    error::{Error, Result},
9    gossipsub, grpc,
10    req_resp::{Request, Response},
11};
12
13#[derive(Debug, Clone, PartialEq, Eq)]
14#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
15pub struct MeshTopologyEvent {
16    pub peer_id: PeerId,
17    pub event: NeighbourEvent,
18}
19
20impl From<MeshTopologyEvent> for grpc::MeshTopologyEvent {
21    fn from(event: MeshTopologyEvent) -> Self {
22        Self {
23            peer: event.peer_id.into(),
24            event: event.event.into(),
25        }
26    }
27}
28
29impl TryFrom<grpc::MeshTopologyEvent> for MeshTopologyEvent {
30    type Error = Error;
31
32    fn try_from(event: grpc::MeshTopologyEvent) -> Result<Self> {
33        Ok(Self {
34            peer_id: event.peer.try_into()?,
35            event: event.event.try_into()?,
36        })
37    }
38}
39
40#[derive(Debug, Clone)]
41#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
42pub struct RequestDebugEvent {
43    pub id: Ulid,
44    pub receiver: PeerId,
45    pub msg: Request,
46}
47
48impl From<RequestDebugEvent> for grpc::RequestDebugEvent {
49    fn from(event: RequestDebugEvent) -> Self {
50        Self {
51            id: event.id.into(),
52            receiver: event.receiver.into(),
53            msg: event.msg.into(),
54        }
55    }
56}
57
58impl TryFrom<grpc::RequestDebugEvent> for RequestDebugEvent {
59    type Error = Error;
60
61    fn try_from(event: grpc::RequestDebugEvent) -> Result<Self> {
62        Ok(Self {
63            id: event.id.try_into()?,
64            receiver: event.receiver.try_into()?,
65            msg: event.msg.into(),
66        })
67    }
68}
69
70#[derive(Debug, Clone)]
71#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
72pub struct ResponseDebugEvent {
73    pub req_id: Ulid,
74    pub response: Response,
75}
76
77impl From<ResponseDebugEvent> for grpc::ResponseDebugEvent {
78    fn from(event: ResponseDebugEvent) -> Self {
79        Self {
80            req_id: event.req_id.into(),
81            response: event.response.into(),
82        }
83    }
84}
85
86impl TryFrom<grpc::ResponseDebugEvent> for ResponseDebugEvent {
87    type Error = Error;
88
89    fn try_from(event: grpc::ResponseDebugEvent) -> Result<Self> {
90        Ok(Self {
91            req_id: event.req_id.try_into()?,
92            response: event.response.try_into()?,
93        })
94    }
95}
96
97#[derive(Debug, Clone)]
98#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
99pub enum MessageDebugEventType {
100    Request(RequestDebugEvent),
101    Response(ResponseDebugEvent),
102    GossipSub(gossipsub::Message),
103}
104
105impl From<MessageDebugEventType> for grpc::message_debug_event::Event {
106    fn from(event: MessageDebugEventType) -> Self {
107        match event {
108            MessageDebugEventType::Request(req) => Self::Req(req.into()),
109            MessageDebugEventType::Response(res) => Self::Res(res.into()),
110            MessageDebugEventType::GossipSub(msg) => Self::Gos(msg.into()),
111        }
112    }
113}
114
115impl TryFrom<grpc::message_debug_event::Event> for MessageDebugEventType {
116    type Error = Error;
117
118    fn try_from(event: grpc::message_debug_event::Event) -> Result<Self> {
119        Ok(match event {
120            grpc::message_debug_event::Event::Req(req) => Self::Request(req.try_into()?),
121            grpc::message_debug_event::Event::Res(res) => Self::Response(res.try_into()?),
122            grpc::message_debug_event::Event::Gos(msg) => Self::GossipSub(msg.into()),
123        })
124    }
125}
126
127#[derive(Debug, Clone)]
128#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
129pub struct MessageDebugEvent {
130    pub sender: PeerId,
131    pub event: MessageDebugEventType,
132}
133
134impl From<MessageDebugEvent> for grpc::MessageDebugEvent {
135    fn from(event: MessageDebugEvent) -> Self {
136        Self {
137            sender: event.sender.into(),
138            event: Some(event.event.into()),
139        }
140    }
141}
142
143impl TryFrom<grpc::MessageDebugEvent> for MessageDebugEvent {
144    type Error = Error;
145
146    fn try_from(event: grpc::MessageDebugEvent) -> Result<Self> {
147        Ok(Self {
148            sender: event.sender.try_into()?,
149            event: event.event.ok_or(Error::MissingEvent)?.try_into()?,
150        })
151    }
152}
hyveos_core/debug.rs

hyveos_core/
debug.rs
