Add Resource derive macro

examples/errorbounded_configmap_watcher.rs

@@ -1,9 +1,7 @@
-use std::borrow::Cow;
-
 use futures::prelude::*;
-use k8s_openapi::{api::core::v1::Pod, NamespaceResourceScope};
+use k8s_openapi::api::core::v1::ConfigMap;
 use kube::{
-    api::{Api, ObjectMeta, ResourceExt},
+    api::{Api, ObjectMeta},
     core::DeserializeGuard,
     runtime::{reflector::ObjectRef, watcher, WatchStreamExt},
     Client, Resource,
@@ -13,7 +11,8 @@ use tracing::*;
 
 // Variant of ConfigMap that only accepts ConfigMaps with a CA certificate
 // to demonstrate parsing failure
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Resource, Deserialize, Debug, Clone)]
+#[inherit(resource = ConfigMap)]
 struct CaConfigMap {
     metadata: ObjectMeta,
     data: CaConfigMapData,
@@ -25,36 +24,6 @@ struct CaConfigMapData {
     ca_crt: String,
 }
 
-// Normally you would derive this, but ConfigMap doesn't follow the standard spec/status pattern
-impl Resource for CaConfigMap {
-    type DynamicType = ();
-    type Scope = NamespaceResourceScope;
-
-    fn kind(&(): &Self::DynamicType) -> Cow<'_, str> {
-        Cow::Borrowed("ConfigMap")
-    }
-
-    fn group(&(): &Self::DynamicType) -> Cow<'_, str> {
-        Cow::Borrowed("")
-    }
-
-    fn version(&(): &Self::DynamicType) -> Cow<'_, str> {
-        Cow::Borrowed("v1")
-    }
-
-    fn plural(&(): &Self::DynamicType) -> Cow<'_, str> {
-        Cow::Borrowed("configmaps")
-    }
-
-    fn meta(&self) -> &ObjectMeta {
-        &self.metadata
-    }
-
-    fn meta_mut(&mut self) -> &mut ObjectMeta {
-        &mut self.metadata
-    }
-}
-
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     tracing_subscriber::fmt::init();

kube-derive/src/lib.rs

@@ -4,6 +4,7 @@
 #[macro_use] extern crate quote;
 
 mod custom_resource;
+mod resource;
 
 /// A custom derive for kubernetes custom resource definitions.
 ///
@@ -308,3 +309,49 @@
 pub fn derive_custom_resource(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     custom_resource::derive(proc_macro2::TokenStream::from(input)).into()
 }
+
+/// A custom derive for inheriting Resource impl for the type.
+///
+/// This will generate a [`kube::Resource`] trait implementation, which inherits the specified
+/// resources trait implementation.
+///
+/// Such implementation allows to add strict typing to some typical resources like `Secret` or `ConfigMap`,
+/// in cases when implementing CRD is not desirable or it does not fit the use-case.
+///
+/// This object can be used with [`kube::Api`].
+///
+/// # Example
+///
+/// ```rust,no_run
+/// use kube::api::ObjectMeta;
+/// use k8s_openapi::api::core::v1::ConfigMap;
+/// use kube_derive::Resource;
+/// use kube::Client;
+/// use kube::Api;
+/// use serde::Deserialize;
+///
+/// #[derive(Resource, Clone, Debug, Deserialize)]
+/// #[inherit(resource = "ConfigMap")]
+/// struct FooMap {
+///     metadata: ObjectMeta,
+///     data: Option<FooMapSpec>,
+/// }
+///
+/// #[derive(Clone, Debug, Deserialize)]
+/// struct FooMapSpec {
+///     field: String,
+/// }
+///
+/// let client: Client = todo!();
+/// let api: Api<FooMap> = Api::default_namespaced(client);
+/// let config_map = api.get("with-field");
+/// ```
+///
+/// The example above will generate:
+/// ```
+/// // impl kube::Resource for FooMap { .. }
+/// ```
+#[proc_macro_derive(Resource, attributes(inherit))]
+pub fn derive_resource_inherit(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    resource::derive(proc_macro2::TokenStream::from(input)).into()
+}

kube-derive/src/resource.rs

