Implement native object reference fetching

Signed-off-by: Danil-Grigorev <[email protected]>

kube-client/src/client/client_ext.rs

@@ -1,5 +1,8 @@
 use crate::{Client, Error, Result};
-use k8s_openapi::api::core::v1::Namespace as k8sNs;
+use k8s_openapi::{
+    api::core::v1::{Namespace as k8sNs, ObjectReference},
+    apimachinery::pkg::apis::meta::v1::OwnerReference,
+};
 use kube_core::{
     object::ObjectList,
     params::{GetParams, ListParams},
@@ -42,9 +45,92 @@ pub struct Cluster;
 /// You can create this directly, or convert `From` a `String` / `&str`, or `TryFrom` an `k8s_openapi::api::core::v1::Namespace`
 pub struct Namespace(String);
 
+/// Referenced object name resolution
+pub trait ObjectRef<K>: ObjectUrl<K> {
+    fn name(&self) -> Option<&str>;
+}
+
+/// Reference resolver for a specified namespace
+pub trait NamespacedRef<K>: ObjectRef<K> {
+    /// Resolve reference in the provided namespace
+    fn within(&self, namespace: String) -> impl ObjectRef<K>;
+}
+
+impl<K> ObjectUrl<K> for ObjectReference
+where
+    K: Resource,
+    K::DynamicType: Default,
+{
+    fn url_path(&self) -> String {
+        K::url_path(&K::DynamicType::default(), self.namespace.as_deref())
+    }
+}
+
+impl<K> ObjectRef<K> for ObjectReference
+where
+    K: Resource,
+    K::DynamicType: Default,
+{
+    fn name(&self) -> Option<&str> {
+        self.name.as_deref()
+    }
+}
+
+impl<K> NamespacedRef<K> for ObjectReference
+where
+    K: Resource,
+    K::DynamicType: Default,
+    K::Scope: NamespaceScope,
+{
+    fn within(&self, namespace: String) -> impl ObjectRef<K> {
+        Self {
+            namespace: namespace.into(),
+            ..self.clone()
+        }
+    }
+}
+
+impl<K> ObjectUrl<K> for OwnerReference
+where
+    K: Resource,
+    K::DynamicType: Default,
+{
+    fn url_path(&self) -> String {
+        K::url_path(&K::DynamicType::default(), None)
+    }
+}
+
+impl<K> ObjectRef<K> for OwnerReference
+where
+    K: Resource,
+    K::DynamicType: Default,
+{
+    fn name(&self) -> Option<&str> {
+        self.name.as_str().into()
+    }
+}
+
+impl<K> NamespacedRef<K> for OwnerReference
+where
+    K: Resource,
+    K::DynamicType: Default,
+    K::Scope: NamespaceScope,
+{
+    fn within(&self, namespace: String) -> impl ObjectRef<K> {
+        ObjectReference {
+            namespace: namespace.into(),
+            name: self.name.clone().into(),
+            uid: self.uid.clone().into(),
+            api_version: Some(K::api_version(&Default::default()).into()),
+            kind: Some(K::kind(&Default::default()).into()),
+            ..Default::default()
+        }
+    }
+}
+
 /// Scopes for `unstable-client` [`Client#impl-Client`] extension methods
 pub mod scope {
-    pub use super::{Cluster, Namespace};
+    pub use super::{Cluster, Namespace, NamespacedRef};
 }
 
 // All objects can be listed cluster-wide
@@ -184,6 +270,52 @@ impl Client {
         self.request::<K>(req).await
     }
 
+    /// Fetch a single instance of a `Resource` from a provided object reference.
+    ///
+    /// ```no_run
+    /// # use k8s_openapi::api::rbac::v1::ClusterRole;
+    /// # use k8s_openapi::api::core::v1::Service;
+    /// # use k8s_openapi::api::core::v1::ObjectReference;
+    /// # use k8s_openapi::api::core::v1::{Node, Pod};
+    /// # use kube::{Resource, ResourceExt, api::GetParams};
+    /// # use kube::client::scope::NamespacedRef;
+    /// # async fn wrapper() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let client: kube::Client = todo!();
+    /// // cluster scoped
+    /// let cr: ClusterRole = todo!();
+    /// let cr: ClusterRole = client.fetch(&cr.object_ref(&())).await?;
+    /// assert_eq!(cr.name_unchecked(), "cluster-admin");
+    /// // namespace scoped
+    /// let svc: Service = todo!();
+    /// let svc: Service = client.fetch(&svc.object_ref(&())).await?;
+    /// assert_eq!(svc.name_unchecked(), "kubernetes");
+    /// // Fetch an owner of the resource
+    /// let pod: Pod = todo!();
+    /// let owner = pod
+    ///     .owner_references()
+    ///     .to_vec()
+    ///     .into_iter()
+    ///     .find(|r| r.kind == Node::kind(&()))
+    ///     .ok_or("Not Found")?;
+    /// let node: Node = client.fetch(&owner).await?;
+    /// let node: Pod = client.fetch(&owner.within("ns".into())).await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub async fn fetch<K>(&self, reference: &impl ObjectRef<K>) -> Result<K>
+    where
+        K: Resource + Serialize + DeserializeOwned + Clone + Debug,
+        <K as Resource>::DynamicType: Default,
+    {
+        self.get(
+            reference
+                .name()
+                .ok_or(Error::RefResolve("Reference is empty".to_string()))?,
+            reference,
+        )
+        .await
+    }
+
     /// List instances of a `Resource` implementing type `K` at the specified scope.
     ///
     /// ```no_run
@@ -222,7 +354,7 @@ mod test {
         scope::{Cluster, Namespace},
         Client, ListParams,
     };
-    use kube_core::ResourceExt;
+    use kube_core::{Resource, ResourceExt};
 
     #[tokio::test]
     #[ignore = "needs cluster (will list/get namespaces, pods, jobs, svcs, clusterroles)"]
@@ -256,4 +388,55 @@ mod test {
 
         Ok(())
     }
+
+    #[tokio::test]
+    #[ignore = "needs cluster (will get svcs, clusterroles, pods, nodes)"]
+    async fn client_ext_fetch_ref_pods_svcs() -> Result<(), Box<dyn std::error::Error>> {
+        use k8s_openapi::api::{
+            core::v1::{Node, ObjectReference, Pod, Service},
+            rbac::v1::ClusterRole,
+        };
+
+        let client = Client::try_default().await?;
+        // namespaced fetch
+        let svc: Service = client
+            .fetch(&ObjectReference {
+                kind: Some(Service::kind(&()).into()),
+                api_version: Some(Service::api_version(&()).into()),
+                name: Some("kubernetes".into()),
+                namespace: Some("default".into()),
+                ..Default::default()
+            })
+            .await?;
+        assert_eq!(svc.name_unchecked(), "kubernetes");
+        // global fetch
+        let ca: ClusterRole = client
+            .fetch(&ObjectReference {
+                kind: Some(ClusterRole::kind(&()).into()),
+                api_version: Some(ClusterRole::api_version(&()).into()),
+                name: Some("cluster-admin".into()),
+                ..Default::default()
+            })
+            .await?;
+        assert_eq!(ca.name_unchecked(), "cluster-admin");
+
+        let kube_system: Namespace = "kube-system".into();
+        for pod in client
+            .list::<Pod>(
+                &ListParams::default().labels("component=kube-apiserver"),
+                &kube_system,
+            )
+            .await?
+        {
+            let owner = pod
+                .owner_references()
+                .to_vec()
+                .into_iter()
+                .find(|r| r.kind == Node::kind(&()))
+                .ok_or("Not found")?;
+            let _: Node = client.fetch(&owner).await?;
+        }
+
+        Ok(())
+    }
 }

kube-client/src/error.rs

@@ -86,6 +86,12 @@ pub enum Error {
     #[cfg_attr(docsrs, doc(cfg(feature = "client")))]
     #[error("auth error: {0}")]
     Auth(#[source] crate::client::AuthError),
+
+    /// Error resolving resource reference
+    #[cfg(feature = "unstable-client")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "unstable-client")))]
+    #[error("Reference resolve error: {0}")]
+    RefResolve(String),
 }
 
 #[derive(Error, Debug)]