Reducing common struct types

Signed-off-by: Dawid Nowak <[email protected]>

Author: dawid-nowak

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace]
-members = ["gateway-api", "gateway-api/examples", "xtask"]
+members = ["gateway-api", "gateway-api/examples", "xtask", "type-reducer"]
 resolver = "2"
 
 [workspace.package]

Cargo.toml

@@ -38,5 +38,7 @@ uuid.workspace = true
 features = ["k8s-openapi/v1_32"]
 
 [features]
-default = []
+default = ["processed"]
+standard = []
 experimental = []
+processed=[]

gateway-api/Cargo.toml

@@ -1,2 +1,3 @@
 pub mod experimental;
 pub mod standard;
+pub mod processed;

gateway-api/src/apis/mod.rs

@@ -0,0 +1,78 @@
+// WARNING! generated file do not edit
+
+#[allow(unused_imports)]
+mod prelude {
+    pub use k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition;
+    pub use kube::CustomResource;
+    pub use schemars::JsonSchema;
+    pub use serde::{Deserialize, Serialize};
+    pub use std::collections::BTreeMap;
+}
+use self::prelude::*;
+#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema, Default, PartialEq)]
+pub struct HeaderModifierRules {
+    pub name: String,
+    pub value: String,
+}
+#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema, Default, PartialEq)]
+pub struct Kind {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group: Option<String>,
+    pub kind: String,
+}
+#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema, Default, PartialEq)]
+pub struct MirrorBackendRef {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kind: Option<String>,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub namespace: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<i32>,
+}
+#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema, Default, PartialEq)]
+pub struct RouteRef {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kind: Option<String>,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub namespace: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none", rename = "sectionName")]
+    pub section_name: Option<String>,
+}
+#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema, Default, PartialEq)]
+pub struct GatewayAddress {
+    #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
+    pub r#type: Option<String>,
+    pub value: String,
+}
+#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema, Default, PartialEq)]
+pub struct ExtensionBackendRef {
+    pub group: String,
+    pub kind: String,
+    pub name: String,
+}
+
+
+// Next attempt 
+
+#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema, Default, PartialEq)]
+pub struct FilterMirrorRouteRules {
+    #[serde(rename = "backendRef")]
+    pub backend_ref: MirrorBackendRef,
+}
+#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema, Default, PartialEq)]
+pub struct FilterHeaderRouteRules {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub add: Option<Vec<HeaderModifierRules>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub remove: Option<Vec<String>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub set: Option<Vec<HeaderModifierRules>>,
+}

gateway-api/src/apis/processed/common_types.rs

