Fix UDP test with timing; this shouldn't be happening and has been gi…

…ven a TO_DO
quietlychris · Jan 15, 2024 · 78dc8fe · 78dc8fe
1 parent cd228fd
commit 78dc8fe
Show file tree

Hide file tree

Showing 3 changed files with 34 additions and 19 deletions.
diff --git a/src/error/host_operation.rs b/src/error/host_operation.rs
@@ -15,7 +15,7 @@ pub enum HostError {
     NonExistentTopic,
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize)]
 pub enum HostOperation {
     SUCCESS,
     FAILURE,

diff --git a/src/host/udp.rs b/src/host/udp.rs
@@ -38,23 +38,23 @@ pub async fn process_udp(
                         panic!("{}", e);
                     }
                 };
-                // dbg!(&msg);
 
                 match msg.msg_type {
                     MsgType::SET => {
                         // println!("received {} bytes, to be assigned to: {}", n, &msg.name);
                         let tree = db
                             .open_tree(msg.topic.as_bytes())
                             .expect("Error opening tree");
-                        let _db_result =
+
+                        let _db_result = {
                             match tree.insert(msg.timestamp.to_string().as_bytes(), bytes) {
                                 Ok(_prev_msg) => {
-                                    let mut count = count.lock().await;
-                                    *count += 1;
-                                    "SUCCESS".to_string()
+                                    info!("{:?}", msg.data);
+                                    crate::error::HostOperation::SUCCESS
                                 }
-                                Err(e) => e.to_string(),
-                            };
+                                Err(_e) => crate::error::HostOperation::FAILURE,
+                            }
+                        };
                     }
                     MsgType::GET => {
                         let tree = db
@@ -81,6 +81,7 @@ pub async fn process_udp(
                     }
                     MsgType::TOPICS => {
                         let names = db.tree_names();
+
                         let mut strings = Vec::new();
                         for name in names {
                             match std::str::from_utf8(&name[..]) {
@@ -99,20 +100,30 @@ pub async fn process_udp(
                             .unwrap();
                         strings.remove(index);
 
-                        if let Ok(data) = to_allocvec(&strings) {
-                            let packet: GenericMsg = GenericMsg {
-                                msg_type: MsgType::TOPICS,
-                                timestamp: Utc::now(),
-                                topic: "".to_string(),
-                                data_type: std::any::type_name::<Vec<String>>().to_string(),
-                                data,
-                            };
+                        match to_allocvec(&strings) {
+                            Ok(data) => {
+                                let packet: GenericMsg = GenericMsg {
+                                    msg_type: MsgType::TOPICS,
+                                    timestamp: Utc::now(),
+                                    topic: "".to_string(),
+                                    data_type: std::any::type_name::<Vec<String>>().to_string(),
+                                    data,
+                                };
 
-                            if let Ok(bytes) = to_allocvec(&packet) {
-                                if let Err(e) = socket.try_send_to(&bytes, return_addr) {
-                                    error!("Error sending data back on UDP/TOPICS: {:?}", e);
+                                if let Ok(bytes) = to_allocvec(&packet) {
+                                    if let Ok(()) = socket.writable().await {
+                                        if let Err(e) = socket.try_send_to(&bytes, return_addr) {
+                                            error!(
+                                                "Error sending data back on UDP/TOPICS: {:?}",
+                                                e
+                                            );
+                                        }
+                                    }
                                 }
                             }
+                            Err(e) => {
+                                error!("{:?}", e);
+                            }
                         }
                     }
                 }

diff --git a/tests/udp_integration.rs b/tests/udp_integration.rs
@@ -115,6 +115,9 @@ fn topics_list_udp() {
 
     for i in 0..topics.len() {
         nodes[i].publish(i).unwrap();
+        dbg!(host.topics());
+        // TO_DO: We really shouldn't need to sleep here
+        thread::sleep(Duration::from_millis(1));
         assert_eq!(host.topics(), nodes[i].topics().unwrap().data);
         let t = if i == 0 {
             vec![topics[i].to_string()]
@@ -126,6 +129,7 @@ fn topics_list_udp() {
             t.sort();
             t
         };
+
         let mut nt = nodes[i].topics().unwrap().data;
         nt.sort();
         assert_eq!(t, nt);