Skip to content
Python
35.3 KB
Raw Blame
//! Fixed Google API hosts, bounded bodies/deadlines, no redirects or HTTP retries.
use super::{control::*, engine::Cloud, *};
use reqwest::{Method, StatusCode};
use std::{process::Stdio, time::Duration};
use tokio::{io::AsyncReadExt, process::Command};
use zeroize::Zeroizing;
#[path = "deployment_gcp_installation_api.rs"]
mod installation;
#[cfg(test)]
#[path = "deployment_gcp_transport_tests.rs"]
mod transport_tests;

pub(super) struct Google {
    client: reqwest::Client,
    token: Zeroizing<String>,
    pub control: Control,
    deadline: std::time::Instant,
    #[cfg(test)]
    pub test_base: Option<String>,
}
fn client() -> Result<reqwest::Client> {
    Ok(reqwest::Client::builder()
        .redirect(reqwest::redirect::Policy::none())
        .retry(reqwest::retry::never())
        .connect_timeout(Duration::from_secs(10))
        .timeout(Duration::from_secs(30))
        .build()?)
}
async fn body(mut r: reqwest::Response, max: usize) -> Result<Zeroizing<Vec<u8>>> {
    let mut out = Zeroizing::new(vec![]);
    while let Some(chunk) = r
        .chunk()
        .await
        .map_err(|_| anyhow::anyhow!("google_body_transport_error"))?
    {
        ensure!(out.len() + chunk.len() <= max, "google_response_limit");
        out.extend_from_slice(&chunk);
    }
    Ok(out)
}
impl Google {
    pub fn new(c: Control, token: Zeroizing<String>) -> Result<Self> {
        c.validate()?;
        ensure!(
            !token.is_empty() && token.len() <= 8192 && token.bytes().all(|b| b.is_ascii_graphic()),
            "Invalid ephemeral access token"
        );
        Ok(Self {
            client: client()?,
            token,
            control: c,
            deadline: std::time::Instant::now() + Duration::from_secs(150),
            #[cfg(test)]
            test_base: None,
        })
    }
    fn url(&self, host: &str, path: &str) -> Result<reqwest::Url> {
        ensure!(
            [
                "config.googleapis.com",
                "storage.googleapis.com",
                "run.googleapis.com",
                "cloudscheduler.googleapis.com",
                "compute.googleapis.com",
                "sqladmin.googleapis.com",
                "container.googleapis.com",
                "artifactregistry.googleapis.com",
                "cloudresourcemanager.googleapis.com",
                "serviceusage.googleapis.com"
            ]
            .contains(&host),
            "API host not allowed"
        );
        ensure!(
            path.starts_with('/') && !path.contains('?') && !path.contains('#'),
            "Invalid fixed API path"
        );
        #[cfg(test)]
        if let Some(base) = &self.test_base {
            return Ok(reqwest::Url::parse(&format!("{base}{path}"))?);
        }
        Ok(reqwest::Url::parse(&format!("https://{host}{path}"))?)
    }
    async fn request(
        &self,
        method: Method,
        host: &str,
        path: &str,
        query: &[(&str, String)],
        bytes: Option<Vec<u8>>,
        max: usize,
    ) -> Result<Option<Vec<u8>>> {
        let left = self
            .deadline
            .saturating_duration_since(std::time::Instant::now());
        ensure!(!left.is_zero(), "Google operation deadline exhausted");
        let mut request = self
            .client
            .request(method.clone(), self.url(host, path)?)
            .bearer_auth(&*self.token)
            .header("x-goog-user-project", project(&self.control.plan))
            .query(query)
            .timeout(left.min(Duration::from_secs(30)));
        if let Some(b) = bytes {
            request = request.header("Content-Type", "application/json").body(b);
        }
        let response = request
            .send()
            .await
            .map_err(|_| anyhow::anyhow!("google_transport_outcome_unknown"))?;
        if response.status() == StatusCode::NOT_FOUND && method == Method::GET {
            return Ok(None);
        }
        ensure!(
            response.status().is_success(),
            "google_http_status_{}",
            response.status().as_u16()
        );
        Ok(Some(body(response, max).await?.to_vec()))
    }
    pub(super) async fn json(
        &self,
        method: Method,
        host: &str,
        path: &str,
        query: &[(&str, String)],
        value: Option<Value>,
    ) -> Result<Option<Value>> {
        self.request(
            method,
            host,
            path,
            query,
            value.map(|v| serde_json::to_vec(&v)).transpose()?,
            1024 * 1024,
        )
        .await?
        .map(|b| serde_json::from_slice(&b).context("Invalid Google JSON response"))
        .transpose()
    }
    fn object_path(&self, name: &str) -> Result<String> {
        let mut url = self.url("storage.googleapis.com", "/storage/v1/b/")?;
        {
            let mut parts = url
                .path_segments_mut()
                .map_err(|_| anyhow::anyhow!("Invalid storage URL"))?;
            parts
                .pop_if_empty()
                .push(&self.control.bucket())
                .push("o")
                .push(name);
        }
        Ok(url.path().into())
    }
    pub async fn object(
        &self,
        name: &str,
        generation: Option<&str>,
        max: usize,
    ) -> Result<Option<(String, Vec<u8>)>> {
        let path = self.object_path(name)?;
        let q = generation
            .map(|g| vec![("generation", g.into())])
            .unwrap_or_default();
        let Some(meta) = self
            .json(Method::GET, "storage.googleapis.com", &path, &q, None)
            .await?
        else {
            return Ok(None);
        };
        let g = meta["generation"]
            .as_str()
            .context("Missing object generation")?;
        ensure!(
            meta["bucket"] == self.control.bucket()
                && meta["name"] == name
                && decimal(g)
                && generation.is_none_or(|expected| expected == g),
            "Object receipt scope mismatch"
        );
        ensure!(
            meta["size"]
                .as_str()
                .and_then(|s| s.parse::<usize>().ok())
                .is_some_and(|s| s <= max),
            "Invalid/oversized object"
        );
        let bytes = self
            .request(
                Method::GET,
                "storage.googleapis.com",
                &path,
                &[("generation", g.into()), ("alt", "media".into())],
                None,
                max,
            )
            .await?
            .context("Pinned object generation unavailable")?;
        Ok(Some((g.into(), bytes)))
    }
    pub async fn load(&self) -> Result<(Checkpoint, String)> {
        let (_, bytes) = self
            .object(&self.control.control_object()?, None, 1024 * 1024)
            .await?
            .context("Immutable control missing")?;
        ensure!(
            hash(&bytes) == self.control.sha()?,
            "Immutable control changed"
        );
        let (g, b) = self
            .object(&self.control.checkpoint_object(), None, 65536)
            .await?
            .context("Missing durable checkpoint")?;
        let j: Checkpoint = serde_json::from_slice(&b)?;
        j.validate(&self.control)?;
        Ok((j, g))
    }
    pub(super) async fn bucket(&self) -> Result<()> {
        let name = self.control.bucket();
        let v = self
            .json(
                Method::GET,
                "storage.googleapis.com",
                &format!("/storage/v1/b/{name}"),
                &[],
                None,
            )
            .await?
            .context("Control bucket missing")?;
        ensure!(
            v["name"] == name
                && v["projectNumber"]
                    == self
                        .control
                        .plan
                        .gcp_bootstrap
                        .as_ref()
                        .unwrap()
                        .project_number
                && v["iamConfiguration"]["uniformBucketLevelAccess"]["enabled"] == true
                && v["iamConfiguration"]["publicAccessPrevention"] == "enforced"
                && v["versioning"]["enabled"] == true,
            "Control bucket ownership/privacy drift"
        );
        Ok(())
    }
    async fn list(&self, path: &str, key: &str) -> Result<Vec<Value>> {
        let mut all = vec![];
        let mut token = String::new();
        let mut seen = std::collections::BTreeSet::new();
        for _ in 0..10 {
            let mut q = vec![("pageSize", "100".into())];
            if !token.is_empty() {
                q.push(("pageToken", token.clone()));
            }
            let v = self
                .json(Method::GET, "config.googleapis.com", path, &q, None)
                .await?
                .context("Provider list unavailable")?;
            ensure!(
                v["unreachable"].as_array().is_none_or(|a| a.is_empty()),
                "Incomplete provider inventory"
            );
            let entries = v
                .get(key)
                .map(|x| x.as_array().context("Invalid provider list"))
                .transpose()?
                .cloned()
                .unwrap_or_default();
            ensure!(
                all.len() + entries.len() <= 1000,
                "Provider inventory limit"
            );
            all.extend(entries);
            token = v
                .get("nextPageToken")
                .map(|x| x.as_str().context("Invalid pagination token"))
                .transpose()?
                .unwrap_or("")
                .into();
            if token.is_empty() {
                return Ok(all);
            }
            ensure!(
                token.len() <= 4096 && seen.insert(token.clone()),
                "Repeated/oversized pagination token"
            );
        }
        bail!("Provider inventory truncated")
    }
}

