Skip to content
Python
13.4 KB
Raw Blame
//! Versioned durable control data, kept outside the workload Terraform graph.
use super::super::artifacts as plan_artifacts;
use super::*;

#[derive(Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub(super) struct Control {
    pub schema_version: u16,
    pub plan: Plan,
    pub bundle_digest: String,
    pub source_generation: String,
    pub source_sha256: String,
    pub request_id: String,
    pub guard_image: String,
}
pub(super) fn decimal(s: &str) -> bool {
    !s.is_empty() && s.len() <= 24 && !s.starts_with('0') && s.bytes().all(|b| b.is_ascii_digit())
}
pub(super) fn uuid(s: &str) -> bool {
    uuid::Uuid::parse_str(s).is_ok_and(|id| !id.is_nil() && id.to_string() == s)
}
pub(super) fn digest(s: &str) -> bool {
    s.len() == 64
        && s.bytes()
            .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
}
pub(super) fn unix(s: &str) -> Result<u64> {
    let t = chrono::DateTime::parse_from_rfc3339(s).context("Invalid provider timestamp")?;
    u64::try_from(t.timestamp()).context("Invalid provider timestamp")
}
impl Control {
    pub fn validate(&self) -> Result<()> {
        self.plan.validate()?;
        ensure!(
            self.schema_version == 1 && self.plan.gcp_infrastructure.is_some(),
            "Invalid control schema/graph"
        );
        let hashes: BTreeMap<_, _> = plan_artifacts(&self.plan)?
            .iter()
            .map(|(n, b)| (n.clone(), hash(b)))
            .collect();
        ensure!(
            self.bundle_digest == hash(&serde_json::to_vec(&hashes)?),
            "Control graph digest mismatch"
        );
        ensure!(
            decimal(&self.source_generation) && uuid(&self.request_id),
            "Invalid source generation/request identity"
        );
        ensure!(
            self.source_sha256 == hash(&source_zip(&self.plan)?),
            "Control source digest mismatch"
        );
        let prefix = format!(
            "{}-docker.pkg.dev/{}/{}-control-images/ows@sha256:",
            self.region(),
            project(&self.plan),
            self.prefix()
        );
        ensure!(
            self.guard_image.strip_prefix(&prefix).is_some_and(digest),
            "Guard image must be digest-pinned in the separate control repository"
        );
        Ok(())
    }
    pub fn region(&self) -> &str {
        match &self.plan.target {
            Target::Gcp { location, .. } => location,
            _ => unreachable!(),
        }
    }
    pub fn prefix(&self) -> String {
        format!("ow-{}", &self.plan.deployment_id[4..16])
    }
    pub fn bucket(&self) -> String {
        format!("{}-{}-control", project(&self.plan), self.prefix())
    }
    pub fn parent(&self) -> String {
        format!(
            "projects/{}/locations/{}",
            project(&self.plan),
            self.region()
        )
    }
    pub fn deployment(&self) -> String {
        format!("{}/deployments/{}", self.parent(), self.plan.deployment_id)
    }
    pub fn job(&self) -> String {
        format!("{}/jobs/{}-cleanup", self.parent(), self.prefix())
    }
    pub fn source_object(&self) -> String {
        format!(
            "{}/source-{}.zip",
            self.plan.deployment_id, self.source_sha256
        )
    }
    pub fn source_uri(&self) -> String {
        format!(
            "gs://{}/{}#{}",
            self.bucket(),
            self.source_object(),
            self.source_generation
        )
    }
    pub fn checkpoint_object(&self) -> String {
        format!("{}/checkpoint.json", self.plan.deployment_id)
    }
    pub fn sha(&self) -> Result<String> {
        Ok(hash(&json_bytes(self)?))
    }
    pub fn control_object(&self) -> Result<String> {
        Ok(format!(
            "{}/control-{}.json",
            self.plan.deployment_id,
            self.sha()?
        ))
    }
    pub fn control_uri(&self) -> Result<String> {
        Ok(format!("gs://{}/{}", self.bucket(), self.control_object()?))
    }
    pub fn executor(&self) -> String {
        format!(
            "projects/{}/serviceAccounts/{}",
            project(&self.plan),
            accounts(&self.plan)["executor"]
        )
    }
    pub fn request(&self) -> Value {
        json!({"serviceAccount":self.executor(),"terraformBlueprint":{"gcsSource":self.source_uri()},"tfVersionConstraint":format!("={}",self.plan.gcp_infrastructure.as_ref().unwrap().terraform_version),"quotaValidation":"ENFORCED","importExistingResources":false,
            "annotations":{"openworker.dev/bundle":self.bundle_digest,"openworker.dev/request":self.request_id,"openworker.dev/expiry":self.plan.expires_at_unix.to_string()}})
    }
    pub fn operation(&self, s: &str) -> Result<()> {
        suffix(s, &format!("{}/operations/", self.parent()))
    }
    pub fn revision(&self, s: &str) -> Result<()> {
        suffix(s, &format!("{}/revisions/", self.deployment()))
    }
}
fn suffix(s: &str, prefix: &str) -> Result<()> {
    let tail = s
        .strip_prefix(prefix)
        .context("Provider receipt outside deployment scope")?;
    ensure!(
        !tail.is_empty()
            && tail.len() <= 128
            && tail
                .bytes()
                .all(|b| b.is_ascii_alphanumeric() || b"-_".contains(&b)),
        "Invalid provider receipt"
    );
    Ok(())
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub(super) enum Phase {
    Prepared,
    CreateIntent,
    Creating,
    Active,
    CreateFailed,
    DeleteIntent,
    Deleting,
    DeleteFailed,
    ProviderDeleted,
    NamedResourcesAbsent,
    PauseIntent,
    Complete,
    Unused,
    UnusedPauseIntent,
    UnusedComplete,
}
#[derive(Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub(super) struct Checkpoint {
    pub schema_version: u16,
    pub control_sha256: String,
    pub phase: Phase,
    pub create_intent_at: Option<u64>,
    pub delete_intent_at: Option<u64>,
    pub delete_request_id: String,
    pub create_operation: Option<String>,
    pub delete_operation: Option<String>,
    pub create_time: Option<String>,
    pub revision: Option<String>,
    pub guard_uid: Option<String>,
    pub heartbeat_at: Option<u64>,
    #[serde(default)]
    pub assets: Option<Vec<Asset>>,
}
#[derive(Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub(super) struct Asset {
    pub path: String,
    pub id: String,
}
impl Asset {
    pub fn validate(&self, c: &Control) -> Result<()> {
        let zone = &c.plan.gcp_infrastructure.as_ref().unwrap().zone;
        let global = format!(
            "/compute/v1/projects/{}/global/instanceTemplates/",
            project(&c.plan)
        );
        let zonal = format!("/compute/v1/projects/{}/zones/{zone}/", project(&c.plan));
        let tail = if let Some(t) = self.path.strip_prefix(&global) {
            t
        } else {
            let t = self
                .path
                .strip_prefix(&zonal)
                .context("Asset outside deployment zone/project")?;
            let (kind, name) = t.split_once('/').context("Invalid asset path")?;
            ensure!(
                [
                    "instances",
                    "disks",
                    "instanceGroups",
                    "instanceGroupManagers"
                ]
                .contains(&kind),
                "Unexpected dependent asset kind"
            );
            name
        };
        ensure!(
            !tail.is_empty()
                && tail.len() <= 128
                && tail
                    .bytes()
                    .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'-')
                && decimal(&self.id),
            "Invalid immutable asset receipt"
        );
        Ok(())
    }
}
impl Checkpoint {
    pub fn new(c: &Control) -> Result<Self> {
        Ok(Self {
            schema_version: 1,
            control_sha256: c.sha()?,
            phase: Phase::Prepared,
            create_intent_at: None,
            delete_intent_at: None,
            delete_request_id: uuid::Uuid::new_v4().to_string(),
            create_operation: None,
            delete_operation: None,
            create_time: None,
            revision: None,
            guard_uid: None,
            heartbeat_at: None,
            assets: None,
        })
    }
    pub fn validate(&self, c: &Control) -> Result<()> {
        ensure!(
            self.schema_version == 1
                && self.control_sha256 == c.sha()?
                && uuid(&self.delete_request_id),
            "Checkpoint/control mismatch"
        );
        for op in [&self.create_operation, &self.delete_operation]
            .into_iter()
            .flatten()
        {
            c.operation(op)?;
        }
        if let Some(rev) = &self.revision {
            c.revision(rev)?;
        }
        if let Some(time) = &self.create_time {
            unix(time)?;
        }
        if let Some(uid) = &self.guard_uid {
            ensure!(uuid(uid), "Invalid pinned guard UID");
        }
        if matches!(
            self.phase,
            Phase::Creating | Phase::Active | Phase::CreateFailed
        ) {
            ensure!(
                self.create_operation.is_some(),
                "Missing acknowledged create operation"
            );
        }
        if matches!(self.phase, Phase::Active | Phase::CreateFailed) {
            ensure!(
                self.create_time.is_some(),
                "Missing deployment creation receipt"
            );
        }
        if self.phase == Phase::Active {
            ensure!(
                self.revision.is_some(),
                "Active checkpoint requires original revision receipt"
            );
        }
        if matches!(
            self.phase,
            Phase::Deleting
                | Phase::DeleteFailed
                | Phase::ProviderDeleted
                | Phase::NamedResourcesAbsent
                | Phase::PauseIntent
                | Phase::Complete
        ) {
            ensure!(
                self.delete_operation.is_some(),
                "Missing acknowledged delete operation"
            );
        }
        if let Some(assets) = &self.assets {
            ensure!(assets.len() <= 1000, "Dependent asset inventory limit");
            let mut paths = std::collections::BTreeSet::new();
            for asset in assets {
                asset.validate(c)?;
                ensure!(
                    paths.insert(&asset.path),
                    "Duplicate dependent asset receipt"
                );
            }
        }
        ensure!(
            !matches!(
                self.phase,
                Phase::CreateIntent | Phase::Creating | Phase::Active | Phase::CreateFailed
            ) || self.create_intent_at.is_some(),
            "Missing create intent"
        );
        if matches!(
            self.phase,
            Phase::DeleteIntent
                | Phase::Deleting
                | Phase::DeleteFailed
                | Phase::ProviderDeleted
                | Phase::NamedResourcesAbsent
                | Phase::PauseIntent
                | Phase::Complete
        ) {
            ensure!(
                self.create_operation.is_some()
                    && self.create_time.is_some()
                    && self.delete_intent_at.is_some(),
                "Missing ownership/deletion receipts"
            );
        }
        Ok(())
    }
}

