Method delete_sandbox

crates/openshell-driver-vm/src/driver.rs:1031–1113

(
        &self,
        sandbox_id: &str,
        sandbox_name: &str,
    )

    }

    pub async fn delete_sandbox(
        &self,
        sandbox_id: &str,
        sandbox_name: &str,
    ) -> Result<DeleteSandboxResponse, Status> {
        if !sandbox_id.is_empty() {
            validate_sandbox_id(sandbox_id)?;
        }

        let record_id = {
            let registry = self.registry.lock().await;
            if let Some((id, _record)) = registry.get_key_value(sandbox_id) {
                Some(id.clone())
            } else {
                registry
                    .iter()
                    .find(|(_, record)| record.snapshot.name == sandbox_name)
                    .map(|(id, _)| id.clone())
            }
        };

        let Some(record_id) = record_id else {
            return Ok(DeleteSandboxResponse { deleted: false });
        };

        let (
            state_dir,
            process,
            gpu_bdf,
            qemu_network_allocated,
            provisioning_task,
            sandbox_snapshot,
        ) = {
            let mut registry = self.registry.lock().await;
            let Some(record) = registry.get_mut(&record_id) else {
                return Ok(DeleteSandboxResponse { deleted: false });
            };
            record.deleting = true;
            (
                record.state_dir.clone(),
                record.process.clone(),
                record.gpu_bdf.clone(),
                record.qemu_network_allocated,
                record.provisioning_task.take(),
                record.snapshot.clone(),
            )
        };

        if let Some(snapshot) = self
            .set_snapshot_condition(&record_id, deleting_condition(), true)
            .await
        {
            self.publish_snapshot(snapshot);
        }

        if let Some(task) = provisioning_task {
            task.abort();
        }