pub(super) async fn independent(uri: &str, sha: &str, expected_account: &str) -> Result<Google> {
    ensure!(digest(sha), "Invalid control digest");
    let source = reqwest::Url::parse(uri)?;
    ensure!(
        source.scheme() == "gs"
            && source.query().is_none()
            && source.fragment().is_none()
            && source.username().is_empty()
            && source.port().is_none(),
        "Use a plain control gs:// URI"
    );
    let bucket = source.host_str().context("Missing control bucket")?;
    ensure!(
        bucket.len() <= 63
            && bucket
                .bytes()
                .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'-'),
        "Invalid control bucket"
    );
    let object = source
        .path()
        .strip_prefix('/')
        .context("Missing control object")?;
    ensure!(
        object.len() <= 200 && object.ends_with(&format!("/control-{sha}.json")),
        "Invalid content-addressed control object"
    );
    let token = metadata_token(expected_account).await?;
    let mut url = reqwest::Url::parse("https://storage.googleapis.com/storage/v1/b/")?;
    url.path_segments_mut()
        .unwrap()
        .pop_if_empty()
        .push(bucket)
        .push("o")
        .push(object);
    let response = client()?
        .get(url)
        .bearer_auth(&*token)
        .query(&[("alt", "media")])
        .send()
        .await
        .map_err(|_| anyhow::anyhow!("Control download failed"))?;
    ensure!(response.status().is_success(), "Control download failed");
    let bytes = body(response, 1024 * 1024).await?;
    ensure!(hash(&bytes) == sha, "Control digest mismatch");
    let c: Control = serde_json::from_slice(&bytes)?;
    c.validate()?;
    ensure!(
        c.sha()? == sha
            && c.control_uri()? == uri
            && accounts(&c.plan)["cleanup"] == expected_account,
        "Control scope/identity mismatch"
    );
    Google::new(c, token)
}
impl Cloud for Google {
    async fn deployment(&mut self) -> Result<Option<Value>> {
        self.json(
            Method::GET,
            "config.googleapis.com",
            &format!("/v1/{}", self.control.deployment()),
            &[],
            None,
        )
        .await
    }
    async fn operation(&mut self, name: &str) -> Result<Value> {
        self.control.operation(name)?;
        self.json(
            Method::GET,
            "config.googleapis.com",
            &format!("/v1/{name}"),
            &[],
            None,
        )
        .await?
        .context("Operation receipt unavailable")
    }
    async fn revision(&mut self, name: &str) -> Result<Value> {
        self.control.revision(name)?;
        self.json(
            Method::GET,
            "config.googleapis.com",
            &format!("/v1/{name}"),
            &[],
            None,
        )
        .await?
        .context("Revision receipt unavailable")
    }
    async fn operations(&mut self) -> Result<Vec<Value>> {
        self.list(
            &format!("/v1/{}/operations", self.control.parent()),
            "operations",
        )
        .await
    }
    async fn source(&mut self) -> Result<()> {
        self.bucket().await?;
        let (_, b) = self
            .object(
                &self.control.source_object(),
                Some(&self.control.source_generation),
                1024 * 1024,
            )
            .await?
            .context("Source missing")?;
        ensure!(
            hash(&b) == self.control.source_sha256,
            "Immutable source digest mismatch"
        );
        Ok(())
    }
    async fn guard(&mut self) -> Result<String> {
        let c = &self.control;
        let v = self
            .json(
                Method::GET,
                "run.googleapis.com",
                &format!("/v2/{}", c.job()),
                &[],
                None,
            )
            .await?
            .context("Independent cleanup job missing")?;
        let uid = v["uid"]
            .as_str()
            .filter(|s| uuid(s))
            .context("Missing cleanup job UID")?;
        let expected_args = super::control_export::tick_args(c)?;
        let execution = &v["template"];
        let task = &execution["template"];
        ensure!(
            v["name"] == c.job()
                && v.get("reconciling")
                    .is_none_or(|x| x.as_bool() == Some(false))
                && v["terminalCondition"]["state"] == "CONDITION_SUCCEEDED"
                && v["generation"].as_str().is_some_and(decimal)
                && v["generation"] == v["observedGeneration"],
            "Cleanup job not ready"
        );
        ensure!(
            execution["taskCount"] == 1
                && execution["parallelism"] == 1
                && task["serviceAccount"] == accounts(&c.plan)["cleanup"]
                && task.get("maxRetries").is_none_or(|x| x.as_u64() == Some(0))
                && task["timeout"] == "180s"
                && task["containers"].as_array().is_some_and(|a| a.len() == 1)
                && task["containers"][0]["image"] == c.guard_image
                && task["containers"][0]["command"] == json!(["/opt/openworker/ows"])
                && task["containers"][0]["args"] == json!(expected_args),
            "Cleanup runtime configuration drift"
        );
        let limits = &task["containers"][0]["resources"]["limits"];
        ensure!(
            ["1", "1000m"].iter().any(|s| limits["cpu"] == *s)
                && ["512Mi", "536870912"]
                    .iter()
                    .any(|s| limits["memory"] == *s),
            "Cleanup CPU/memory bounds changed"
        );
        ensure!(
            task.get("volumes")
                .is_none_or(|v| v.as_array().is_some_and(|a| a.is_empty()))
                && task["containers"][0]
                    .get("env")
                    .is_none_or(|v| v.as_array().is_some_and(|a| a.is_empty())),
            "Unexpected cleanup environment/volumes"
        );
        let schedule = self
            .json(
                Method::GET,
                "cloudscheduler.googleapis.com",
                &format!("/v1/{}", c.job()),
                &[],
                None,
            )
            .await?
            .context("Independent scheduler missing")?;
        ensure!(
            schedule["name"] == c.job()
                && schedule["state"] == "ENABLED"
                && schedule["schedule"] == "*/1 * * * *"
                && schedule["timeZone"] == "Etc/UTC"
                && schedule["attemptDeadline"] == "180s"
                && schedule["httpTarget"]["uri"]
                    == format!("https://run.googleapis.com/v2/{}:run", c.job())
                && schedule["httpTarget"]["httpMethod"] == "POST"
                && schedule["httpTarget"]["body"] == "e30="
                && schedule["httpTarget"]["headers"]["Content-Type"] == "application/json"
                && schedule["httpTarget"]["oauthToken"]["serviceAccountEmail"]
                    == accounts(&c.plan)["cleanup"]
                && schedule["httpTarget"]["oauthToken"]["scope"]
                    == "https://www.googleapis.com/auth/cloud-platform",
            "Cleanup scheduler drift"
        );
        Ok(uid.into())
    }
    async fn authorize_create(&mut self) -> Result<()> {
        bail!("GCP create remains blocked: full cost/effective-IAM/private-access and live guard qualification required")
    }
    async fn create(&mut self) -> Result<Value> {
        let c = &self.control;
        self.json(
            Method::POST,
            "config.googleapis.com",
            &format!("/v1/{}/deployments", c.parent()),
            &[
                ("deploymentId", c.plan.deployment_id.clone()),
                ("requestId", c.request_id.clone()),
            ],
            Some(c.request()),
        )
        .await?
        .context("Create response missing")
    }
    async fn delete(&mut self, request: &str) -> Result<Value> {
        ensure!(uuid(request), "Invalid delete request UUID");
        self.json(
            Method::DELETE,
            "config.googleapis.com",
            &format!("/v1/{}", self.control.deployment()),
            &[
                ("requestId", request.into()),
                ("force", "true".into()),
                ("deletePolicy", "DELETE".into()),
            ],
            None,
        )
        .await?
        .context("Delete response missing")
    }
    async fn save(&mut self, generation: &str, j: &Checkpoint) -> Result<String> {
        ensure!(decimal(generation), "Missing CAS generation");
        j.validate(&self.control)?;
        let path = format!("/upload/storage/v1/b/{}/o", self.control.bucket());
        let meta = self
            .json(
                Method::POST,
                "storage.googleapis.com",
                &path,
                &[
                    ("uploadType", "media".into()),
                    ("name", self.control.checkpoint_object()),
                    ("ifGenerationMatch", generation.into()),
                ],
                Some(serde_json::to_value(j)?),
            )
            .await?
            .context("Checkpoint CAS response missing")?;
        let g = meta["generation"]
            .as_str()
            .filter(|g| decimal(g))
            .context("Invalid checkpoint generation")?;
        ensure!(
            meta["bucket"] == self.control.bucket()
                && meta["name"] == self.control.checkpoint_object()
                && g != generation,
            "Checkpoint CAS receipt mismatch"
        );
        Ok(g.into())
    }
    async fn named_resources_absent(&mut self) -> Result<bool> {
        let c = &self.control;
        let p = project(&c.plan);
        let n = c.prefix();
        let z = &c.plan.gcp_infrastructure.as_ref().unwrap().zone;
        let targets = [
            (
                "container.googleapis.com",
                format!("/v1/projects/{p}/locations/{z}/clusters/{n}-gke"),
            ),
            (
                "sqladmin.googleapis.com",
                format!("/v1beta4/projects/{p}/instances/{n}-sql"),
            ),
            (
                "storage.googleapis.com",
                format!("/storage/v1/b/{p}-{n}-artifacts"),
            ),
            (
                "artifactregistry.googleapis.com",
                format!("/v1/{}/repositories/{n}-images", c.parent()),
            ),
            (
                "compute.googleapis.com",
                format!("/compute/v1/projects/{p}/global/networks/{n}-vpc"),
            ),
            (
                "compute.googleapis.com",
                format!(
                    "/compute/v1/projects/{p}/regions/{}/subnetworks/{n}-subnet",
                    c.region()
                ),
            ),
            (
                "compute.googleapis.com",
                format!(
                    "/compute/v1/projects/{p}/regions/{}/routers/{n}-router",
                    c.region()
                ),
            ),
            (
                "compute.googleapis.com",
                format!("/compute/v1/projects/{p}/global/addresses/{n}-sql-range"),
            ),
        ];
        let mut absent = true;
        for (host, path) in targets {
            if self
                .json(Method::GET, host, &path, &[], None)
                .await?
                .is_some()
            {
                absent = false;
            }
        }
        Ok(absent)
    }
    async fn dependent_assets(&mut self) -> Result<Vec<Asset>> {
        self.inventory().await
    }
    async fn assets_absent(&mut self, assets: &[Asset]) -> Result<bool> {
        let mut absent = true;
        for a in assets {
            a.validate(&self.control)?;
            if let Some(v) = self
                .json(Method::GET, "compute.googleapis.com", &a.path, &[], None)
                .await?
            {
                ensure!(
                    v["id"] == a.id,
                    "Captured dependent replaced; review instead of deleting/adopting it"
                );
                absent = false;
            }
        }
        Ok(absent)
    }
    async fn scheduler_paused(&mut self) -> Result<bool> {
        let c = &self.control;
        let v = self
            .json(
                Method::GET,
                "cloudscheduler.googleapis.com",
                &format!("/v1/{}", c.job()),
                &[],
                None,
            )
            .await?
            .context("Scheduler receipt missing")?;
        ensure!(
            v["name"] == c.job()
                && ["PAUSED", "ENABLED"].iter().any(|s| v["state"] == *s)
                && v["httpTarget"]["uri"]
                    == format!("https://run.googleapis.com/v2/{}:run", c.job())
                && v["httpTarget"]["oauthToken"]["serviceAccountEmail"]
                    == accounts(&c.plan)["cleanup"]
                && v["httpTarget"]["body"] == "e30=",
            "Scheduler scope changed"
        );
        Ok(v["state"] == "PAUSED")
    }
    async fn pause_scheduler(&mut self) -> Result<()> {
        self.json(
            Method::POST,
            "cloudscheduler.googleapis.com",
            &format!("/v1/{}:pause", self.control.job()),
            &[],
            Some(json!({})),
        )
        .await?
        .context("Pause receipt missing")?;
        Ok(())
    }
}

