fix: modify ping behaviour

Signed-off-by: tjh <[e-mail]>

src/tap/channel.rs

···
-use std::{
-    collections::HashSet,
-    time::{Duration, SystemTime},
-};
+use std::time::{Duration, SystemTime};
 
 use futures_util::{SinkExt as _, StreamExt};
 use serde::Serialize;
···
 use tokio_util::sync::{CancellationToken, DropGuard};
 
 use crate::tap::{TapClient, TapEvent};
-
-/// Maximum number of unanswered Ping messages to allow before the connection is
-/// considered broken.
-const MAX_INFLIGHT_PINGS: usize = 2;
 
 const TIMEOUT: Duration = Duration::from_secs(30);
 
···
         ClearAcks,
     }
 
-    let mut pings: HashSet<Bytes> = HashSet::with_capacity(MAX_INFLIGHT_PINGS + 1);
-    let mut timeout = tokio::time::interval(TIMEOUT);
-    timeout.tick().await;
-
     let (ack_tx, mut ack_rx) = mpsc::channel(capacity);
     let mut acks: Vec<_> = Default::default();
 
     'outer: loop {
+        let mut ping_inflight = false;
+        let mut timeout = tokio::time::interval(TIMEOUT);
+        timeout.tick().await;
+
         let request = request_builder.clone();
         let (mut socket, _) = match tokio_tungstenite::connect_async(request).await {
             Ok(result) => result,
···
                     Message::Ping(bytes) => {
                         if let Err(error) = socket.send(Message::Pong(bytes)).await {
                             tracing::error!(?error, "failed to send Pong");
-                            continue 'outer;
+                            break;
                         }
                     }
                     Message::Pong(bytes) => {
                         tracing::trace!(?bytes, "received Pong from server");
-                        if !pings.remove(&bytes) {
-                            tracing::error!("unsolicited Pong");
-                            break;
-                        }
+                        ping_inflight = false;
                     }
                     Message::Close(close_frame) => {
                         tracing::debug!(?close_frame, "received close frame");
···
                     }
                 }
                 Action::Timeout => {
-                    if pings.len() > MAX_INFLIGHT_PINGS {
-                        tracing::error!("too many missed pings");
+                    if ping_inflight {
+                        tracing::error!("missed ping");
                         break;
                     }
 
···
 
                     let payload = format!("{timestamp}");
                     let payload: Bytes = payload.into();
-                    pings.insert(payload.clone());
-
                     if socket.send(Message::Ping(payload)).await.is_err() {
                         tracing::error!("failed to send Ping to server");
                         break;
                     }
+
+                    ping_inflight = true;
                 }
                 Action::ClearAcks => {
                     drop(ack_tx);