Removes prost, prost-build for quick-protobuf. Refactors signaling.rs to use generated SignalingMessage

Author: elijahhampton

Cargo.lock

@@ -11,9 +11,6 @@ rust-version = { workspace = true }
 version = "0.4.0"
 publish = true
 
-[build-dependencies]
-prost-build = "0.13.5"
-
 [dependencies]
 bytes = "1"
 futures = { workspace = true }
@@ -66,13 +63,13 @@ web-sys = { version = "0.3.70", features = [
   "WebSocket"
 ]}
 oneshot = "0.1.11"
-prost = "0.13.5"
 multistream-select.workspace = true
 pin-project = "1.1.10"
 gloo-timers = { version = "0.3.0", features = ["futures"] }
 serde_json = "1.0.140"
 wasm-timer = "0.2.5"
 async-trait = "0.1.89"
+quick-protobuf = "0.8.1"
 
 [lints]
 workspace = true

transports/webrtc-websys/Cargo.toml

@@ -1,8 +1,4 @@
-#![allow(unreachable_pub)]
-pub mod pb {
-    include!(concat!(env!("OUT_DIR"), "/signaling.rs"));
-}
-
+pub(crate) mod proto;
 pub(crate) mod signaling;
 pub(crate) mod stream_protocol;
 pub(crate) mod upgrade;

transports/webrtc-websys/build.rs

@@ -0,0 +1 @@
+pub(crate) mod signaling;

transports/webrtc-websys/src/browser/protocol/mod.rs

@@ -0,0 +1,90 @@
+// Automatically generated rust module for 'message.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::*;
+
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Debug, Default, PartialEq, Clone)]
+pub struct SignalingMessage {
+    pub type_pb: signaling::mod_SignalingMessage::Type,
+    pub data: String,
+}
+
+impl<'a> MessageRead<'a> for SignalingMessage {
+    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.type_pb = r.read_enum(bytes)?,
+                Ok(18) => msg.data = r.read_string(bytes)?.to_owned(),
+                Ok(t) => { r.read_unknown(bytes, t)?; }
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(msg)
+    }
+}
+
+impl MessageWrite for SignalingMessage {
+    fn get_size(&self) -> usize {
+        0
+        + if self.type_pb == signaling::mod_SignalingMessage::Type::SDP_OFFER { 0 } else { 1 + sizeof_varint(*(&self.type_pb) as u64) }
+        + if self.data == String::default() { 0 } else { 1 + sizeof_len((&self.data).len()) }
+    }
+
+    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
+        if self.type_pb != signaling::mod_SignalingMessage::Type::SDP_OFFER { w.write_with_tag(8, |w| w.write_enum(*&self.type_pb as i32))?; }
+        if self.data != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.data))?; }
+        Ok(())
+    }
+}
+
+pub(crate) mod mod_SignalingMessage {
+
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum Type {
+    SDP_OFFER = 0,
+    SDP_ANSWER = 1,
+    ICE_CANDIDATE = 2,
+}
+
+impl Default for Type {
+    fn default() -> Self {
+        Type::SDP_OFFER
+    }
+}
+
+impl From<i32> for Type {
+    fn from(i: i32) -> Self {
+        match i {
+            0 => Type::SDP_OFFER,
+            1 => Type::SDP_ANSWER,
+            2 => Type::ICE_CANDIDATE,
+            _ => Self::default(),
+        }
+    }
+}
+
+impl<'a> From<&'a str> for Type {
+    fn from(s: &'a str) -> Self {
+        match s {
+            "SDP_OFFER" => Type::SDP_OFFER,
+            "SDP_ANSWER" => Type::SDP_ANSWER,
+            "ICE_CANDIDATE" => Type::ICE_CANDIDATE,
+            _ => Self::default(),
+        }
+    }
+}
+
+}

transports/webrtc-websys/src/browser/protocol/proto/mod.rs

