Clean up decoding of known-len component of messages between bootstrap client/server

massa-bootstrap/src/client_binder.rs

@@ -29,6 +29,12 @@ pub struct BootstrapClientBinder {
     cfg: BootstrapClientConfig,
 }
 
+/// The known-length component of a message to be received.
+struct ServerMessageLeader {
+    sig: Signature,
+    msg_len: u32,
+}
+
 impl BootstrapClientBinder {
     /// Creates a new `WriteBinder`.
     ///
@@ -69,7 +75,6 @@ impl BootstrapClientBinder {
         Ok(())
     }
 
-    // TODO: use a proper (de)serializer: https://github.com/massalabs/massa/pull/3745#discussion_r1169733161
     /// Reads the next message.
     pub fn next_timeout(
         &mut self,
@@ -85,18 +90,7 @@ impl BootstrapClientBinder {
             // TODO: Backoff spin of some sort
         }
 
-        // construct the signature from the peek
-        let sig_array = peek_buff.as_slice()[0..SIGNATURE_SIZE_BYTES]
-            .try_into()
-            .expect("logic error in array manipulations");
-        let sig = Signature::from_bytes(&sig_array)?;
-
-        // construct the message len from the peek
-        let msg_len = u32::from_be_bytes_min(
-            &peek_buff[SIGNATURE_SIZE_BYTES..],
-            self.cfg.max_bootstrap_message_size,
-        )?
-        .0;
+        let ServerMessageLeader { sig, msg_len } = self.decode_msg_leader(&peek_buff)?;
 
         // Update this bindings "most recently received" message hash, retaining the replaced value
         let message_deserializer = BootstrapServerMessageDeserializer::new((&self.cfg).into());
@@ -189,4 +183,26 @@ impl BootstrapClientBinder {
         self.duplex.write_all(&msg_bytes)?;
         Ok(())
     }
+
+    /// We are using this instead of of our library deserializer as the process is relatively straight forward
+    /// and makes error-type management cleaner
+    fn decode_msg_leader(&self, peek_buff: &[u8]) -> Result<ServerMessageLeader, BootstrapError> {
+        // todo: make the byte-count for the message len known at compile time so an array can be used
+        if peek_buff.len() != SIGNATURE_SIZE_BYTES + self.size_field_len {
+            panic!("todo: make the peek-buff length a compile-time constant");
+        }
+
+        let sig_array = peek_buff[0..SIGNATURE_SIZE_BYTES]
+            .try_into()
+            .expect("logic error in array manipulations");
+        let sig = Signature::from_bytes(&sig_array)?;
+
+        // construct the message len from the peek
+        let msg_len = u32::from_be_bytes_min(
+            &peek_buff[SIGNATURE_SIZE_BYTES..],
+            self.cfg.max_bootstrap_message_size,
+        )?
+        .0;
+        Ok(ServerMessageLeader { sig, msg_len })
+    }
 }

massa-bootstrap/src/server_binder.rs

@@ -22,6 +22,12 @@ use std::{
 };
 use tracing::error;
 
+/// The known-length component of a message to be received.
+struct ClientMessageLeader {
+    received_prev_hash: Option<Hash>,
+    msg_len: u32,
+}
+
 /// Bootstrap server binder
 pub struct BootstrapServerBinder {
     max_bootstrap_message_size: u32,
@@ -168,7 +174,6 @@ impl BootstrapServerBinder {
         })
     }
 
-    // TODO: use a proper (de)serializer: https://github.com/massalabs/massa/pull/3745#discussion_r1169733161
     /// Writes the next message.
     pub fn send_timeout(
         &mut self,
@@ -229,27 +234,11 @@ impl BootstrapServerBinder {
         while self.duplex.peek(&mut peek_buf)? < peek_len {
             // TODO: backoff spin of some sort
         }
-        // construct prev-hash from peek
-        let received_prev_hash = {
-            if self.prev_message.is_some() {
-                Some(Hash::from_bytes(
-                    peek_buf[..HASH_SIZE_BYTES]
-                        .try_into()
-                        .expect("bad slice logic"),
-                ))
-            } else {
-                None
-            }
-        };
 
-        // construct msg-len from peek
-        let msg_len = {
-            u32::from_be_bytes_min(
-                &peek_buf[HASH_SIZE_BYTES..],
-                self.max_bootstrap_message_size,
-            )?
-            .0
-        };
+        let ClientMessageLeader {
+            received_prev_hash,
+            msg_len,
+        } = self.decode_message_leader(&peek_buf)?;
 
         // read message, and discard the peek
         let mut msg_bytes = vec![0u8; peek_len + (msg_len as usize)];
@@ -287,4 +276,37 @@ impl BootstrapServerBinder {
 
         Ok(msg)
     }
+
+    /// We are using this instead of of our library deserializer as the process is relatively straight forward
+    /// and makes error-type management cleaner
+    fn decode_message_leader(
+        &self,
+        peek_buf: &[u8],
+    ) -> Result<ClientMessageLeader, BootstrapError> {
+        // construct prev-hash from peek
+        let received_prev_hash = {
+            if self.prev_message.is_some() {
+                Some(Hash::from_bytes(
+                    peek_buf[..HASH_SIZE_BYTES]
+                        .try_into()
+                        .expect("bad slice logic"),
+                ))
+            } else {
+                None
+            }
+        };
+
+        // construct msg-len from peek
+        let msg_len = {
+            u32::from_be_bytes_min(
+                &peek_buf[HASH_SIZE_BYTES..],
+                self.max_bootstrap_message_size,
+            )?
+            .0
+        };
+        Ok(ClientMessageLeader {
+            received_prev_hash,
+            msg_len,
+        })
+    }
 }