basic reflection question/how-to

[jamesrobb]

Hello,

I'm coming from the world of Golang and have made use of its protoreflect and protoregistry packages. In particular, I've used them to achieve the following (respectively):

• At runtime get the FQDN of a proto message (as a string), that is, the package name concatenated with the message name (e.g., myapp.somepackage.ChocolateOrder where ChocolateOrder is the message's name)
• For a given FQDN (as a string), convert/cast a proto message that has been serialized as an array of bytes to corresponding type in Golang.

I'm very interested by Rust, but am extremely new to it. I have a project I'm working on in Golang where I am doing these things, but I thought about attempting to rewrite it in Rust. The ability to do the two things mentioned above is pretty core to the project. I've taken a look at the documentation and have done some googling, but I really haven't managed to find out how to accomplish the two above tasks in my searches.

Could someone provide some insight into how I could tackle those items? Of course for the latter item I'd like to know how to convert an array of bytes to the corresponding Rust type (given the FQDN).

Thanks,

[LucioFranco]

Could you explain what a FQDN is?

This is mostly the right place though we also have a discord channel at https://discord.gg/tokio

[jamesrobb]

I'm using the wrong terminology. With FQDN I mean the fully-qualified domain name, by which I meant the name of the message including its package name. For example, if we have the following proto file, the FQDN of the message would be myapp.order.ChocolateOrder.

package myapp.order;

message ChocolateOrder {
    string choclate_type = 1;
}

Given that's what I what I mean by FQDN, how could I go about doing the two things I had asked about?

Also, while not directly related, I realized that that FQDN was probably not the right choice of terminology. What term should I use? "Full name", possibly?

[LucioFranco]

maybe this is what you want https://crates.io/crates/prost-reflect

[jamesrobb]

This gets me almost all the way there. Let me try and answer one of my own questions, and ask a follow up.

When I asked the second question, I should have said that I would have an Any type to work with.

Getting the message's full name

It looks like I can use the ReflectMessage trait to do this. It'll expose a .descriptor() method which I can use to get a MessageDescriptor, which in turn has a .full_name() method.

Further, it looks like I can use the prost-reflect-build trait to automatically provide ReflectMessage implementations for the generated rust code.

So unless I said something that doesn't make sense, I think this one is solved.

Convert an Any message to the appropriate Rust type given the message's full name

This one I haven't quite figured all the way out. I came across this packing/unpacking example, which shows how to serialize/deserialize a message, as well as convert from a message of type Any to the corresponding Rust type. However, the caveat for the Any conversion in this example though is that one knows the Rust type at compile time (at least that's what I gather when reading Lines 57-60).

In my case I don't know the Rust type at compile time, I'll just have the Any type. If it helps for clarity, I'll receive the Any type from over the wire, and we can assume that the appropriate Rust type does indeed exist on the receiving end.

Given that the Any type will have the message's full name, and the packing/unpacking example I listed, how can I go the last step and convert to the appropriate Rust at runtime?

[jamesrobb]

So I thought I'd follow up since I found a solution to my second question. I reached out to the author of the packing/unpacking example, and doing what I was trying to do is very simple. It essentially boils down to:

    let msg = prost_types::Any::decode(&buf[..]).unwrap();

    if let Some(foo) = unpack_from_any::<Foo>(&msg) {
        println!("foo received: {:?}", foo);
    } else if let Some(bar) = unpack_from_any::<Bar>(&msg) {
        println!("bar received: {:?}", bar);
    }

If buf is a message of type Any that came in over the wire, I can convert it to the appropriate type.