Patch implementation for unstable client

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

Author: Danil-Grigorev

kube-client/src/client/client_ext.rs

@@ -5,9 +5,10 @@ use k8s_openapi::{
 };
 use kube_core::{
     object::ObjectList,
-    params::{GetParams, ListParams},
+    params::{GetParams, ListParams, Patch, PatchParams},
     request::Request,
-    ApiResource, ClusterResourceScope, DynamicResourceScope, NamespaceResourceScope, Resource,
+    ApiResource, ClusterResourceScope, DynamicResourceScope, NamespaceResourceScope, ObjectMeta, Resource,
+    ResourceExt,
 };
 use serde::{de::DeserializeOwned, Serialize};
 use std::fmt::Debug;
@@ -149,7 +150,7 @@ where
 
 /// Scopes for `unstable-client` [`Client#impl-Client`] extension methods
 pub mod scope {
-    pub use super::{Cluster, Namespace, NamespacedRef};
+    pub use super::{Cluster, Namespace, NamespacedRef, Subresource};
 }
 
 // All objects can be listed cluster-wide
@@ -230,6 +231,15 @@ pub enum NamespaceError {
     MissingName,
 }
 
+#[derive(Default)]
+pub enum Subresource {
+    #[default]
+    Core,
+    Status,
+    Scale,
+    Custom(String),
+}
+
 /// Generic client extensions for the `unstable-client` feature
 ///
 /// These methods allow users to query across a wide-array of resources without needing
@@ -385,6 +395,54 @@ impl Client {
         req.extensions_mut().insert("list");
         self.request::<ObjectList<K>>(req).await
     }
+
+    /// Patch provided `Resource` implementing type `K`
+    ///
+    /// ```no_run
+    /// # use k8s_openapi::api::core::v1::Pod;
+    /// # use k8s_openapi::api::core::v1::Service;
+    /// # use kube::client::scope::{Namespace, Subresource};
+    /// # use kube::prelude::*;
+    /// # use kube::api::{PatchParams, Patch};
+    /// # async fn wrapper() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let client: kube::Client = todo!();
+    /// let pod: Pod = client.get("some_pod", &Namespace::from("default")).await?;
+    /// let pp = &PatchParams::apply("controller").force();
+    /// // Perform an apply patch on the resource
+    /// client.patch(pod, pp, &Patch::Apply(&pod), &Default::default()).await?;
+    /// // Perform an apply patch on the resource status
+    /// client.patch(pod, pp, &Patch::Apply(&pod), &Subresource::Status).await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub async fn patch<K, P: Serialize + Debug>(
+        &self,
+        resource: &K,
+        pp: &PatchParams,
+        patch: &Patch<P>,
+        subresource: &Subresource,
+    ) -> Result<K>
+    where
+        K: ResourceExt + Serialize + DeserializeOwned + Clone + Debug,
+        <K as Resource>::DynamicType: Default,
+    {
+        let name = resource.meta().name.as_ref().ok_or(Error::NameResolve)?;
+        let url = K::url_path(&Default::default(), resource.meta().namespace.as_deref());
+        let req = Request::new(url);
+        let req = match subresource {
+            Subresource::Core => req.patch(name, pp, patch).map_err(Error::BuildRequest)?,
+            Subresource::Status => req
+                .patch_subresource("status", name, pp, patch)
+                .map_err(Error::BuildRequest)?,
+            Subresource::Scale => req
+                .patch_subresource("scale", name, pp, patch)
+                .map_err(Error::BuildRequest)?,
+            Subresource::Custom(subresource) => req
+                .patch_subresource(subresource, name, pp, patch)
+                .map_err(Error::BuildRequest)?,
+        };
+        self.request::<K>(req).await
+    }
 }
 
 // Resource url_path resolver

kube-client/src/error.rs

@@ -92,6 +92,12 @@ pub enum Error {
     #[cfg_attr(docsrs, doc(cfg(feature = "unstable-client")))]
     #[error("Reference resolve error: {0}")]
     RefResolve(String),
+
+    /// Error resolving resource name
+    #[cfg(feature = "unstable-client")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "unstable-client")))]
+    #[error("Resource has no name")]
+    NameResolve,
 }
 
 #[derive(Error, Debug)]