Method finish_remove_vm

vmm/src/app.rs:327–392

Background cleanup: stop supervisor process, wait for it to exit, remove from supervisor, optionally delete workdir, and free CID. `delete_workdir`: true for user-initiated removal, false for orphan cleanup.

(&self, id: &str, delete_workdir: bool)

    ///
    /// `delete_workdir`: true for user-initiated removal, false for orphan cleanup.
    async fn finish_remove_vm(&self, id: &str, delete_workdir: bool) -> Result<()> {
        // Stop the supervisor process (idempotent if already stopped)
        if let Err(err) = self.supervisor.stop(id).await {
            debug!("supervisor.stop({id}) during removal: {err:?}");
        }

        // Poll until the process is no longer running, then remove it.
        // Some VMs take a long time to stop (e.g. 2+ hours), so we wait indefinitely.
        let mut poll_count: u64 = 0;
        loop {
            match self.supervisor.info(id).await {
                Ok(Some(info)) if info.state.status.is_running() => {
                    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
                    poll_count += 1;
                    if poll_count.is_multiple_of(30) {
                        info!(
                            "VM {id} still running after {}m during removal, waiting...",
                            poll_count * 2 / 60
                        );
                    }
                }
                Ok(Some(_)) => {
                    // Not running — remove from supervisor
                    if let Err(err) = self.supervisor.remove(id).await {
                        warn!("supervisor.remove({id}) failed: {err:?}");
                    }
                    break;
                }
                Ok(None) => {
                    // Already gone from supervisor
                    break;
                }
                Err(err) => {
                    warn!("supervisor.info({id}) failed during removal: {err:?}");
                    tokio::time::sleep(std::time::Duration::from_secs(5)).await;
                }
            }
        }

        // Only delete the workdir for user-initiated removal or if .removing marker exists.
        // Orphaned supervisor processes without the marker keep their data intact.
        let vm_path = self.work_dir(id);
        if delete_workdir || vm_path.is_removing() {
            if vm_path.path().exists() {
                if let Err(err) = fs::remove_dir_all(&vm_path) {
                    error!("failed to remove VM directory for {id}: {err:?}");
                }
            }
        } else if vm_path.path().exists() {
            info!(
                "VM {id} workdir preserved (orphan cleanup): {}",
                vm_path.path().display()
            );
        }

        // Free CID and remove from memory (last step)
        {
            let mut state = self.lock();