Bring your own codec

[cemoktra]

Hi,

i'm building a set of crates that until now hooked in tonic codec for a custom encoding/decoding experience: https://codeberg.org/cemoktra/gin-tonic

Basically i'm providing a protobuf option to directly use your real types in protobuf message structs, a trait for defining how this is encoded on protobuf scalar values and a code generator for this.

I was now scimming the traits exposed by the new library, and it seems there is no such thing as the Codec trait anymore.

That leads to my main question of, to plan to re-integrate that?

[dfawley]

Hi @cemoktra, thanks for your issue.

The Codec trait equivalent in the grpc crate is:

https://docs.rs/grpc/latest/grpc/core/trait.SendMessage.html and https://docs.rs/grpc/latest/grpc/core/trait.RecvMessage.html

Examples of how those are implemented for google protobuf are here:

grpc-rust/grpc-protobuf/src/lib.rs

Lines 68 to 141 in e7c0dd0

	/// Implements [`SendMessage`] for protobuf message views.
	pub struct ProtoSendMessage<'a, V: Proxied>(V::View<'a>);
	impl<'a, V: Proxied> ProtoSendMessage<'a, V> {
	pub fn from_view(provider: &'a impl AsView<Proxied = V>) -> Self {
	Self(provider.as_view())
	}
	}
	impl<'a, V> SendMessage for ProtoSendMessage<'a, V>
	where
	V: Proxied,
	V::View<'a>: Serialize + Send + Sync,
	{
	fn encode(&self) -> Result<Box<dyn Buf + Send + Sync>, String> {
	Ok(Box::new(Bytes::from(
	self.0.serialize().map_err(|e| e.to_string())?,
	)))
	}
	unsafe fn _ptr_for(&self, id: TypeId) -> Option<*const ()> {
	if id != TypeId::of::<V::View<'static>>() {
	return None;
	}
	Some(&self.0 as *const _ as *const ())
	}
	}
	impl<'a, V: Proxied> MessageType for ProtoSendMessage<'a, V> {
	type Target<'b> = V::View<'b>;
	}
	/// Implements [`RecvMessage`] for protobuf message mutable views.
	pub struct ProtoRecvMessage<'a, M: MutProxied>(M::Mut<'a>);
	impl<'a, M: MutProxied> ProtoRecvMessage<'a, M> {
	pub fn from_mut(provider: &'a mut impl AsMut<MutProxied = M>) -> Self {
	Self(provider.as_mut())
	}
	}
	impl<'a, M> RecvMessage for ProtoRecvMessage<'a, M>
	where
	M: MutProxied,
	M::Mut<'a>: Send + Sync + ClearAndParse,
	{
	fn decode(&mut self, buf: &mut dyn Buf) -> Result<(), String> {
	let len = buf.remaining();
	if buf.chunk().len() == len {
	self.0
	.clear_and_parse(buf.chunk())
	.map_err(|e| e.to_string())?;
	} else {
	let mut temp_vec = vec![0u8; len];
	buf.copy_to_slice(&mut temp_vec);
	self.0
	.clear_and_parse(&temp_vec)
	.map_err(|e| e.to_string())?;
	}
	Ok(())
	}
	unsafe fn _ptr_for(&mut self, id: TypeId) -> Option<*mut ()> {
	if id != TypeId::of::<M::Mut<'static>>() {
	return None;
	}
	Some(&mut self.0 as *mut _ as *mut ())
	}
	}
	impl<'a, M: Message> MessageType for ProtoRecvMessage<'a, M> {
	type Target<'b> = M::Mut<'b>;
	}

This means that you can't just swap out these traits and everything magically works -- you need to have your own code generator, too, since they are hard-coded in the grpc-protobuf library. I believe this is reasonable, as the generated code we produce depends heavily on the exact google protobuf APIs. Let me know if you disagree and I'm happy to discuss. Maybe it's possible to abstract this further, but I'm not sure what all that would entail, or whether it would be worth the complexity vs. having a separate code generator.

Also, we do intend to provide a codegen that supports the tonic API as closely as possible in the future.

[cemoktra]

I will play around. At least I think I could implement the those for all types that implement my Message trait. So it should work.

The main point of my library is providing a way (trait) to encode/decode any type into protobuf scalar types directly. Which was not possible with Prost before.

[halo-space]

I will play around. At least I think I could implement the those for all types that implement my Message trait. So it should work.

The main point of my library is providing a way (trait) to encode/decode any type into protobuf scalar types directly. Which was not possible with Prost before.

HI cemoktra
Is there any plan to integrate a framework like go-zero that enables rapid business development? If you're interested, we can work together on it.