Incorrect version specified in apply patch

[JPFrancoia]

Current and expected behavior

I have a function that is supposed to patch a resource:

    // helper to send a merge patch
    pub async fn patch(&self, data: &serde_json::Value) -> Result<()> {
        let mut pp = PatchParams::default();
        pp.field_manager = Some(String::from("application/apply-patch"));
        // Run this patch with a smaller deserialization surface via kube::Resource
        // kube::Api would force ShipcatManifest fully valid here
        // and this would prevent status updates during schema changes.
        println!("patch");
        println!("DATA: {:?}", data);
        let req = self
            .mfs
            .patch_subresource("status", &self.name, &pp, &Patch::Apply(data))
            .map_err(ErrorKind::KubeApi)?;
        let o = self
            .client
            .request::<MinimalMfCrd>(req) // <- difference from using Api::patch_status
            .await
            .map_err(ErrorKind::KubeError)?;
        debug!("Patched status: {:?}", o.status);
        Ok(())
    }

But whenever this function is called, I'm getting this error:

shipcat: apply error: kube api: ApiError: Incorrect version specified in apply patch. Specified patch version: , expected: babylontech.co.uk/v1: BadRequest (ErrorResponse { status: "Failure", message: "Incorrect version specified in apply patch. Specified patch version: , expected: babylontech.co.uk/v1", reason: "BadRequest", code: 400 }): Api(ErrorResponse { status: "Failure", message: "Incorrect version specified in apply patch. Specified patch version: , expected: babylontech.co.uk/v1", reason: "BadRequest", code: 400 })

It looks like my patch doesn't provide a version? To be honest I'm really confused about what's happening here.

Possible solution

No response

Additional context

The content of data:

DATA: Object {"status": Object {"conditions": Object {"generated": Object {"status": Bool(true), "reason": Null, "message": Null, "lastTransitionTime": String("2022-11-18T14:03:38Z"), "source": Object {"name": String("jean-patrickfrancoia"), "url": Null}}}, "summary": Object {"lastSuccessfulGenerate": String("2022-11-18T14:03:38Z"), "lastAction": String("Generate")}}}

Environment

Client Version: v1.21.14
Server Version: v1.21.14-eks-fb459a0

Configuration and features

kube = { version = "0.76.0", features=["rustls-tls"], default-features = false }
k8s-openapi = { version = "0.16.0", features = ["v1_21"]}

Affected crates

No response

Would you like to work on fixing this bug?

No response

[clux]

Looks like your MinimalMfCrd or mfs do not correctly include the apiVersion (you are serializing the empty string for that field, which is not allowed).

[JPFrancoia]

I think it's MinimalMfCrd but I'm not sure. The let req = self... line executes properly, it's really the last command that fails.

#[derive(Clone, Serialize, Deserialize)]
pub struct MinimalManifest {
    pub name: String,
    pub version: String,
}
type MinimalMfCrd = Object<MinimalManifest, ManifestStatus>;

...

/// Status object for shipcatmanifests crd
///
/// All fields optional, but we try to ensure all fields exist.
#[derive(Deserialize, Serialize, Clone, Debug, Default, JsonSchema)]
#[serde(rename_all = "camelCase")]
pub struct ManifestStatus {
    /// Detailed individual conditions, emitted as they happen during apply
    #[serde(default)]
    pub conditions: Conditions,
    /// A more easily readable summary of why the conditions are what they are
    #[serde(default)]
    pub summary: Option<ConditionSummary>,
}

Where does apiVersion come from?

[clux]

MinimalMfCrd is an Object which contains types (TypeMeta) which contains the api_version.

[JPFrancoia]

Hmmmmmmmm I think after banging my head against the walls I figured it out, and I think I've been a bit thick... @clux you have experience with this codebase, I believe you actually wrote the lines I'm debugging haha. But that was years ago and things improved since then.

Years ago, this was the state of the code:

use kube::{
    api::{Api, DeleteParams, ListParams, LogParams, Object, ObjectList, PatchParams, Resource},
    client::APIClient,
};