// Small deterministic ZIP writer. Fixed file names only; no subprocess or archive dependency.
pub(super) fn source_zip(p: &Plan) -> Result<Vec<u8>> {
    let files = plan_artifacts(p)?;
    let entries = [
        (
            "main.tf.json",
            files
                .get("gcp-main.tf.json")
                .context("GCP graph required")?,
        ),
        (
            ".terraform.lock.hcl",
            files
                .get("gcp-provider.lock.hcl")
                .context("Provider lock required")?,
        ),
    ];
    let mut out = vec![];
    let mut central = vec![];
    for (name, bytes) in entries {
        let offset = out.len() as u32;
        let mut crc = !0u32;
        for b in bytes {
            crc ^= u32::from(*b);
            for _ in 0..8 {
                crc = (crc >> 1) ^ if crc & 1 == 1 { 0xedb88320 } else { 0 }
            }
        }
        crc = !crc;
        out.extend(0x04034b50u32.to_le_bytes());
        for x in [20u16, 0, 0, 0, 33] {
            out.extend(x.to_le_bytes())
        }
        for x in [crc, bytes.len() as u32, bytes.len() as u32] {
            out.extend(x.to_le_bytes())
        }
        out.extend((name.len() as u16).to_le_bytes());
        out.extend(0u16.to_le_bytes());
        out.extend(name.as_bytes());
        out.extend(bytes);
        central.extend(0x02014b50u32.to_le_bytes());
        for x in [0x0314u16, 20, 0, 0, 0, 33] {
            central.extend(x.to_le_bytes())
        }
        for x in [crc, bytes.len() as u32, bytes.len() as u32] {
            central.extend(x.to_le_bytes())
        }
        central.extend((name.len() as u16).to_le_bytes());
        for _ in 0..4 {
            central.extend(0u16.to_le_bytes())
        }
        central.extend((0o100600u32 << 16).to_le_bytes());
        central.extend(offset.to_le_bytes());
        central.extend(name.as_bytes());
    }
    let offset = out.len() as u32;
    let size = central.len() as u32;
    out.extend(central);
    out.extend(0x06054b50u32.to_le_bytes());
    for x in [0u16, 0, 2, 2] {
        out.extend(x.to_le_bytes())
    }
    out.extend(size.to_le_bytes());
    out.extend(offset.to_le_bytes());
    out.extend(0u16.to_le_bytes());
    Ok(out)
}