Method watch_loop

crates/openshell-server/src/compute/mod.rs:974–1022

(self: Arc<Self>, mut cancel: watch::Receiver<bool>)

    }

    async fn watch_loop(self: Arc<Self>, mut cancel: watch::Receiver<bool>) {
        loop {
            let mut stream = match self
                .driver
                .watch_sandboxes(Request::new(WatchSandboxesRequest {}))
                .await
            {
                Ok(response) => response.into_inner(),
                Err(err) => {
                    warn!(error = %err, "Compute driver watch stream failed to start");
                    tokio::select! {
                        () = tokio::time::sleep(Duration::from_secs(2)) => {}
                        _ = cancel.changed() => return,
                    }
                    continue;
                }
            };

            let mut restart = false;
            loop {
                tokio::select! {
                    item = stream.next() => {
                        match item {
                            Some(Ok(event)) => {
                                if let Err(err) = self.apply_watch_event(event).await {
                                    warn!(error = %err, "Failed to apply compute driver event");
                                }
                            }
                            Some(Err(err)) => {
                                warn!(error = %err, "Compute driver watch stream errored");
                                restart = true;
                                break;
                            }
                            None => break,
                        }
                    }
                    _ = cancel.changed() => return,
                }
            }

            if !restart {
                warn!("Compute driver watch stream ended unexpectedly");
            }
            tokio::select! {
                () = tokio::time::sleep(Duration::from_secs(2)) => {}
                _ = cancel.changed() => return,
            }
        }
    }

    async fn reconcile_loop(self: Arc<Self>, mut cancel: watch::Receiver<bool>) {
        loop {