moves code into the api layer

api/Cargo.toml

@@ -12,3 +12,8 @@ serde = { version = "1.0.228", features = ["derive"] }
 derive_more = { version = "2.1.0", features = ["from", "try_into"] }
 uuid = { version = "1.19.0", features = ["v4", "serde"] }
 chrono = { version = "0.4.39", features = ["serde"] }
+tokio = { version = "1.43.0", features = ["rt", "macros"] }
+tokio-tungstenite = { version = "0.28.0", features = ["rustls-tls-native-roots"] }
+tokio-util = "0.7.17"
+futures-util = "0.3.31"
+serde_json = "1.0.145"

api/src/client/error.rs

@@ -0,0 +1,31 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ConnectError {
+    #[error(transparent)]
+    TungsteniteError(#[from] tokio_tungstenite::tungstenite::Error),
+    #[error(transparent)]
+    IoError(#[from] std::io::Error),
+}
+
+#[derive(Error, Debug)]
+pub enum MessageError {
+    #[error(transparent)]
+    TokioSendError(#[from] tokio::sync::mpsc::error::SendError<()>),
+    #[error(transparent)]
+    TokioTrySendError(#[from] tokio::sync::mpsc::error::TrySendError<()>),
+    #[error(transparent)]
+    TokioLockError(#[from] tokio::sync::TryLockError),
+}
+
+#[derive(Error, Debug)]
+pub enum RequestError<E> {
+    #[error(transparent)]
+    TokioSendError(#[from] tokio::sync::mpsc::error::SendError<()>),
+    #[error(transparent)]
+    TokioLockError(#[from] tokio::sync::TryLockError),
+    #[error(transparent)]
+    RecvError(#[from] tokio::sync::oneshot::error::RecvError),
+    #[error(transparent)]
+    Inner(E),
+}

api/src/client/mod.rs

@@ -0,0 +1,283 @@
+pub mod error;
+
+use crate::client::error::{MessageError, RequestError};
+use crate::messages::payload::ResponseMessagePayload;
+use crate::messages::{ClientMessage, RequestMessage, RequestResponse, ResponseMessage};
+use error::ConnectError;
+use futures_util::stream::StreamExt;
+use futures_util::SinkExt;
+use log::{debug, error};
+use std::collections::HashMap;
+use std::sync::mpsc::sync_channel;
+use std::sync::Arc;
+use std::thread;
+use tokio::net::TcpStream;
+use tokio::select;
+use tokio::sync::mpsc::{Receiver, Sender};
+use tokio::sync::{mpsc, oneshot, RwLock, RwLockWriteGuard};
+use tokio_tungstenite::tungstenite::client::IntoClientRequest;
+use tokio_tungstenite::tungstenite::handshake::client::Request;
+use tokio_tungstenite::tungstenite::Message;
+use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
+use tokio_util::sync::CancellationToken;
+use uuid::Uuid;
+
+enum Callback {
+    None,
+    Once(oneshot::Sender<ResponseMessage>),
+}
+
+struct OutgoingMessage {
+    msg: RequestMessage,
+    callback: Callback,
+}
+
+pub struct Client {
+    cancel: CancellationToken,
+    channel: Arc<RwLock<Sender<OutgoingMessage>>>,
+}
+
+struct ClientContext {
+    cancel: CancellationToken,
+    request: Request,
+}
+
+impl Client {
+    pub fn connect<R>(request: R) -> Result<Self, ConnectError>
+    where
+        R: IntoClientRequest,
+    {
+        let (tx, _rx) = mpsc::channel(1);
+        let cancel = CancellationToken::new();
+        let channel = Arc::new(RwLock::new(tx));
+        let context = ClientContext {
+            cancel: cancel.clone(),
+            request: request.into_client_request()?,
+        };
+
+        context.start(channel.clone())?;
+
+        Ok(Self { cancel, channel })
+    }
+
+    pub async fn send_message<M: ClientMessage>(&self, msg: M) -> Result<(), MessageError> {
+        let sender = self.channel.read().await;
+        let data = sender.reserve().await?;
+        data.send(OutgoingMessage {
+            msg: RequestMessage {
+                uuid: Uuid::new_v4(),
+                response: None,
+                payload: msg.into(),
+            },
+            callback: Callback::None,
+        });
+        Ok(())
+    }
+
+    pub async fn send_message_if_connected<M: ClientMessage>(
+        &self,
+        msg: M,
+    ) -> Result<(), MessageError> {
+        let sender = self.channel.try_read()?;
+        let data = sender.reserve().await?;
+        data.send(OutgoingMessage {
+            msg: RequestMessage {
+                uuid: Uuid::new_v4(),
+                response: None,
+                payload: msg.into(),
+            },
+            callback: Callback::None,
+        });
+        Ok(())
+    }
+
+    pub fn try_send_message<M: ClientMessage>(&self, msg: M) -> Result<(), MessageError> {
+        let sender = self.channel.try_read()?;
+        let data = sender.try_reserve()?;
+        data.send(OutgoingMessage {
+            msg: RequestMessage {
+                uuid: Uuid::new_v4(),
+                response: None,
+                payload: msg.into(),
+            },
+            callback: Callback::None,
+        });
+        Ok(())
+    }
+
+    pub async fn send_request<M: RequestResponse>(
+        &self,
+        msg: M,
+    ) -> Result<M::Response, RequestError<<M::Response as TryFrom<ResponseMessagePayload>>::Error>>
+    {
+        let sender = self.channel.read().await;
+        let data = sender.reserve().await?;
+
+        let (tx, rx) = oneshot::channel();
+        data.send(OutgoingMessage {
+            msg: RequestMessage {
+                uuid: Uuid::new_v4(),
+                response: None,
+                payload: msg.into(),
+            },
+            callback: Callback::Once(tx),
+        });
+
+        let response = rx.await?;
+        let response = M::Response::try_from(response.payload).map_err(RequestError::Inner)?;
+
+        Ok(response)
+    }
+}
+
+impl ClientContext {
+    fn start(mut self, channel: Arc<RwLock<Sender<OutgoingMessage>>>) -> Result<(), ConnectError> {
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()?;
+
+        let (tx, rx) = sync_channel::<()>(1);
+
+        let _detached = thread::Builder::new()
+            .name("tlm-client".to_string())
+            .spawn(move || {
+                runtime.block_on(async {
+                    let mut write_lock = channel.write().await;
+
+                    // This cannot fail
+                    let _ = tx.send(());
+
+                    while !self.cancel.is_cancelled() {
+                        write_lock = self.run_connection(write_lock, &channel).await;
+                    }
+                    drop(write_lock);
+                });
+            })?;
+
+        // This cannot fail
+        let _ = rx.recv();
+
+        Ok(())
+    }
+
+    async fn run_connection<'a>(
+        &mut self,
+        mut write_lock: RwLockWriteGuard<'a, Sender<OutgoingMessage>>,
+        channel: &'a Arc<RwLock<Sender<OutgoingMessage>>>,
+    ) -> RwLockWriteGuard<'a, Sender<OutgoingMessage>> {
+        let mut ws = match connect_async(self.request.clone()).await {
+            Ok((ws, _)) => ws,
+            Err(e) => {
+                error!("Connect Error: {e}");
+                return write_lock;
+            }
+        };
+
+        let (tx, rx) = mpsc::channel(128);
+        *write_lock = tx;
+        drop(write_lock);
+
+        let close_connection = self.handle_connection(&mut ws, rx).await;
+
+        let write_lock = channel.write().await;
+        if close_connection {
+            if let Err(e) = ws.close(None).await {
+                println!("Close Error {e}");
+            }
+        }
+        write_lock
+    }
+
+    async fn handle_connection(
+        &mut self,
+        ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
+        mut rx: Receiver<OutgoingMessage>,
+    ) -> bool {
+        let mut callbacks = HashMap::<Uuid, Callback>::new();
+        loop {
+            select! {
+                _ = self.cancel.cancelled() => { break; },
+                Some(msg) = ws.next() => {
+                    match msg {
+                        Ok(msg) => {
+                            match msg {
+                                Message::Text(msg) => {
+                                    let msg: ResponseMessage = match serde_json::from_str(&msg) {
+                                        Ok(m) => m,
+                                        Err(e) => {
+                                            error!("Failed to deserialize {e}");
+                                            break;
+                                        }
+                                    };
+                                    self.handle_incoming(msg, &mut callbacks).await;
+                                }
+                                Message::Binary(_) => unimplemented!("Binary Data Not Implemented"),
+                                Message::Ping(data) => {
+                                    if let Err(e) = ws.send(Message::Pong(data)).await {
+                                        error!("Failed to send Pong {e}");
+                                        break;
+                                    }
+                                }
+                                Message::Pong(_) => {
+                                    // Intentionally Left Empty
+                                }
+                                Message::Close(_) => {
+                                    debug!("Websocket Closed");
+                                    return false;
+                                }
+                                Message::Frame(_) => unreachable!("Not Possible"),
+                            }
+                        }
+                        Err(e) => {
+                            error!("Receive Error {e}");
+                            break;
+                        }
+                    }
+                }
+                Some(msg) = rx.recv() => {
+                    callbacks.insert(msg.msg.uuid, msg.callback);
+                    let msg = match serde_json::to_string(&msg.msg) {
+                        Ok(m) => m,
+                        Err(e) => {
+                            error!("Encode Error {e}");
+                            break;
+                        }
+                    };
+                    if let Err(e) = ws.send(Message::Text(msg.into())).await {
+                        error!("Send Error {e}");
+                        break;
+                    }
+                }
+                else => { break; },
+            }
+        }
+        true
+    }
+
+    async fn handle_incoming(
+        &mut self,
+        msg: ResponseMessage,
+        callbacks: &mut HashMap<Uuid, Callback>,
+    ) {
+        if let Some(response_uuid) = msg.response {
+            match callbacks.get(&response_uuid) {
+                Some(Callback::Once(_)) => {
+                    let Some(Callback::Once(callback)) = callbacks.remove(&response_uuid) else {
+                        return;
+                    };
+                    let _ = callback.send(msg);
+                }
+                Some(Callback::None) => {
+                    callbacks.remove(&response_uuid);
+                }
+                None => {}
+            }
+        }
+    }
+}
+
+impl Drop for Client {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+    }
+}

api/src/lib.rs

@@ -1,4 +1,4 @@
+pub mod client;
 pub mod data_type;
 pub mod data_value;
-pub mod request;
-pub mod response;
+pub mod messages;

api/src/messages/mod.rs

@@ -0,0 +1,34 @@
+pub mod payload;
+pub mod telemetry_definition;
+pub mod telemetry_entry;
+
+use payload::{RequestMessagePayload, ResponseMessagePayload};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RequestMessage {
+    pub uuid: Uuid,
+    pub response: Option<Uuid>,
+    #[serde(flatten)]
+    pub payload: RequestMessagePayload,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ResponseMessage {
+    pub uuid: Uuid,
+    pub response: Option<Uuid>,
+    #[serde(flatten)]
+    pub payload: ResponseMessagePayload,
+}
+
+pub trait ClientMessage: Into<RequestMessagePayload> {}
+
+pub trait RequestResponse: Into<RequestMessagePayload> {
+    type Response: TryFrom<ResponseMessagePayload>;
+}
+
+// pub trait RegisterCallback {
+//     type Callback : TryFrom<ResponseMessagePayload>;
+//     type Response : Into<RequestMessagePayload>;
+// }

api/src/messages/payload.rs

@@ -0,0 +1,17 @@
+use crate::messages::telemetry_definition::{
+    TelemetryDefinitionRequest, TelemetryDefinitionResponse,
+};
+use crate::messages::telemetry_entry::TelemetryEntry;
+use derive_more::{From, TryInto};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize, From)]
+pub enum RequestMessagePayload {
+    TelemetryDefinitionRequest(TelemetryDefinitionRequest),
+    TelemetryEntry(TelemetryEntry),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, From, TryInto)]
+pub enum ResponseMessagePayload {
+    TelemetryDefinitionResponse(TelemetryDefinitionResponse),
+}

api/src/messages/telemetry_definition.rs

@@ -0,0 +1,19 @@
+use crate::data_type::DataType;
+use crate::messages::RequestResponse;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TelemetryDefinitionRequest {
+    pub name: String,
+    pub data_type: DataType,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TelemetryDefinitionResponse {
+    pub uuid: Uuid,
+}
+
+impl RequestResponse for TelemetryDefinitionRequest {
+    type Response = TelemetryDefinitionResponse;
+}

api/src/messages/telemetry_entry.rs

@@ -0,0 +1,14 @@
+use crate::data_value::DataValue;
+use crate::messages::ClientMessage;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TelemetryEntry {
+    pub uuid: Uuid,
+    pub value: DataValue,
+    pub timestamp: DateTime<Utc>,
+}
+
+impl ClientMessage for TelemetryEntry {}

api/src/request.rs

@@ -1,32 +0,0 @@
-use crate::data_type::DataType;
-use crate::data_value::DataValue;
-use chrono::{DateTime, Utc};
-use derive_more::From;
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TelemetryDefinitionRequest {
-    pub name: String,
-    pub data_type: DataType,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TelemetryEntry {
-    pub uuid: Uuid,
-    pub value: DataValue,
-    pub timestamp: DateTime<Utc>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, From)]
-pub enum RequestMessagePayload {
-    TelemetryDefinitionRequest(TelemetryDefinitionRequest),
-    TelemetryEntry(TelemetryEntry),
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RequestMessage {
-    pub uuid: Uuid,
-    #[serde(flatten)]
-    pub payload: RequestMessagePayload,
-}

api/src/response.rs

@@ -1,20 +0,0 @@
-use derive_more::{From, TryInto};
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TelemetryDefinitionResponse {
-    pub uuid: Uuid,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, From, TryInto)]
-pub enum ResponseMessagePayload {
-    TelemetryDefinitionResponse(TelemetryDefinitionResponse),
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ResponseMessage {
-    pub uuid: Uuid,
-    #[serde(flatten)]
-    pub payload: ResponseMessagePayload,
-}