feat: migrate to quick-protobuf

Instead of relying on `protoc` and buildscripts, we generate the bindings using `pb-rs` and version them within our codebase. This makes for a better IDE integration, a faster build and an easier use of `rust-libp2p` because we don't force the `protoc` dependency onto them.

Resolves #3024.

Pull-Request: #3312.

protocols/floodsub/src/generated/floodsub/mod.rs

@@ -0,0 +1,2 @@
+// Automatically generated mod.rs
+pub mod pb;

protocols/floodsub/src/generated/floodsub/pb.rs

@@ -0,0 +1,137 @@
+// Automatically generated rust module for 'rpc.proto' file
+
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+#![cfg_attr(rustfmt, rustfmt_skip)]
+
+
+use quick_protobuf::{MessageInfo, MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result};
+use quick_protobuf::sizeofs::*;
+use super::super::*;
+
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Debug, Default, PartialEq, Clone)]
+pub struct RPC {
+    pub subscriptions: Vec<floodsub::pb::mod_RPC::SubOpts>,
+    pub publish: Vec<floodsub::pb::Message>,
+}
+
+impl<'a> MessageRead<'a> for RPC {
+    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
+        let mut msg = Self::default();
+        while !r.is_eof() {
+            match r.next_tag(bytes) {
+                Ok(10) => msg.subscriptions.push(r.read_message::<floodsub::pb::mod_RPC::SubOpts>(bytes)?),
+                Ok(18) => msg.publish.push(r.read_message::<floodsub::pb::Message>(bytes)?),
+                Ok(t) => { r.read_unknown(bytes, t)?; }
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(msg)
+    }
+}
+
+impl MessageWrite for RPC {
+    fn get_size(&self) -> usize {
+        0
+        + self.subscriptions.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+        + self.publish.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+    }
+
+    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
+        for s in &self.subscriptions { w.write_with_tag(10, |w| w.write_message(s))?; }
+        for s in &self.publish { w.write_with_tag(18, |w| w.write_message(s))?; }
+        Ok(())
+    }
+}
+
+pub mod mod_RPC {
+
+use super::*;
+
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Debug, Default, PartialEq, Clone)]
+pub struct SubOpts {
+    pub subscribe: Option<bool>,
+    pub topic_id: Option<String>,
+}
+
+impl<'a> MessageRead<'a> for SubOpts {
+    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
+        let mut msg = Self::default();
+        while !r.is_eof() {
+            match r.next_tag(bytes) {
+                Ok(8) => msg.subscribe = Some(r.read_bool(bytes)?),
+                Ok(18) => msg.topic_id = Some(r.read_string(bytes)?.to_owned()),
+                Ok(t) => { r.read_unknown(bytes, t)?; }
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(msg)
+    }
+}
+
+impl MessageWrite for SubOpts {
+    fn get_size(&self) -> usize {
+        0
+        + self.subscribe.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+        + self.topic_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+    }
+
+    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
+        if let Some(ref s) = self.subscribe { w.write_with_tag(8, |w| w.write_bool(*s))?; }
+        if let Some(ref s) = self.topic_id { w.write_with_tag(18, |w| w.write_string(&**s))?; }
+        Ok(())
+    }
+}
+
+}
+
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Debug, Default, PartialEq, Clone)]
+pub struct Message {
+    pub from: Option<Vec<u8>>,
+    pub data: Option<Vec<u8>>,
+    pub seqno: Option<Vec<u8>>,
+    pub topic_ids: Vec<String>,
+}
+
+impl<'a> MessageRead<'a> for Message {
+    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
+        let mut msg = Self::default();
+        while !r.is_eof() {
+            match r.next_tag(bytes) {
+                Ok(10) => msg.from = Some(r.read_bytes(bytes)?.to_owned()),
+                Ok(18) => msg.data = Some(r.read_bytes(bytes)?.to_owned()),
+                Ok(26) => msg.seqno = Some(r.read_bytes(bytes)?.to_owned()),
+                Ok(34) => msg.topic_ids.push(r.read_string(bytes)?.to_owned()),
+                Ok(t) => { r.read_unknown(bytes, t)?; }
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(msg)
+    }
+}
+
+impl MessageWrite for Message {
+    fn get_size(&self) -> usize {
+        0
+        + self.from.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+        + self.data.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+        + self.seqno.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+        + self.topic_ids.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
+    }
+
+    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
+        if let Some(ref s) = self.from { w.write_with_tag(10, |w| w.write_bytes(&**s))?; }
+        if let Some(ref s) = self.data { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
+        if let Some(ref s) = self.seqno { w.write_with_tag(26, |w| w.write_bytes(&**s))?; }
+        for s in &self.topic_ids { w.write_with_tag(34, |w| w.write_string(&**s))?; }
+        Ok(())
+    }
+}
+

protocols/floodsub/src/generated/mod.rs

@@ -0,0 +1,2 @@
+// Automatically generated mod.rs
+pub mod floodsub;

protocols/floodsub/src/lib.rs

@@ -29,9 +29,9 @@ pub mod protocol;
 mod layer;
 mod topic;
 
-#[allow(clippy::derive_partial_eq_without_eq)]
-mod rpc_proto {
-    include!(concat!(env!("OUT_DIR"), "/floodsub.pb.rs"));
+mod proto {
+    include!("generated/mod.rs");
+    pub use self::floodsub::pb::{mod_RPC::SubOpts, Message, RPC};
 }
 
 pub use self::layer::{Floodsub, FloodsubEvent};

protocols/floodsub/src/protocol.rs

@@ -18,7 +18,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use crate::rpc_proto;
+use crate::proto;
 use crate::topic::Topic;
 use asynchronous_codec::Framed;
 use futures::{
@@ -65,7 +65,7 @@ where
         Box::pin(async move {
             let mut framed = Framed::new(
                 socket,
-                prost_codec::Codec::<rpc_proto::Rpc>::new(MAX_MESSAGE_LEN_BYTES),
+                quick_protobuf_codec::Codec::<proto::RPC>::new(MAX_MESSAGE_LEN_BYTES),
             );
 
             let rpc = framed
@@ -120,7 +120,7 @@ pub enum FloodsubError {
 
 #[derive(thiserror::Error, Debug)]
 #[error(transparent)]
-pub struct CodecError(#[from] prost_codec::Error);
+pub struct CodecError(#[from] quick_protobuf_codec::Error);
 
 /// An RPC received by the floodsub system.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -152,7 +152,7 @@ where
         Box::pin(async move {
             let mut framed = Framed::new(
                 socket,
-                prost_codec::Codec::<rpc_proto::Rpc>::new(MAX_MESSAGE_LEN_BYTES),
+                quick_protobuf_codec::Codec::<proto::RPC>::new(MAX_MESSAGE_LEN_BYTES),
             );
             framed.send(self.into_rpc()).await?;
             framed.close().await?;
@@ -163,12 +163,12 @@ where
 
 impl FloodsubRpc {
     /// Turns this `FloodsubRpc` into a message that can be sent to a substream.
-    fn into_rpc(self) -> rpc_proto::Rpc {
-        rpc_proto::Rpc {
+    fn into_rpc(self) -> proto::RPC {
+        proto::RPC {
             publish: self
                 .messages
                 .into_iter()
-                .map(|msg| rpc_proto::Message {
+                .map(|msg| proto::Message {
                     from: Some(msg.source.to_bytes()),
                     data: Some(msg.data),
                     seqno: Some(msg.sequence_number),
@@ -179,7 +179,7 @@ impl FloodsubRpc {
             subscriptions: self
                 .subscriptions
                 .into_iter()
-                .map(|topic| rpc_proto::rpc::SubOpts {
+                .map(|topic| proto::SubOpts {
                     subscribe: Some(topic.action == FloodsubSubscriptionAction::Subscribe),
                     topic_id: Some(topic.topic.into()),
                 })