Rename iced_sentinel to iced_beacon and refactor its API

beacon/src/client.rs

@@ -0,0 +1,123 @@
+use crate::core::time::{Duration, SystemTime};
+use crate::span;
+use crate::theme;
+
+use semver::Version;
+use serde::{Deserialize, Serialize};
+use tokio::io::{self, AsyncWriteExt};
+use tokio::net;
+use tokio::sync::mpsc;
+use tokio::time;
+
+use std::sync::Arc;
+use std::thread;
+
+pub const SERVER_ADDRESS: &str = "127.0.0.1:9167";
+
+#[derive(Debug, Clone)]
+pub struct Client {
+    sender: mpsc::Sender<Message>,
+    _handle: Arc<thread::JoinHandle<()>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Message {
+    Connected {
+        at: SystemTime,
+        name: String,
+        version: Version,
+    },
+    EventLogged {
+        at: SystemTime,
+        event: Event,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Event {
+    ThemeChanged(theme::Palette),
+    SpanStarted(span::Stage),
+    SpanFinished(span::Stage, Duration),
+}
+
+impl Client {
+    pub fn log(&self, event: Event) {
+        let _ = self.sender.try_send(Message::EventLogged {
+            at: SystemTime::now(),
+            event,
+        });
+    }
+}
+
+#[must_use]
+pub fn connect(name: String) -> Client {
+    let (sender, receiver) = mpsc::channel(100);
+
+    let handle = std::thread::spawn(move || run(name, receiver));
+
+    Client {
+        sender,
+        _handle: Arc::new(handle),
+    }
+}
+
+#[tokio::main]
+async fn run(name: String, mut receiver: mpsc::Receiver<Message>) {
+    let version = semver::Version::parse(env!("CARGO_PKG_VERSION"))
+        .expect("Parse package version");
+
+    loop {
+        match _connect().await {
+            Ok(mut stream) => {
+                let _ = send(
+                    &mut stream,
+                    Message::Connected {
+                        at: SystemTime::now(),
+                        name: name.clone(),
+                        version: version.clone(),
+                    },
+                )
+                .await;
+
+                while let Some(output) = receiver.recv().await {
+                    match send(&mut stream, output).await {
+                        Ok(()) => {}
+                        Err(error) => {
+                            log::warn!(
+                                "Error sending message to server: {error}"
+                            );
+                            break;
+                        }
+                    }
+                }
+            }
+            Err(_) => {
+                time::sleep(time::Duration::from_secs(2)).await;
+            }
+        }
+    }
+}
+
+async fn _connect() -> Result<net::TcpStream, io::Error> {
+    log::debug!("Attempting to connect to server...");
+    let stream = net::TcpStream::connect(SERVER_ADDRESS).await?;
+
+    stream.set_nodelay(true)?;
+    stream.writable().await?;
+
+    Ok(stream)
+}
+
+async fn send(
+    stream: &mut net::TcpStream,
+    message: Message,
+) -> Result<(), io::Error> {
+    let bytes = bincode::serialize(&message).expect("Encode input message");
+    let size = bytes.len() as u64;
+
+    stream.write_all(&size.to_be_bytes()).await?;
+    stream.write_all(&bytes).await?;
+    stream.flush().await?;
+
+    Ok(())
+}