@@ -0,0 +1,127 @@
+// Generated by darling macros, out of our control
+#![allow(clippy::manual_unwrap_or_default)]
+
+use darling::{FromDeriveInput, FromMeta};
+use syn::{parse_quote, Data, DeriveInput, Path};
+
+/// Values we can parse from #[kube(attrs)]
+#[derive(Debug, FromDeriveInput)]
+#[darling(attributes(inherit))]
+struct InheritAttrs {
+    resource: syn::Path,
+    #[darling(default)]
+    crates: Crates,
+}
+
+#[derive(Debug, FromMeta)]
+struct Crates {
+    #[darling(default = "Self::default_kube_core")]
+    kube_core: Path,
+    #[darling(default = "Self::default_k8s_openapi")]
+    k8s_openapi: Path,
+}
+
+// Default is required when the subattribute isn't mentioned at all
+// Delegate to darling rather than deriving, so that we can piggyback off the `#[darling(default)]` clauses
+impl Default for Crates {
+    fn default() -> Self {
+        Self::from_list(&[]).unwrap()
+    }
+}
+
+impl Crates {
+    fn default_kube_core() -> Path {
+        parse_quote! { ::kube::core } // by default must work well with people using facade crate
+    }
+
+    fn default_k8s_openapi() -> Path {
+        parse_quote! { ::k8s_openapi }
+    }
+}
+
+pub(crate) fn derive(input: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+    let derive_input: DeriveInput = match syn::parse2(input) {
+        Err(err) => return err.to_compile_error(),
+        Ok(di) => di,
+    };
+    // Limit derive to structs
+    match derive_input.data {
+        Data::Struct(_) | Data::Enum(_) => {}
+        _ => {
+            return syn::Error::new_spanned(&derive_input.ident, r#"Unions can not #[derive(Resource)]"#)
+                .to_compile_error()
+        }
+    }
+    let kube_attrs = match InheritAttrs::from_derive_input(&derive_input) {
+        Err(err) => return err.write_errors(),
+        Ok(attrs) => attrs,
+    };
+
+    let InheritAttrs {
+        resource,
+        crates: Crates {
+            kube_core,
+            k8s_openapi,
+        },
+        ..
+    } = kube_attrs;
+
+    let rootident = derive_input.ident;
+
+    let inherit_resource = quote! {
+        impl #kube_core::Resource for #rootident {
+            type DynamicType = <#resource as #kube_core::Resource>::DynamicType;
+            type Scope = <#resource as #kube_core::Resource>::Scope;
+
+            fn group(_: &<#resource as #kube_core::Resource>::DynamicType) -> std::borrow::Cow<'_, str> {
+                #resource::group(&Default::default()).into_owned().into()
+            }
+
+            fn kind(_: &<#resource as #kube_core::Resource>::DynamicType) -> std::borrow::Cow<'_, str> {
+                #resource::kind(&Default::default()).into_owned().into()
+            }
+
+            fn version(_: &<#resource as #kube_core::Resource>::DynamicType) -> std::borrow::Cow<'_, str> {
+                #resource::version(&Default::default()).into_owned().into()
+            }
+
+            fn api_version(_: &<#resource as #kube_core::Resource>::DynamicType) -> std::borrow::Cow<'_, str> {
+                #resource::api_version(&Default::default()).into_owned().into()
+            }
+
+            fn plural(_: &<#resource as #kube_core::Resource>::DynamicType) -> std::borrow::Cow<'_, str> {
+                #resource::plural(&Default::default()).into_owned().into()
+            }
+
+            fn meta(&self) -> &#k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
+                &self.metadata
+            }
+
+            fn meta_mut(&mut self) -> &mut #k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
+                &mut self.metadata
+            }
+        }
+    };
+
+    // Concat output
+    quote! {
+        #inherit_resource
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_inherit() {
+        let input = quote! {
+            #[derive(Resource)]
+            #[inherit(resource = "ConfigMap")]
+            struct Foo { metadata: ObjectMeta }
+        };
+
+        let input = syn::parse2(input).unwrap();
+        InheritAttrs::from_derive_input(&input).unwrap();
+    }
+}

kube-derive/tests/resource.rs

@@ -0,0 +1,55 @@
+use k8s_openapi::{
+    api::core::v1::{ConfigMap, Secret},
+    ByteString,
+};
+use kube::api::ObjectMeta;
+use kube_derive::Resource;
+
+#[derive(Resource, Default)]
+#[inherit(resource = "ConfigMap")]
+struct TypedMap {
+    metadata: ObjectMeta,
+    data: Option<TypedData>,
+}
+
+#[derive(Default)]
+struct TypedData {
+    field: String,
+}
+
+#[derive(Resource, Default)]
+#[inherit(resource = "Secret")]
+struct TypedSecret {
+    metadata: ObjectMeta,
+    data: Option<TypedSecretData>,
+}
+
+#[derive(Default)]
+struct TypedSecretData {
+    field: ByteString,
+}
+
+#[cfg(test)]
+mod tests {
+    use kube::Resource;
+
+    use crate::{TypedMap, TypedSecret};
+
+    #[test]
+    fn test_parse_config_map_default() {
+        TypedMap::default();
+        assert_eq!(TypedMap::kind(&()), "ConfigMap");
+        assert_eq!(TypedMap::api_version(&()), "v1");
+        assert_eq!(TypedMap::group(&()), "");
+        assert_eq!(TypedMap::plural(&()), "configmaps");
+    }
+
+    #[test]
+    fn test_parse_secret_default() {
+        TypedSecret::default();
+        assert_eq!(TypedSecret::kind(&()), "Secret");
+        assert_eq!(TypedSecret::api_version(&()), "v1");
+        assert_eq!(TypedSecret::group(&()), "");
+        assert_eq!(TypedSecret::plural(&()), "secrets");
+    }
+}

kube/src/lib.rs

@@ -165,6 +165,10 @@ cfg_error! {
 #[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
 pub use kube_derive::CustomResource;
 
+#[cfg(feature = "derive")]
+#[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
+pub use kube_derive::Resource;
+
 /// Re-exports from `kube-runtime`
 #[cfg(feature = "runtime")]
 #[cfg_attr(docsrs, doc(cfg(feature = "runtime")))]