impl Google {
    async fn compute_list(&self, path: &str, filter: &str) -> Result<Vec<Value>> {
        let mut out = vec![];
        let mut token = String::new();
        let mut seen = std::collections::BTreeSet::new();
        for _ in 0..10 {
            let mut q = vec![("filter", filter.into()), ("maxResults", "100".into())];
            if !token.is_empty() {
                q.push(("pageToken", token.clone()));
            }
            let v = self
                .json(Method::GET, "compute.googleapis.com", path, &q, None)
                .await?
                .context("Dependent inventory unavailable")?;
            let items = v
                .get("items")
                .map(|a| a.as_array().context("Invalid dependent inventory"))
                .transpose()?
                .cloned()
                .unwrap_or_default();
            ensure!(out.len() + items.len() <= 1000, "Dependent inventory limit");
            out.extend(items);
            token = v
                .get("nextPageToken")
                .map(|v| v.as_str().context("Invalid dependent page token"))
                .transpose()?
                .unwrap_or("")
                .into();
            if token.is_empty() {
                return Ok(out);
            }
            ensure!(
                token.len() <= 4096 && seen.insert(token.clone()),
                "Dependent pagination loop"
            );
        }
        bail!("Dependent inventory truncated")
    }
    fn asset_path(&self, url: &str) -> Result<String> {
        let u = reqwest::Url::parse(url)?;
        ensure!(
            u.scheme() == "https"
                && [Some("www.googleapis.com"), Some("compute.googleapis.com")]
                    .contains(&u.host_str())
                && u.query().is_none()
                && u.fragment().is_none(),
            "Untrusted asset URI"
        );
        let a = Asset {
            path: u.path().into(),
            id: "1".into(),
        };
        a.validate(&self.control)?;
        Ok(a.path)
    }
    async fn collect(&self, url: &str, out: &mut BTreeMap<String, Asset>) -> Result<Option<Value>> {
        let path = self.asset_path(url)?;
        let Some(v) = self
            .json(Method::GET, "compute.googleapis.com", &path, &[], None)
            .await?
        else {
            return Ok(None);
        };
        let id = v["id"]
            .as_str()
            .filter(|id| decimal(id))
            .context("Missing dependent immutable ID")?;
        let a = Asset {
            path: path.clone(),
            id: id.into(),
        };
        a.validate(&self.control)?;
        if let Some(old) = out.insert(path, a) {
            ensure!(old.id == id, "Dependent replaced during inventory");
        }
        ensure!(out.len() <= 1000, "Dependent asset limit");
        Ok(Some(v))
    }
    async fn inventory(&self) -> Result<Vec<Asset>> {
        let c = &self.control;
        let p = project(&c.plan);
        let z = &c.plan.gcp_infrastructure.as_ref().unwrap().zone;
        let cluster = format!("{}-gke", c.prefix());
        let filter = format!("labels.goog-k8s-cluster-name = \"{cluster}\"");
        let mut assets = BTreeMap::new();
        let mut groups = std::collections::BTreeSet::new();
        if let Some(gke) = self
            .json(
                Method::GET,
                "container.googleapis.com",
                &format!("/v1/projects/{p}/locations/{z}/clusters/{cluster}"),
                &[],
                None,
            )
            .await?
        {
            let pools = gke
                .get("nodePools")
                .map(|v| v.as_array().context("Invalid GKE node-pool inventory"))
                .transpose()?
                .cloned()
                .unwrap_or_default();
            for pool in pools {
                let groups_for_pool = pool
                    .get("instanceGroupUrls")
                    .map(|v| v.as_array().context("Invalid GKE group inventory"))
                    .transpose()?
                    .cloned()
                    .unwrap_or_default();
                for group in groups_for_pool {
                    groups.insert(group.as_str().context("Invalid GKE group URI")?.to_owned());
                }
            }
        }
        for vm in self
            .compute_list(
                &format!("/compute/v1/projects/{p}/zones/{z}/instances"),
                &filter,
            )
            .await?
        {
            ensure!(
                vm["labels"]["goog-k8s-cluster-name"] == cluster,
                "Instance inventory scope mismatch"
            );
            let link = vm["selfLink"]
                .as_str()
                .context("Instance self-link missing")?;
            self.collect(link, &mut assets).await?;
            for disk in vm["disks"]
                .as_array()
                .context("Incomplete instance disk inventory")?
            {
                self.collect(
                    disk["source"].as_str().context("Disk URI missing")?,
                    &mut assets,
                )
                .await?;
            }
            if let Some(items) = vm["metadata"]["items"].as_array() {
                for item in items {
                    if item["key"] == "created-by" {
                        groups.insert(
                            item["value"]
                                .as_str()
                                .context("Invalid managed group URI")?
                                .into(),
                        );
                    }
                }
            }
        }
        for disk in self
            .compute_list(
                &format!("/compute/v1/projects/{p}/zones/{z}/disks"),
                &filter,
            )
            .await?
        {
            ensure!(
                disk["labels"]["goog-k8s-cluster-name"] == cluster,
                "Disk inventory scope mismatch"
            );
            self.collect(
                disk["selfLink"]
                    .as_str()
                    .context("Disk self-link missing")?,
                &mut assets,
            )
            .await?;
        }
        for group in groups {
            if let Some(v) = self.collect(&group, &mut assets).await? {
                if let Some(url) = v["instanceGroup"].as_str() {
                    self.collect(url, &mut assets).await?;
                }
                if let Some(url) = v["instanceTemplate"].as_str() {
                    self.collect(url, &mut assets).await?;
                }
                if let Some(versions) = v["versions"].as_array() {
                    for version in versions {
                        if let Some(url) = version["instanceTemplate"].as_str() {
                            self.collect(url, &mut assets).await?;
                        }
                    }
                }
            }
        }
        Ok(assets.into_values().collect())
    }
}

