remove uuid from session request, simplify bincode

Author: Migorithm

duva/src/domains/caches/cache_objects/entry.rs

@@ -1,14 +1,10 @@
 use anyhow::Context;
-use bincode::{
-    BorrowDecode,
-    error::{DecodeError, EncodeError},
-};
 use chrono::{DateTime, Utc};
 use std::time::Duration;
 
 use crate::domains::caches::cache_objects::{CacheValue, TypedValue};
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, bincode::Encode, bincode::Decode)]
 pub struct CacheEntry {
     pub(crate) key: String,
     pub(crate) value: CacheValue,
@@ -69,32 +65,6 @@ impl CacheEntry {
     }
 }
 
-impl bincode::Encode for CacheEntry {
-    fn encode<E: bincode::enc::Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
-        bincode::Encode::encode(&self.key, encoder)?;
-        bincode::Encode::encode(&self.value, encoder)?;
-        Ok(())
-    }
-}
-
-impl<Ctx> bincode::Decode<Ctx> for CacheEntry {
-    fn decode<D: bincode::de::Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
-        let key: String = bincode::Decode::decode(decoder)?;
-        let value: CacheValue = bincode::Decode::decode(decoder)?;
-        Ok(CacheEntry { key, value })
-    }
-}
-
-impl<'de, Ctx> BorrowDecode<'de, Ctx> for CacheEntry {
-    fn borrow_decode<D: bincode::de::BorrowDecoder<'de>>(
-        decoder: &mut D,
-    ) -> Result<Self, DecodeError> {
-        let key: String = BorrowDecode::borrow_decode(decoder)?;
-        let value: CacheValue = BorrowDecode::borrow_decode(decoder)?;
-        Ok(CacheEntry { key, value })
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

duva/src/domains/cluster_actors/actor/client_sessions.rs

@@ -1,11 +1,10 @@
 use crate::{domains::cluster_actors::SessionRequest, make_smart_pointer};
 use chrono::{DateTime, Utc};
 use std::collections::HashMap;
-use uuid::Uuid;
 
 #[derive(Default, Debug)]
-pub(crate) struct ClientSessions(HashMap<Uuid, Session>);
-make_smart_pointer!(ClientSessions,HashMap<Uuid, Session>);
+pub(crate) struct ClientSessions(HashMap<String, Session>);
+make_smart_pointer!(ClientSessions,HashMap<String, Session>);
 
 #[derive(Default, Debug)]
 pub(crate) struct Session {

duva/src/domains/cluster_actors/command.rs

@@ -127,48 +127,13 @@ impl FromStr for LazyOption {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, bincode::Encode, bincode::Decode)]
 pub struct SessionRequest {
     pub(crate) request_id: u64,
-    pub(crate) client_id: Uuid,
+    pub(crate) client_id: String,
 }
 impl SessionRequest {
     pub(crate) fn new(request_id: u64, client_id: Uuid) -> Self {
-        Self { request_id, client_id }
-    }
-}
-
-impl bincode::Encode for SessionRequest {
-    fn encode<E: bincode::enc::Encoder>(
-        &self,
-        encoder: &mut E,
-    ) -> core::result::Result<(), bincode::error::EncodeError> {
-        self.request_id.encode(encoder)?;
-        self.client_id.as_bytes().encode(encoder)?;
-        Ok(())
-    }
-}
-
-impl<Context> bincode::Decode<Context> for SessionRequest {
-    fn decode<D: bincode::de::Decoder>(
-        decoder: &mut D,
-    ) -> core::result::Result<Self, bincode::error::DecodeError> {
-        let request_id = u64::decode(decoder)?;
-        let uuid_bytes: [u8; 16] = <[u8; 16]>::decode(decoder)?;
-        let client_id = Uuid::from_bytes(uuid_bytes);
-
-        Ok(SessionRequest { request_id, client_id })
-    }
-}
-
-impl<'de, Context> bincode::BorrowDecode<'de, Context> for SessionRequest {
-    fn borrow_decode<D: bincode::de::BorrowDecoder<'de>>(
-        decoder: &mut D,
-    ) -> core::result::Result<Self, bincode::error::DecodeError> {
-        let request_id = u64::borrow_decode(decoder)?;
-        let uuid_bytes: [u8; 16] = <[u8; 16]>::borrow_decode(decoder)?;
-        let client_id = Uuid::from_bytes(uuid_bytes);
-
-        Ok(SessionRequest { request_id, client_id })
+        Self { request_id, client_id: client_id.to_string() }
     }
 }