1use ave_actors::{
2 Actor, ActorError, ActorPath, Handler, Message, NotPersistentActor,
3 Response,
4};
5use ave_common::response::MonitorNetworkState;
6use tracing::{Span, info_span};
7
8use crate::{Event as NetworkEvent, NetworkState};
9
10use async_trait::async_trait;
11use serde::{Deserialize, Serialize};
12
13#[derive(Clone, Debug, Serialize, Deserialize)]
14pub struct Monitor {
16 state: MonitorNetworkState,
17}
18
19impl Monitor {
20 pub fn new() -> Self {
22 Self {
23 state: MonitorNetworkState::default(),
24 }
25 }
26}
27
28impl Default for Monitor {
29 fn default() -> Self {
30 Self::new()
31 }
32}
33
34#[derive(Debug, Clone)]
36pub enum MonitorMessage {
37 Network(NetworkEvent),
39 State,
41}
42
43impl Message for MonitorMessage {}
44
45impl NotPersistentActor for Monitor {}
46
47#[derive(Debug, Clone)]
49pub enum MonitorResponse {
50 State(MonitorNetworkState),
52 Ok,
54}
55
56impl Response for MonitorResponse {}
57
58#[async_trait]
59impl Actor for Monitor {
60 type Message = MonitorMessage;
61 type Event = ();
62 type Response = MonitorResponse;
63
64 fn get_span(_id: &str, parent_span: Option<Span>) -> tracing::Span {
65 parent_span.map_or_else(
66 || info_span!("Monitor"),
67 |parent_span| info_span!(parent: parent_span, "Monitor"),
68 )
69 }
70}
71
72#[async_trait]
73impl Handler<Self> for Monitor {
74 async fn handle_message(
75 &mut self,
76 _sender: ActorPath,
77 msg: MonitorMessage,
78 _ctx: &mut ave_actors::ActorContext<Self>,
79 ) -> Result<MonitorResponse, ActorError> {
80 match msg {
81 MonitorMessage::Network(event) => {
82 if matches!(
83 event,
84 NetworkEvent::StateChanged(NetworkState::Running)
85 ) {
86 self.state = MonitorNetworkState::Running
87 }
88 Ok(MonitorResponse::Ok)
89 }
90 MonitorMessage::State => {
91 Ok(MonitorResponse::State(self.state.clone()))
92 }
93 }
94 }
95}