pub(super) async fn login(c: &Control, metadata: bool) -> Result<Zeroizing<String>> {
    if metadata {
        return metadata_token(&accounts(&c.plan)["cleanup"]).await;
    }
    for (key, value) in std::env::vars_os() {
        let key = key.to_string_lossy();
        let endpoint = key.starts_with("CLOUDSDK_API_ENDPOINT_OVERRIDES_");
        let impersonation = key == "CLOUDSDK_AUTH_IMPERSONATE_SERVICE_ACCOUNT" && !value.is_empty();
        ensure!(
            !(endpoint || impersonation),
            "Implicit cloud endpoint/identity override"
        );
    }
    let account = c.plan.gcp_bootstrap.as_ref().unwrap().email();
    let config = gcloud(c, account, &["config", "list", "--format=json"]).await?;
    let v: Value = serde_json::from_slice(config.as_bytes())?;
    ensure!(
        v.is_object()
            && ["api_endpoint_overrides", "auth", "core"]
                .iter()
                .all(|k| v.get(k).is_none_or(Value::is_object))
            && v["api_endpoint_overrides"]
                .as_object()
                .is_none_or(|m| m.is_empty())
            && [
                "impersonate_service_account",
                "credential_file_override",
                "access_token_file"
            ]
            .iter()
            .all(|k| v["auth"][k].as_str().is_none_or(str::is_empty))
            && v["core"]["universe_domain"]
                .as_str()
                .unwrap_or("googleapis.com")
                == "googleapis.com",
        "Untrusted gcloud configuration"
    );
    gcloud(
        c,
        account,
        &[
            "auth",
            "print-access-token",
            &format!(
                "--impersonate-service-account={}",
                accounts(&c.plan)["setup"]
            ),
        ],
    )
    .await
}
async fn gcloud(c: &Control, account: &str, args: &[&str]) -> Result<Zeroizing<String>> {
    let mut cmd = Command::new("gcloud");
    cmd.args(args)
        .args([
            "--project",
            project(&c.plan),
            "--billing-project",
            project(&c.plan),
            "--account",
            account,
            "--quiet",
            "--verbosity=error",
        ])
        .env("CLOUDSDK_CORE_DISABLE_PROMPTS", "1")
        .env("CLOUDSDK_CORE_LOG_HTTP", "false")
        .stdin(Stdio::null())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .kill_on_drop(true);
    for key in [
        "CLOUDSDK_AUTH_ACCESS_TOKEN",
        "CLOUDSDK_AUTH_ACCESS_TOKEN_FILE",
        "CLOUDSDK_AUTH_CREDENTIAL_FILE_OVERRIDE",
        "GOOGLE_APPLICATION_CREDENTIALS",
    ] {
        cmd.env_remove(key);
    }
    let mut child = cmd.spawn().context("gcloud unavailable")?;
    let out = child.stdout.take().unwrap();
    let err = child.stderr.take().unwrap();
    async fn capture(r: impl tokio::io::AsyncRead + Unpin) -> std::io::Result<Zeroizing<Vec<u8>>> {
        let mut b = Zeroizing::new(vec![]);
        r.take(16385).read_to_end(&mut b).await?;
        Ok(b)
    }
    let result = tokio::time::timeout(Duration::from_secs(30), async {
        tokio::try_join!(child.wait(), capture(out), capture(err))
    })
    .await;
    let (status, out, err) = match result {
        Ok(Ok(v)) => v,
        _ => {
            let _ = child.kill().await;
            let _ = child.wait().await;
            bail!("gcloud authentication deadline/io failure")
        }
    };
    ensure!(
        status.success() && out.len() <= 16384 && err.len() <= 16384,
        "gcloud authentication failed"
    );
    Ok(Zeroizing::new(
        std::str::from_utf8(&out)
            .context("Invalid gcloud response")?
            .trim()
            .into(),
    ))
}

