Convert <K: Resource> to DynamicObject?

[danrspencer]

I'm working on a command dispatcher for our Kubernetes stuff and I'm looking at using DynamicObject to store the resource on a command in a type agnostic way, e.g.

pub enum KubeCommandVerb {
    Create {
        resource: DynamicObject,
        kind: ApiResource,
    },
    Patch {
        name: String,
        patch: KubePatch,
        kind: ApiResource,
    },
    Delete {
        name: String,
        kind: ApiResource,
    },
}

Which means that in my command dispatcher I'm not coupled to a specific resource:

Api::<DynamicObject>::all_with(client.clone(), &command.get_api_resource())

Is there a good way to convert from <K: Resource> to DynamicObject? I've got the conversion working via a hacky (excuse the lack of error handling) function that seems to work, but am I missing a built in way to do this?

fn to_dyn_obj<K: Resource + Serialize>(resource: K) -> DynamicObject
where
    K::DynamicType: Default,
{
    let api_resource = ApiResource::erase::<K>(&Default::default());

    DynamicObject {
        types: Some(TypeMeta {
            api_version: api_resource.api_version.clone(),
            kind: api_resource.kind.clone(),
        }),
        metadata: resource.meta().clone(),
        data: serde_json::to_value(resource).unwrap(),
    }
}

[clux]

There is a function DynamicObject::new that does that stuff. There's a couple of builders there that should get you to a nice one liner at the end once you have an ApiResource (the erase method or api discovery should work well for that).

[clux]

oh, that was not intended. Good spot 👍
I didn't know flatten could influence explicitly specified keys, but then that method was only tested on an object that contained the "spec"..

If we make a TryFrom impl, then at least we need some tests on this if it's this brittle.

[danrspencer]

TryFrom would solve my use case perfectly 👍

[danrspencer]

It looks like the serialiser is stupider than I anticipated, this is what you end up with:

{
   "apiVersion":"v1",
   "kind":"Pod",
   "metadata":{
      "name":"test"
   },
   "apiVersion":"v1",
   "kind":"Pod",
   "metadata":{
      "name":"test",
      "namespace":"default"
   },
   "spec":{
      "containers":[
         {
            "image":"test",
            "name":"test"
         }
      ]
   }
}

Kubernetes seems to accept it but I wouldn't want to put money on which key wins when they're not in sync.

[danrspencer]

This is what I've ended up with:

fn to_dynamic_object<K: Resource + Serialize>(resource: K) -> Result<DynamicObject>
where
    K::DynamicType: Default,
{
    let mut dynamic_object = DynamicObject::new(
        &resource.name(),
        &ApiResource::erase::<K>(&Default::default()),
    );

    dynamic_object.metadata = resource.meta().clone();
    dynamic_object.data = serde_json::to_value(resource)?;

    if let Some(data) = dynamic_object.data.as_object_mut() {
        data.remove("kind");
        data.remove("apiVersion");
        data.remove("metadata");
    }

    Ok(dynamic_object)
}

#[test]
fn it_serialises_the_same_as_before_conversion() {
    let resource = Pod {
        metadata: ObjectMeta {
            name: Some("test".to_string()),
            namespace: Some("default".to_string()),
            ..Default::default()
        },
        spec: Some(PodSpec {
            containers: vec![Container {
                name: "test".to_string(),
                image: Some("test".to_string()),
                ..Default::default()
            }],
            ..Default::default()
        }),
        ..Default::default()
    };
    let dynamic_object = to_dynamic_object(resource.clone()).unwrap();

    assert_eq!(
        serde_json::to_string(&dynamic_object).unwrap(),
        serde_json::to_string(&resource).unwrap()
    );
}

[clux]

Thanks. That's helpful. I'm playing around a bit with a TryFrom impl here, but it's a bit more awkward than i thought because it's a generic TryFrom<K> over K: Resource and you end up with conflicting trait implementations for TryInto and TryFrom.

Was hoping something like this would work (before accounting for duplicates like you have done):

impl<K> TryFrom<K> for DynamicObject
where
    K: Resource + Serialize,
    K::DynamicType: Default
{
    type Error = Error;
    fn try_from(resource: K) -> Result<DynamicObject, Self::Error> {
        let ar = ApiResource::erase::<K>(&Default::default());
        let data = serde_json::to_value(resource).unwrap(); // TODO: map_errror
        let dynobj = DynamicObject {
            types: Some(TypeMeta {
                api_version: ar.api_version.to_string(),
                kind: ar.kind.to_string(),
            }),
            metadata: ObjectMeta::default(), // overwritten by data
            data: data,
        };
        Ok(dynobj)
    }
}

but seems like probably need a more direct helper.

if you want to try your hand at a pr on a direct impl on DynamicObject (in kube-core/src/dynamic.rs) i'd be happy to review.
otherwise i'll have a look again later in the week.