@@ -13,7 +13,7 @@ use web_sys::{
 
 use crate::{
     browser::{
-        protocol::pb::{signaling_message, SignalingMessage},
+        protocol::proto::signaling::{mod_SignalingMessage::Type, SignalingMessage},
         SignalingConfig, SignalingStream,
     },
     connection::RtcPeerConnection,
@@ -444,7 +444,7 @@ impl ProtocolHandler {
                 .unwrap_or_default();
 
             let message = SignalingMessage {
-                r#type: signaling_message::Type::IceCandidate as i32,
+                type_pb: Type::ICE_CANDIDATE,
                 data: candidate_as_str,
             };
 
@@ -455,7 +455,7 @@ impl ProtocolHandler {
 
         // Send end-of-candidates marker as an empty JSON object
         let end_message = SignalingMessage {
-            r#type: signaling_message::Type::IceCandidate as i32,
+            type_pb: Type::ICE_CANDIDATE,
             data: "{}".to_string(),
         };
 
@@ -479,7 +479,7 @@ impl ProtocolHandler {
                 Error::ProtoSerialization("Failed to read ICE candidate".to_string())
             })?;
 
-            if message.r#type != signaling_message::Type::IceCandidate as i32 {
+            if message.type_pb != Type::ICE_CANDIDATE {
                 return Err(Error::Signaling(
                     "Expected ICE candidate message".to_string(),
                 ));
@@ -533,7 +533,7 @@ impl Signaling for ProtocolHandler {
             Error::ProtoSerialization("Failure to read SDP offer from signaling stream".to_string())
         })?;
 
-        if offer_message.r#type != signaling_message::Type::SdpOffer as i32 {
+        if offer_message.type_pb != Type::SDP_OFFER {
             return Err(Error::Signaling("Expected SDP offer".to_string()));
         }
 
@@ -560,7 +560,7 @@ impl Signaling for ProtocolHandler {
 
         // Send SDP answer
         let answer_message = SignalingMessage {
-            r#type: signaling_message::Type::SdpAnswer as i32,
+            type_pb: Type::SDP_ANSWER,
             data: answer_sdp,
         };
 
@@ -630,8 +630,8 @@ impl Signaling for ProtocolHandler {
 
         // Write SDP offer to the signaling stream
         let message = SignalingMessage {
-            r#type: signaling_message::Type::SdpOffer as i32,
-            data: offer_sdp.clone(),
+            type_pb: Type::SDP_OFFER,
+            data: offer_sdp,
         };
 
         pb_stream.lock().await.write(message).await.map_err(|_| {
@@ -645,7 +645,7 @@ impl Signaling for ProtocolHandler {
             )
         })?;
 
-        if answer_message.r#type != signaling_message::Type::SdpAnswer as i32 {
+        if answer_message.type_pb != Type::SDP_ANSWER {
             return Err(Error::Signaling("Expected SDP answer".to_string()));
         }
 

transports/webrtc-websys/src/browser/protocol/proto/signaling.rs

@@ -1,8 +1,8 @@
 use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
-use prost::Message;
+use quick_protobuf::{BytesReader, Error, MessageRead, MessageWrite, Writer};
 use tracing::info;
 
-use crate::browser::protocol::pb::SignalingMessage;
+use crate::browser::protocol::proto::signaling::SignalingMessage;
 
 /// A wrapper over a async stream for reading and writing SignalingMesssages.
 pub struct SignalingStream<T> {
@@ -18,10 +18,11 @@ where
     }
 
     /// Encodes and writes a signaling message to the stream.
-    pub async fn write(&mut self, message: SignalingMessage) -> Result<(), std::io::Error> {
+    pub async fn write(&mut self, message: SignalingMessage) -> Result<(), Error> {
         info!("Writing signaling message through signaling stream");
         let mut buf = Vec::new();
-        message.encode(&mut buf)?;
+        let mut writer = Writer::new(&mut buf);
+        message.write_message(&mut writer)?;
         let len = buf.len() as u32;
 
         self.inner.write_all(&len.to_be_bytes()).await?;
@@ -31,7 +32,7 @@ where
     }
 
     /// Reads and decodes a signaling message from the stream.
-    pub async fn read(&mut self) -> Result<SignalingMessage, std::io::Error> {
+    pub async fn read(&mut self) -> Result<SignalingMessage, Error> {
         info!("Reading signaling message from signaling stream");
         let mut len_buf = [0u8; 4];
         self.inner.read_exact(&mut len_buf).await?;
@@ -40,7 +41,8 @@ where
         let mut buf = vec![0u8; len];
         self.inner.read_exact(&mut buf).await?;
 
-        let message = SignalingMessage::decode(&buf[..])?;
+        let mut reader = BytesReader::from_bytes(&buf);
+        let message = SignalingMessage::from_reader(&mut reader, &buf)?;
         Ok(message)
     }
 }