1use std::sync::Arc;
2use tokio::task::JoinHandle;
3
4use super::init;
5use super::message::Message;
6use super::meter::{MeterSnapshot, SessionRuntimeSnapshot, TransportSnapshot};
7use super::triple_buffer::TripleBufferConsumer;
8use tokio::sync::mpsc::{Receiver, Sender, channel};
9
10#[derive(Debug, Clone)]
11pub struct Client {
12 pub sender: Sender<Message>,
13 meter_consumer: Arc<TripleBufferConsumer<MeterSnapshot>>,
14 transport_consumer: Arc<TripleBufferConsumer<TransportSnapshot>>,
15 session_runtime_consumer: Arc<TripleBufferConsumer<SessionRuntimeSnapshot>>,
16 _handle: Arc<JoinHandle<()>>,
17}
18
19impl Default for Client {
20 fn default() -> Self {
21 let (sender, handle, meter_consumer, transport_consumer, session_runtime_consumer) = init();
22 Self {
23 sender,
24 meter_consumer: Arc::new(meter_consumer),
25 transport_consumer: Arc::new(transport_consumer),
26 session_runtime_consumer: Arc::new(session_runtime_consumer),
27 _handle: Arc::new(handle),
28 }
29 }
30}
31
32impl Client {
33 pub async fn subscribe(&self) -> Receiver<Message> {
34 let (tx, rx) = channel::<Message>(32);
35 self.sender
36 .send(Message::Channel(tx))
37 .await
38 .expect("Failed to subscribe to engine");
39 rx
40 }
41
42 pub async fn send(&self, message: Message) -> Result<(), String> {
43 self.sender
44 .send(message)
45 .await
46 .map_err(|e| format!("Failed to send message from client: {:?}", e))
47 }
48
49 pub fn meter_snapshot(&self) -> Option<MeterSnapshot> {
50 self.meter_consumer.read_latest_clone()
51 }
52
53 pub fn transport_snapshot(&self) -> Option<TransportSnapshot> {
54 self.transport_consumer.read_latest_clone()
55 }
56
57 pub fn session_runtime_snapshot(&self) -> Option<SessionRuntimeSnapshot> {
58 self.session_runtime_consumer.read_latest_clone()
59 }
60}