fix(irtt): retry terminal targets without restarting healthy sessions

src/measurement/irtt.rs

@@ -7,7 +7,7 @@ use irtt_client::{
         ManagedClient, ManagedClientConfig, ManagedClientHandle, ManagedClientTask,
         ManagedCommandApplyError, ManagedCommandError, ManagedCompletionPolicy, ManagedConfigError,
         ManagedEndReason, ManagedEvent, ManagedLifecycle, ManagedSubscribeError,
-        ManagedTargetConfig, ManagedTargetEndReason, TargetAuth, TargetId,
+        ManagedTargetConfig, ManagedTargetEndReason, ManagedTargetLifecycle, TargetAuth, TargetId,
     },
 };
 use log::{debug, trace, warn};
@@ -81,6 +81,7 @@ pub struct IrttEngine {
     client: ManagedClientHandle,
 
     bindings: HashMap<MeasurementStreamId, IrttBinding>,
+    targets: Vec<ManagedTargetConfig>,
 
     origin: Instant,
 
@@ -104,6 +105,7 @@ impl IrttEngine {
             Self {
                 client: handle,
                 bindings: HashMap::new(),
+                targets: Vec::new(),
                 origin,
                 binding_rx,
                 observation_tx,
@@ -126,9 +128,10 @@ impl IrttEngine {
                 }
                 target
             })
-            .collect();
+            .collect::<Vec<_>>();
 
-        self.client.update_targets(targets)?.await?;
+        self.client.update_targets(targets.clone())?.await?;
+        self.targets = targets;
 
         self.bindings = bindings
             .into_iter()
@@ -166,6 +169,11 @@ impl IrttEngine {
 
     async fn run_events(&mut self) -> Result<(), IrttError> {
         let mut events = self.client.subscribe()?;
+        // Durable status catches failures even if their presentation events were lost.
+        // Resubmitting the full desired set restarts terminal targets only.
+        let mut retry = tokio::time::interval(std::time::Duration::from_secs(5));
+        retry.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
+        retry.tick().await;
         loop {
             tokio::select! {
                 bindings = self.binding_rx.recv_async() => {
@@ -175,6 +183,17 @@ impl IrttEngine {
                     self.set_bindings(bindings).await?;
                 }
 
+                _ = retry.tick() => {
+                    if SHUTDOWN.load(std::sync::atomic::Ordering::Relaxed) {
+                        return Ok(());
+                    }
+                    if self.client.status().targets.iter().any(|target| {
+                        target.desired && target.lifecycle == ManagedTargetLifecycle::Terminal
+                    }) {
+                        self.client.update_targets(self.targets.clone())?.await?;
+                    }
+                }
+
                 event = events.recv() => {
                     let event = match event {
                         Ok(event) => event,