async fn metadata_token(expected: &str) -> Result<Zeroizing<String>> {
    ensure!(
        expected.ends_with(".iam.gserviceaccount.com")
            && expected.len() <= 254
            && expected
                .bytes()
                .all(|b| b.is_ascii_alphanumeric() || b"@._-".contains(&b)),
        "Invalid cleanup service account"
    );
    // Explicit Cloud Run mode only. Never consume caller-supplied metadata URLs.
    let client = reqwest::Client::builder()
        .no_proxy()
        .redirect(reqwest::redirect::Policy::none())
        .retry(reqwest::retry::never())
        .timeout(Duration::from_secs(5))
        .build()?;
    let base =
        "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default";
    let email = client
        .get(format!("{base}/email"))
        .header("Metadata-Flavor", "Google")
        .send()
        .await
        .map_err(|_| anyhow::anyhow!("Metadata identity unavailable"))?;
    ensure!(
        email.status().is_success()
            && email
                .headers()
                .get("Metadata-Flavor")
                .is_some_and(|v| v == "Google"),
        "Untrusted metadata response"
    );
    ensure!(
        body(email, 512).await?.as_slice() == expected.as_bytes(),
        "Cleanup metadata identity mismatch"
    );
    let r = client
        .get(format!("{base}/token"))
        .header("Metadata-Flavor", "Google")
        .send()
        .await
        .map_err(|_| anyhow::anyhow!("Metadata token unavailable"))?;
    ensure!(
        r.status().is_success()
            && r.headers()
                .get("Metadata-Flavor")
                .is_some_and(|v| v == "Google"),
        "Untrusted metadata token response"
    );
    let bytes = body(r, 16384).await?;
    let v: Value = serde_json::from_slice(&bytes)?;
    ensure!(
        v["token_type"] == "Bearer" && v["expires_in"].as_u64().is_some_and(|s| s >= 300),
        "Invalid metadata token lifetime"
    );
    Ok(Zeroizing::new(
        v["access_token"]
            .as_str()
            .context("Missing metadata token")?
            .into(),
    ))
}