Add BackendObjectReference to BackendRef (#47)

BackendRef is a shared type used by routes that may match traffic to an
arbitrary backend (other than the `Service` they are attached to). Our
current bindings take a simplified approach of representing this by
assuming the type is always a `Service`. Several fields are missing
(gvk, namespace). This makes it hard to work with the types in code,
and it makes it hard to add validation logic since the unserialized
objects will be missing the gvk reference.

This change removes the fields in favour of adding an inner
`BackendObjectReference` type that already exists in the bindings. This
will make it so that any serialization takes into account the actual
type of the backend the route has.

Signed-off-by: Matei David <[email protected]>

Author: mateiidavid

integration/tests/httproute.rs

@@ -1,6 +1,6 @@
 use k8s_gateway_api::{
-    BackendRef, HttpBackendRef, HttpHeaderMatch, HttpRoute, HttpRouteMatch, HttpRouteRule,
-    HttpRouteSpec,
+    BackendObjectReference, BackendRef, HttpBackendRef, HttpHeaderMatch, HttpRoute, HttpRouteMatch,
+    HttpRouteRule, HttpRouteSpec,
 };
 use kube::{api::PostParams, core::ObjectMeta};
 
@@ -26,16 +26,14 @@ async fn round_trip() {
                     backend_refs: Some(vec![
                         HttpBackendRef {
                             backend_ref: Some(BackendRef {
-                                name: "bar-v1".to_string(),
-                                port: 8080,
+                                inner: mk_inner_ref("bar-v1", None, Some(8080)),
                                 weight: Some(90),
                             }),
                             filters: None,
                         },
                         HttpBackendRef {
                             backend_ref: Some(BackendRef {
-                                name: "bar-v2".to_string(),
-                                port: 8080,
+                                inner: mk_inner_ref("bar-v2", None, Some(8080)),
                                 weight: Some(10),
                             }),
                             filters: None,
@@ -54,8 +52,7 @@ async fn round_trip() {
                     }]),
                     backend_refs: Some(vec![HttpBackendRef {
                         backend_ref: Some(BackendRef {
-                            name: "bar-v2".to_string(),
-                            port: 8080,
+                            inner: mk_inner_ref("bar-v2", None, Some(8080)),
                             weight: None,
                         }),
                         filters: None,
@@ -81,3 +78,17 @@ async fn round_trip() {
         .await
         .expect("failed to delete resource");
 }
+
+fn mk_inner_ref(
+    name: &str,
+    namespace: Option<String>,
+    port: Option<u16>,
+) -> BackendObjectReference {
+    BackendObjectReference {
+        group: None, // core group inferred
+        kind: None,  // defaults to Service when not specified
+        name: name.to_string(),
+        namespace, // defaults to local namespace when unspecified
+        port,
+    }
+}

src/shared.rs

@@ -1,5 +1,7 @@
 use k8s_openapi::apimachinery::pkg::apis::meta::v1 as metav1;
 
+use crate::BackendObjectReference;
+
 /// ParentReference identifies an API object (usually a Gateway) that can be considered
 /// a parent of this resource (usually a route). The only kind of parent resource
 /// with "Core" support is Gateway. This API may be extended in the future to
@@ -141,9 +143,9 @@ pub struct BackendRef {
     /// Support for this field varies based on the context where used.
     pub weight: Option<u16>,
 
-    pub name: String,
-
-    pub port: PortNumber,
+    /// BackendObjectReference references a Kubernetes object.
+    #[serde(flatten)]
+    pub inner: BackendObjectReference,
 }
 
 /// RouteConditionType is a type of condition for a route.