initial comms

common/Cargo.toml

@@ -4,3 +4,11 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+anyhow = "1.0.100"
+fern = { version = "0.7.1", features = ["colored"] }
+log = { version = "0.4.28", features = ["max_level_trace", "release_max_level_debug"] }
+chrono = { version = "0.4.42", features = ["serde"] }
+ctrlc = "3.5.0"
+serde = { version = "1.0.228", features = ["derive"], default-features = false }
+ciborium = { version = "0.2.2" }
+thiserror = "2.0.17"

common/src/command/mod.rs

@@ -0,0 +1,6 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum Command {
+    Shutdown,
+}

common/src/lib.rs

@@ -1,14 +1,16 @@
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
-}
+use log::info;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+pub mod logger;
+pub mod command;
+pub mod telemetry;
+pub mod udp;
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
+pub fn add_ctrlc_handler(flag: Arc<AtomicBool>) -> anyhow::Result<()> {
+    ctrlc::set_handler(move || {
+        info!("Shutdown Requested");
+        flag.store(false, Ordering::Relaxed);
+    })?;
+    Ok(())
 }

common/src/logger.rs

@@ -0,0 +1,52 @@
+use anyhow::Result;
+use fern::colors::{Color, ColoredLevelConfig};
+use log::debug;
+use std::fs::create_dir_all;
+use std::str::FromStr;
+use std::{env, thread};
+
+pub fn setup_logger(package_name: &'static str) -> Result<()> {
+    let log_file = env::var("LOG_FILE").or_else(|_| {
+        create_dir_all("logs/")?;
+
+        anyhow::Ok(format!(
+            "logs/{}_{}.log",
+            package_name,
+            chrono::Local::now().format("%Y%m%d_%H%M%S")
+        ))
+    })?;
+    let log_level = match env::var("LOG_LEVEL") {
+        Ok(log_level) => log::LevelFilter::from_str(&log_level).unwrap_or(log::LevelFilter::Info),
+        Err(_) => log::LevelFilter::Info,
+    };
+
+    let colors = ColoredLevelConfig::new()
+        .error(Color::Red)
+        .warn(Color::Yellow)
+        .info(Color::White)
+        .debug(Color::White)
+        .trace(Color::BrightBlack);
+
+    fern::Dispatch::new()
+        .format(move |out, message, record| {
+            let binding = thread::current();
+            let thread_name = binding.name().unwrap_or("<unnamed>");
+
+            out.finish(format_args!(
+                "[{time} {level} {thread_name} {target}] {message}",
+                level = colors.color(record.level()),
+                time = chrono::Local::now().format("%Y-%m-%dT%H:%M:%S%.9f"),
+                target = record.target(),
+            ))
+        })
+        .chain(
+            fern::Dispatch::new()
+                .level(log_level)
+                .chain(std::io::stdout()),
+        )
+        .chain(fern::log_file(log_file.clone())?)
+        .apply()?;
+
+    debug!("Logging to {} at level {}", log_file, log_level);
+    Ok(())
+}

common/src/telemetry/mod.rs

@@ -0,0 +1,8 @@
+use chrono::serde::ts_nanoseconds;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum Telemetry {
+    Timestamp(#[serde(with = "ts_nanoseconds")] DateTime<Utc>)
+}

common/src/udp.rs

@@ -0,0 +1,80 @@
+use crate::udp::UdpSendCborError::LengthMismatch;
+use log::error;
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+use std::io::{Cursor, ErrorKind};
+use std::net::{SocketAddr, ToSocketAddrs, UdpSocket};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum UdpRecvCborError {
+    #[error("IO Error")]
+    Io(#[from] std::io::Error),
+    #[error("Deserialization Error")]
+    Deserialization(#[from] ciborium::de::Error<std::io::Error>),
+    #[error("No Data")]
+    NoData,
+}
+
+#[derive(Error, Debug)]
+pub enum UdpSendCborError {
+    #[error("IO Error")]
+    Io(#[from] std::io::Error),
+    #[error("Serialization Error")]
+    Serialization(#[from] ciborium::ser::Error<std::io::Error>),
+    #[error("Length Mismatch")]
+    LengthMismatch {
+        expected: usize,
+        actual: usize,
+    },
+}
+
+pub trait UdpSocketExt {
+    fn recv_cbor<T: DeserializeOwned, const N: usize>(&self, buffer: &mut Cursor<[u8; N]>) -> Result<(T, SocketAddr), UdpRecvCborError>;
+    fn send_cbor<T: Serialize + ?Sized, A: ToSocketAddrs, const N: usize>(&self, data: &T, buffer: &mut Cursor<[u8; N]>, addr: A) -> Result<(), UdpSendCborError>;
+}
+
+impl UdpSocketExt for UdpSocket {
+    fn recv_cbor<T: DeserializeOwned, const N: usize>(&self, buffer: &mut Cursor<[u8; N]>) -> Result<(T, SocketAddr), UdpRecvCborError> {
+        buffer.set_position(0);
+        match self.recv_from(buffer.get_mut()) {
+            Ok((size, addr)) => {
+                match ciborium::from_reader::<T, _>(&buffer.get_ref()[..size]) {
+                    Ok(res) => Ok((res, addr)),
+                    Err(err) => Err(err.into()),
+                }
+            }
+            Err(err) => {
+                match err.kind() {
+                    ErrorKind::WouldBlock | ErrorKind::TimedOut => {
+                        Err(UdpRecvCborError::NoData)
+                    }
+                    _ => Err(err.into())
+                }
+            }
+        }
+    }
+
+    fn send_cbor<T: Serialize + ?Sized, A: ToSocketAddrs, const N: usize>(&self, data: &T, mut buffer: &mut Cursor<[u8; N]>, addr: A) -> Result<(), UdpSendCborError> {
+        buffer.set_position(0);
+        match ciborium::into_writer(data, &mut buffer) {
+            Ok(_) => match self.send_to(&buffer.get_ref()[..buffer.position() as usize], addr) {
+                Ok(size) => {
+                    if buffer.position() as usize != size {
+                        return Err(LengthMismatch {
+                            expected: buffer.position() as usize,
+                            actual: size,
+                        });
+                    }
+                    Ok(())
+                }
+                Err(e) => {
+                    Err(e.into())
+                }
+            }
+            Err(e) => {
+                Err(e.into())
+            }
+        }
+    }
+}