pub struct ShipKube {
    mfs: Resource,
    client: APIClient,
    pub(crate) applier: Applier,
    api: Api<ShipcatManifest>,
    name: String,
    namespace: String,
}

impl ShipKube {
    // helper to send a merge patch
    pub async fn patch(&self, data: &serde_json::Value) -> Result<()> {
        let pp = PatchParams::default();
        // Run this patch with a smaller deserialization surface via kube::Resource
        // kube::Api would force ShipcatManifest fully valid here
        // and this would prevent status updates during schema changes.
        let req = self
            .mfs
            .patch_status(&self.name, &pp, serde_json::to_vec(data)?)
            .map_err(ErrorKind::KubeError)?;
        let o = self
            .client
            .request::<MinimalMfCrd>(req) // <- difference from using Api::patch_status
            .await
            .map_err(ErrorKind::KubeError)?;
        debug!("Patched status: {:?}", o.status);
        Ok(())
    }
}

mfs was a Resource and we used to patch its status and then we used to push the changes with the Client.

But when I ported the code to a more recent api of the kubecrate, I did this:

/// Interface for dealing with kubernetes shipcatmanifests
pub struct ShipKube {
    mfs: Request,
    client: Client,
    pub(crate) applier: Applier,
    api: Api<ShipcatManifest>,
    name: String,
    namespace: String,
}

/// Entry points for shipcat::apply, and shipcat::status
impl ShipKube {
    pub async fn new_within(svc: &str, ns: &str) -> Result<Self> {
        // hide the client in here -> Api resource for now (not needed elsewhere)
        let client = make_client().await?;

        // https://github.com/kube-rs/kube/pull/474/files
        let url = ShipcatManifest::url_path(&(), Some(ns));
        let mfs = Request::new(url);

        let api = Api::namespaced(client.clone(), ns);

        Ok(Self {
            name: svc.to_string(),
            namespace: ns.to_string(),
            applier: Applier::infer(),
            api,
            client,
            mfs,
        })
    }
}

mfs is now a Request. So I believe I can just do that now:

    // helper to send a merge patch
    pub async fn patch(&self, data: &serde_json::Value) -> Result<()> {
        let mut pp = PatchParams::default();
        pp.field_manager = Some(String::from("application/apply-patch+json"));
        println!("DATA: {:?}", data);
        self.mfs.patch_subresource("status", &self.name, &pp, &Patch::Apply(data)).map_err(ErrorKind::KubeApi)?;

        Ok(())
    }

I tried it and it seems to work. This is specific to my company but in the console output I can see:

DATA: Object {"status": Object {"conditions": Object {"rolledout": Object {"status": Bool(true), "reason": Null, "message": Null, "lastTransitionTime": String("2022-11-20T17:01:30Z"), "source": Object {"name": String("jean-patrickfrancoia"), "url": Null}}}, "summary": Object {"lastRollout": String("2022-11-20T17:01:30Z"), "lastSuccessfulRollout": String("2022-11-20T17:01:30Z"), "lastFailureReason": Null, "lastAction": String("Rollout"), "lastSuccessfulRolloutVersion": String("0.171.12")}}}

Does that seem tangible to you?

[clux]

That looks reasonable to me. Just be aware that when using server side apply you generally need to include the kubernetes types of the manifest in the json patch: https://github.com/kube-rs/kube/blob/main/examples/crd_apply.rs#L67-L74

But if you got it working then it's probably good.

[clux]

Btw: you are setting field manager to a header value, which is weird. It's just an arbitrary string used to indicate the fields owner. It has otherwise no request-specific behaviour.

[JPFrancoia]

Btw: you are setting field manager to a header value, which is weird. It's just an arbitrary string used to indicate the fields owner. It has otherwise no request-specific behaviour.

Oh yeah, I added that but it was for the second instruction, it's actually not needed indeed.

Thanks again for your help, everything seems to be working now!