@@ -0,0 +1,90 @@
+// WARNING! generated file do not edit
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum GatewayClassConditionType {
+    Accepted,
+}
+impl std::fmt::Display for GatewayClassConditionType {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+#[derive(Debug, PartialEq, Eq)]
+pub enum GatewayClassConditionReason {
+    Accepted,
+    InvalidParameters,
+    Pending,
+    Unsupported,
+    Waiting,
+}
+impl std::fmt::Display for GatewayClassConditionReason {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+#[derive(Debug, PartialEq, Eq)]
+pub enum GatewayConditionType {
+    Programmed,
+    Accepted,
+    Ready,
+}
+impl std::fmt::Display for GatewayConditionType {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+#[derive(Debug, PartialEq, Eq)]
+pub enum GatewayConditionReason {
+    Programmed,
+    Invalid,
+    NoResources,
+    AddressNotAssigned,
+    AddressNotUsable,
+    Accepted,
+    ListenersNotValid,
+    Pending,
+    UnsupportedAddress,
+    InvalidParameters,
+    Ready,
+    ListenersNotReady,
+}
+impl std::fmt::Display for GatewayConditionReason {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+#[derive(Debug, PartialEq, Eq)]
+pub enum ListenerConditionType {
+    Conflicted,
+    Accepted,
+    ResolvedRefs,
+    Programmed,
+    Ready,
+}
+impl std::fmt::Display for ListenerConditionType {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+#[derive(Debug, PartialEq, Eq)]
+pub enum ListenerConditionReason {
+    HostnameConflict,
+    ProtocolConflict,
+    NoConflicts,
+    Accepted,
+    PortUnavailable,
+    UnsupportedProtocol,
+    ResolvedRefs,
+    InvalidCertificateRef,
+    InvalidRouteKinds,
+    RefNotPermitted,
+    Programmed,
+    Invalid,
+    Pending,
+    Ready,
+}
+impl std::fmt::Display for ListenerConditionReason {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}

gateway-api/src/apis/processed/constants.rs

@@ -0,0 +1,50 @@
+// WARNING! generated file do not edit
+
+use super::httproutes::{
+    HTTPRouteRulesBackendRefsFiltersRequestRedirectPathType,
+    HTTPRouteRulesBackendRefsFiltersType,
+    HTTPRouteRulesBackendRefsFiltersUrlRewritePathType,
+    HTTPRouteRulesFiltersRequestRedirectPathType, HTTPRouteRulesFiltersType,
+    HTTPRouteRulesFiltersUrlRewritePathType,
+};
+use super::grpcroutes::{GRPCRouteRulesBackendRefsFiltersType, GRPCRouteRulesFiltersType};
+impl Default for GRPCRouteRulesBackendRefsFiltersType {
+    fn default() -> Self {
+        GRPCRouteRulesBackendRefsFiltersType::RequestHeaderModifier
+    }
+}
+impl Default for GRPCRouteRulesFiltersType {
+    fn default() -> Self {
+        GRPCRouteRulesFiltersType::RequestHeaderModifier
+    }
+}
+impl Default for HTTPRouteRulesBackendRefsFiltersRequestRedirectPathType {
+    fn default() -> Self {
+        HTTPRouteRulesBackendRefsFiltersRequestRedirectPathType::ReplaceFullPath
+    }
+}
+impl Default for HTTPRouteRulesBackendRefsFiltersType {
+    fn default() -> Self {
+        HTTPRouteRulesBackendRefsFiltersType::RequestHeaderModifier
+    }
+}
+impl Default for HTTPRouteRulesBackendRefsFiltersUrlRewritePathType {
+    fn default() -> Self {
+        HTTPRouteRulesBackendRefsFiltersUrlRewritePathType::ReplaceFullPath
+    }
+}
+impl Default for HTTPRouteRulesFiltersRequestRedirectPathType {
+    fn default() -> Self {
+        HTTPRouteRulesFiltersRequestRedirectPathType::ReplaceFullPath
+    }
+}
+impl Default for HTTPRouteRulesFiltersType {
+    fn default() -> Self {
+        HTTPRouteRulesFiltersType::RequestHeaderModifier
+    }
+}
+impl Default for HTTPRouteRulesFiltersUrlRewritePathType {
+    fn default() -> Self {
+        HTTPRouteRulesFiltersUrlRewritePathType::ReplaceFullPath
+    }
+}

gateway-api/src/apis/processed/enum_defaults.rs

@@ -0,0 +1,111 @@
+// WARNING! generated file do not edit
+
+#[allow(unused_imports)]
+mod prelude {
+    pub use k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition;
+    pub use kube::CustomResource;
+    pub use schemars::JsonSchema;
+    pub use serde::{Deserialize, Serialize};
+}
+use self::prelude::*;
+/// Spec defines the desired state of GatewayClass.
+#[derive(
+    CustomResource,
+    Serialize,
+    Deserialize,
+    Clone,
+    Debug,
+    JsonSchema,
+    Default,
+    PartialEq
+)]
+#[kube(
+    group = "gateway.networking.k8s.io",
+    version = "v1",
+    kind = "GatewayClass",
+    plural = "gatewayclasses"
+)]
+#[kube(status = "GatewayClassStatus")]
+#[kube(derive = "Default")]
+#[kube(derive = "PartialEq")]
+pub struct GatewayClassSpec {
+    /// ControllerName is the name of the controller that is managing Gateways of
+    /// this class. The value of this field MUST be a domain prefixed path.
+    ///
+    /// Example: "example.net/gateway-controller".
+    ///
+    /// This field is not mutable and cannot be empty.
+    ///
+    /// Support: Core
+    #[serde(rename = "controllerName")]
+    pub controller_name: String,
+    /// Description helps describe a GatewayClass with more details.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    /// ParametersRef is a reference to a resource that contains the configuration
+    /// parameters corresponding to the GatewayClass. This is optional if the
+    /// controller does not require any additional configuration.
+    ///
+    /// ParametersRef can reference a standard Kubernetes resource, i.e. ConfigMap,
+    /// or an implementation-specific custom resource. The resource can be
+    /// cluster-scoped or namespace-scoped.
+    ///
+    /// If the referent cannot be found, refers to an unsupported kind, or when
+    /// the data within that resource is malformed, the GatewayClass SHOULD be
+    /// rejected with the "Accepted" status condition set to "False" and an
+    /// "InvalidParameters" reason.
+    ///
+    /// A Gateway for this GatewayClass may provide its own `parametersRef`. When both are specified,
+    /// the merging behavior is implementation specific.
+    /// It is generally recommended that GatewayClass provides defaults that can be overridden by a Gateway.
+    ///
+    /// Support: Implementation-specific
+    #[serde(default, skip_serializing_if = "Option::is_none", rename = "parametersRef")]
+    pub parameters_ref: Option<GatewayClassParametersRef>,
+}
+/// ParametersRef is a reference to a resource that contains the configuration
+/// parameters corresponding to the GatewayClass. This is optional if the
+/// controller does not require any additional configuration.
+///
+/// ParametersRef can reference a standard Kubernetes resource, i.e. ConfigMap,
+/// or an implementation-specific custom resource. The resource can be
+/// cluster-scoped or namespace-scoped.
+///
+/// If the referent cannot be found, refers to an unsupported kind, or when
+/// the data within that resource is malformed, the GatewayClass SHOULD be
+/// rejected with the "Accepted" status condition set to "False" and an
+/// "InvalidParameters" reason.
+///
+/// A Gateway for this GatewayClass may provide its own `parametersRef`. When both are specified,
+/// the merging behavior is implementation specific.
+/// It is generally recommended that GatewayClass provides defaults that can be overridden by a Gateway.
+///
+/// Support: Implementation-specific
+#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema, Default, PartialEq)]
+pub struct GatewayClassParametersRef {
+    /// Group is the group of the referent.
+    pub group: String,
+    /// Kind is kind of the referent.
+    pub kind: String,
+    /// Name is the name of the referent.
+    pub name: String,
+    /// Namespace is the namespace of the referent.
+    /// This field is required when referring to a Namespace-scoped resource and
+    /// MUST be unset when referring to a Cluster-scoped resource.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub namespace: Option<String>,
+}
+/// Status defines the current state of GatewayClass.
+///
+/// Implementations MUST populate status on all GatewayClass resources which
+/// specify their controller name.
+#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema, Default, PartialEq)]
+pub struct GatewayClassStatus {
+    /// Conditions is the current status from the controller for
+    /// this GatewayClass.
+    ///
+    /// Controllers should prefer to publish conditions using values
+    /// of GatewayClassConditionType for the type of each Condition.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conditions: Option<Vec<Condition>>,
+}