improves server efficiency

server/src/http/websocket/mod.rs

@@ -1,16 +1,18 @@
-use std::collections::HashMap;
-use crate::http::websocket::request::{RegisterTlmListenerRequest, UnregisterTlmListenerRequest, WebsocketRequest};
+use crate::http::websocket::request::{
+    RegisterTlmListenerRequest, UnregisterTlmListenerRequest, WebsocketRequest,
+};
 use crate::http::websocket::response::{TlmValueResponse, WebsocketResponse};
 use crate::telemetry::management_service::TelemetryManagementService;
 use actix_web::{rt, web, HttpRequest, HttpResponse};
 use actix_ws::{AggregatedMessage, ProtocolError, Session};
 use anyhow::anyhow;
 use log::{error, trace};
+use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
+use tokio::select;
 use tokio::sync::mpsc::Sender;
-use tokio::time::{sleep, Instant};
-use tokio::{pin, select};
+use tokio::time::{sleep_until, Instant};
 use tokio_util::sync::CancellationToken;
 use tonic::codegen::tokio_stream::StreamExt;
 
@@ -32,48 +34,29 @@ fn handle_register_tlm_listener(
         let mut rx = tlm_data.data.subscribe();
         let tx = tx.clone();
         rt::spawn(async move {
-            let mut last_sent_at = Instant::now() - minimum_separation;
-            let mut last_value = None;
-            let sleep = sleep(Duration::from_millis(0));
-            pin!(sleep);
             loop {
-                select! {
-                    _ = tx.closed() => {
-                        break;
-                    }
-                    _ = token.cancelled() => {
-                        break;
-                    }
+                let now = select! {
+                    biased;
+                    _ = tx.closed() => { break; }
+                    _ = token.cancelled() => { break; }
                     Ok(_) = rx.changed() => {
                         let now = Instant::now();
                         let value = {
                             let ref_val = rx.borrow_and_update();
                             ref_val.clone()
                         };
-                        if last_sent_at + minimum_separation > now {
-                            last_value = value;
-                            sleep.as_mut().reset(last_sent_at + minimum_separation);
-                            continue;
-                        } else {
-                            last_value = None;
-                            last_sent_at = now;
-                        }
                         let _ = tx.send(TlmValueResponse {
                             uuid: request.uuid.clone(),
                             value,
                         }.into()).await;
+                        now
                     }
-                    () = &mut sleep => {
-                        if let Some(value) = last_value {
-                            let _ = tx.send(TlmValueResponse {
-                                uuid: request.uuid.clone(),
-                                value: Some(value),
-                            }.into()).await;
-                        }
-                        last_value = None;
-                        let now = Instant::now();
-                        last_sent_at = now;
-                    }
+                };
+                select! {
+                    biased;
+                    _ = tx.closed() => { break; }
+                    _ = token.cancelled() => { break; }
+                    _ = sleep_until(now + minimum_separation) => {}
                 }
             }
         });
@@ -98,10 +81,10 @@ async fn handle_websocket_message(
     match request {
         WebsocketRequest::RegisterTlmListener(request) => {
             handle_register_tlm_listener(data, request, tx, tlm_listeners)
-        },
+        }
         WebsocketRequest::UnregisterTlmListener(request) => {
             handle_unregister_tlm_listener(request, tlm_listeners)
-        },
+        }
     };
 }