Rust Algebraic Enums Rejected by k8s

[webern]

Given this Cargo.toml

[package]
name = "untitled15"
version = "0.1.0"
edition = "2018"

[dependencies]
async-trait = "0.1"
k8s-openapi = { version = "0.12", default-features = false, features = ["v1_20"] }
kube = { version = "0.58", default-features = true, features = ["derive"] }
schemars = "0.8"
serde = { version = "1", features = [ "derive" ] }
serde_json = "1"
serde_yaml = "0.8"

This program:

use kube::{CustomResource, CustomResourceExt};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::fs::File;
use std::path::PathBuf;

#[derive(Clone, CustomResource, Debug, Deserialize, JsonSchema, PartialEq, Serialize)]
#[kube(
    derive = "PartialEq",
    group = "example.com",
    kind = "MyCrd",
    namespaced,
    plural = "mycrds",
    singular = "mycrd",
    version = "v1"
)]
pub struct MyCrdSpec {
    rust_enum: RustEnum,
}

#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)]
pub enum RustEnum {
    Something,
    SomethingElse(String),
}

fn main() {
    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("mycrd.yaml");
    println!("{}", path.display());
    let f = File::create(&path).expect(&format!(
        "unable to open file '{}' for writing",
        path.display()
    ));

    serde_yaml::to_writer(&f, &MyCrd::crd()).expect("unable to write mycrd");
}

Which produces this CRD definition:

---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: mycrds.example.com
spec:
  group: example.com
  names:
    kind: MyCrd
    plural: mycrds
    singular: mycrd
  scope: Namespaced
  versions:
    - name: v1
      schema:
        openAPIV3Schema:
          description: "Auto-generated derived type for MyCrdSpec via `CustomResource`"
          properties:
            spec:
              properties:
                rust_enum:
                  anyOf:
                    - enum:
                        - Something
                      type: string
                    - additionalProperties: false
                      properties:
                        SomethingElse:
                          type: string
                      required:
                        - SomethingElse
                      type: object
              required:
                - rust_enum
              type: object
          required:
            - spec
          title: MyCrd
          type: object
      served: true
      storage: true
      subresources: {}

When applying the CRD yaml to a 1.21 kind cluster I get the following error:

The CustomResourceDefinition "mycrds.example.com" is invalid:
* spec.validation.openAPIV3Schema.properties[spec].properties[rust_enum].anyOf[1].additionalProperties: Forbidden: additionalProperties and properties are mutual exclusive
* spec.validation.openAPIV3Schema.properties[spec].properties[rust_enum].anyOf[0].type: Forbidden: must be empty to be structural
* spec.validation.openAPIV3Schema.properties[spec].properties[rust_enum].anyOf[1].additionalProperties: Forbidden: must be undefined to be structural
* spec.validation.openAPIV3Schema.properties[spec].properties[rust_enum].anyOf[1].properties[SomethingElse].type: Forbidden: must be empty to be structural
* spec.validation.openAPIV3Schema.properties[spec].properties[rust_enum].anyOf[1].type: Forbidden: must be empty to be structural
* spec.validation.openAPIV3Schema.properties[spec].properties[rust_enum].type: Required value: must not be empty for specified object fields
FAIL: 1

I have a hard time understanding OpenAPI in general, and the constraints given by https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#specifying-a-structural-schema but the operative constraint appears to be:

does not set description, type, default, additionalProperties, nullable within an allOf, anyOf, oneOf or not, with the exception of the two pattern for x-kubernetes-int-or-string: true (see below).

Does this restriction mean that Rust's algebraic-type enums (i.e. Enum variants with values in them) are explicitly unsupported by k8s? Or is there a way to express what I'm trying to express in a way that k8s will allow and validate? If it is the former (explicitly unsupported), could one of the derive macros raise an error instead of producing the invalid yaml?

Thanks.

[clux]

Structural schemas are not supported yet via schemars.

The relevant issue is in GREsau/schemars#84
It's probably not trivial since no one has solved it since it was reported 6months ago via #129 (comment)
Some more information is also available in #398

I have not had much time to dig into this so that's all I got atm.

[kazk]

The generated schema is not guaranteed to be structural at the moment because it's Kubernetes specific and we're using general schmema derive. I haven't fully understood the requirements either. As far as I know, none of Go frameworks support generating structural schema.

Maybe https://pkg.go.dev/k8s.io/apiextensions-apiserver/pkg/apiserver/schema can help us understand the requirements, and possibly transform the schema.

See #398 (comment) and possible workaround #398 (comment)

[nightkr]

For future reference, there's work on this in #779