fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-06-30 18:21:33 +00:00
Code Issues Projects Releases Wiki Activity

feat: migrate to quick-protobuf

Browse Source 
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.
This commit is contained in:
Miguel Guarniz
2023-03-02 05:45:07 -05:00
committed by GitHub
parent 4910160bea
commit db82e0210e
141 changed files with 3662 additions and 1276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

228
protocols/rendezvous/src/codec.rs
View File

@ -200,13 +200,13 @@ pub enum ErrorCode {
}
pub struct RendezvousCodec {
inner: prost_codec::Codec<wire::Message>,
inner: quick_protobuf_codec::Codec<proto::Message>,
}
impl Default for RendezvousCodec {
fn default() -> Self {
Self {
inner: prost_codec::Codec::new(1024 * 1024), // 1MB
inner: quick_protobuf_codec::Codec::new(1024 * 1024), // 1MB
}
}
}
@ -216,7 +216,7 @@ impl Encoder for RendezvousCodec {
type Error = Error;
fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
self.inner.encode(wire::Message::from(item), dst)?;
self.inner.encode(proto::Message::from(item), dst)?;
Ok(())
}
@ -239,140 +239,134 @@ impl Decoder for RendezvousCodec {
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error(transparent)]
Codec(#[from] prost_codec::Error),
Codec(#[from] quick_protobuf_codec::Error),
#[error("Failed to read/write")]
Io(#[from] std::io::Error),
#[error("Failed to convert wire message to internal data model")]
Conversion(#[from] ConversionError),
}
impl From<Message> for wire::Message {
impl From<Message> for proto::Message {
fn from(message: Message) -> Self {
use wire::message::*;
match message {
Message::Register(NewRegistration {
namespace,
record,
ttl,
}) => wire::Message {
r#type: Some(MessageType::Register.into()),
register: Some(Register {
}) => proto::Message {
type_pb: Some(proto::MessageType::REGISTER),
register: Some(proto::Register {
ns: Some(namespace.into()),
ttl,
signed_peer_record: Some(
record.into_signed_envelope().into_protobuf_encoding(),
),
signedPeerRecord: Some(record.into_signed_envelope().into_protobuf_encoding()),
}),
register_response: None,
registerResponse: None,
unregister: None,
discover: None,
discover_response: None,
discoverResponse: None,
},
Message::RegisterResponse(Ok(ttl)) => wire::Message {
r#type: Some(MessageType::RegisterResponse.into()),
register_response: Some(RegisterResponse {
status: Some(ResponseStatus::Ok.into()),
status_text: None,
Message::RegisterResponse(Ok(ttl)) => proto::Message {
type_pb: Some(proto::MessageType::REGISTER_RESPONSE),
registerResponse: Some(proto::RegisterResponse {
status: Some(proto::ResponseStatus::OK),
statusText: None,
ttl: Some(ttl),
}),
register: None,
discover: None,
unregister: None,
discover_response: None,
discoverResponse: None,
},
Message::RegisterResponse(Err(error)) => wire::Message {
r#type: Some(MessageType::RegisterResponse.into()),
register_response: Some(RegisterResponse {
status: Some(ResponseStatus::from(error).into()),
status_text: None,
Message::RegisterResponse(Err(error)) => proto::Message {
type_pb: Some(proto::MessageType::REGISTER_RESPONSE),
registerResponse: Some(proto::RegisterResponse {
status: Some(proto::ResponseStatus::from(error)),
statusText: None,
ttl: None,
}),
register: None,
discover: None,
unregister: None,
discover_response: None,
discoverResponse: None,
},
Message::Unregister(namespace) => wire::Message {
r#type: Some(MessageType::Unregister.into()),
unregister: Some(Unregister {
Message::Unregister(namespace) => proto::Message {
type_pb: Some(proto::MessageType::UNREGISTER),
unregister: Some(proto::Unregister {
ns: Some(namespace.into()),
id: None,
}),
register: None,
register_response: None,
registerResponse: None,
discover: None,
discover_response: None,
discoverResponse: None,
},
Message::Discover {
namespace,
cookie,
limit,
} => wire::Message {
r#type: Some(MessageType::Discover.into()),
discover: Some(Discover {
} => proto::Message {
type_pb: Some(proto::MessageType::DISCOVER),
discover: Some(proto::Discover {
ns: namespace.map(|ns| ns.into()),
cookie: cookie.map(|cookie| cookie.into_wire_encoding()),
limit,
}),
register: None,
register_response: None,
registerResponse: None,
unregister: None,
discover_response: None,
discoverResponse: None,
},
Message::DiscoverResponse(Ok((registrations, cookie))) => wire::Message {
r#type: Some(MessageType::DiscoverResponse.into()),
discover_response: Some(DiscoverResponse {
Message::DiscoverResponse(Ok((registrations, cookie))) => proto::Message {
type_pb: Some(proto::MessageType::DISCOVER_RESPONSE),
discoverResponse: Some(proto::DiscoverResponse {
registrations: registrations
.into_iter()
.map(|reggo| Register {
.map(|reggo| proto::Register {
ns: Some(reggo.namespace.into()),
ttl: Some(reggo.ttl),
signed_peer_record: Some(
signedPeerRecord: Some(
reggo.record.into_signed_envelope().into_protobuf_encoding(),
),
})
.collect(),
status: Some(ResponseStatus::Ok.into()),
status_text: None,
status: Some(proto::ResponseStatus::OK),
statusText: None,
cookie: Some(cookie.into_wire_encoding()),
}),
register: None,
discover: None,
unregister: None,
register_response: None,
registerResponse: None,
},
Message::DiscoverResponse(Err(error)) => wire::Message {
r#type: Some(MessageType::DiscoverResponse.into()),
discover_response: Some(DiscoverResponse {
Message::DiscoverResponse(Err(error)) => proto::Message {
type_pb: Some(proto::MessageType::DISCOVER_RESPONSE),
discoverResponse: Some(proto::DiscoverResponse {
registrations: Vec::new(),
status: Some(ResponseStatus::from(error).into()),
status_text: None,
status: Some(proto::ResponseStatus::from(error)),
statusText: None,
cookie: None,
}),
register: None,
discover: None,
unregister: None,
register_response: None,
registerResponse: None,
},
}
}
}
impl TryFrom<wire::Message> for Message {
impl TryFrom<proto::Message> for Message {
type Error = ConversionError;
fn try_from(message: wire::Message) -> Result<Self, Self::Error> {
use wire::message::*;
fn try_from(message: proto::Message) -> Result<Self, Self::Error> {
let message = match message {
wire::Message {
r#type: Some(0),
proto::Message {
type_pb: Some(proto::MessageType::REGISTER),
register:
Some(Register {
Some(proto::Register {
ns,
ttl,
signed_peer_record: Some(signed_peer_record),
signedPeerRecord: Some(signed_peer_record),
}),
..
} => Message::Register(NewRegistration {
@ -385,31 +379,31 @@ impl TryFrom<wire::Message> for Message {
&signed_peer_record,
)?)?,
}),
wire::Message {
r#type: Some(1),
register_response:
Some(RegisterResponse {
status: Some(0),
proto::Message {
type_pb: Some(proto::MessageType::REGISTER_RESPONSE),
registerResponse:
Some(proto::RegisterResponse {
status: Some(proto::ResponseStatus::OK),
ttl,
..
}),
..
} => Message::RegisterResponse(Ok(ttl.ok_or(ConversionError::MissingTtl)?)),
wire::Message {
r#type: Some(3),
discover: Some(Discover { ns, limit, cookie }),
proto::Message {
type_pb: Some(proto::MessageType::DISCOVER),
discover: Some(proto::Discover { ns, limit, cookie }),
..
} => Message::Discover {
namespace: ns.map(Namespace::new).transpose()?,
cookie: cookie.map(Cookie::from_wire_encoding).transpose()?,
limit,
},
wire::Message {
r#type: Some(4),
discover_response:
Some(DiscoverResponse {
proto::Message {
type_pb: Some(proto::MessageType::DISCOVER_RESPONSE),
discoverResponse:
Some(proto::DiscoverResponse {
registrations,
status: Some(0),
status: Some(proto::ResponseStatus::OK),
cookie: Some(cookie),
..
}),
@ -427,7 +421,7 @@ impl TryFrom<wire::Message> for Message {
record: PeerRecord::from_signed_envelope(
SignedEnvelope::from_protobuf_encoding(
&reggo
.signed_peer_record
.signedPeerRecord
.ok_or(ConversionError::MissingSignedPeerRecord)?,
)?,
)?,
@ -439,43 +433,33 @@ impl TryFrom<wire::Message> for Message {
Message::DiscoverResponse(Ok((registrations, cookie)))
}
wire::Message {
r#type: Some(1),
register_response:
Some(RegisterResponse {
status: Some(error_code),
proto::Message {
type_pb: Some(proto::MessageType::REGISTER_RESPONSE),
registerResponse:
Some(proto::RegisterResponse {
status: Some(response_status),
..
}),
..
} => {
let error_code = wire::message::ResponseStatus::from_i32(error_code)
.ok_or(ConversionError::BadStatusCode)?
.try_into()?;
Message::RegisterResponse(Err(error_code))
}
wire::Message {
r#type: Some(2),
unregister: Some(Unregister { ns, .. }),
} => Message::RegisterResponse(Err(response_status.try_into()?)),
proto::Message {
type_pb: Some(proto::MessageType::UNREGISTER),
unregister: Some(proto::Unregister { ns, .. }),
..
} => Message::Unregister(
ns.map(Namespace::new)
.transpose()?
.ok_or(ConversionError::MissingNamespace)?,
),
wire::Message {
r#type: Some(4),
discover_response:
Some(DiscoverResponse {
status: Some(error_code),
proto::Message {
type_pb: Some(proto::MessageType::DISCOVER_RESPONSE),
discoverResponse:
Some(proto::DiscoverResponse {
status: Some(response_status),
..
}),
..
} => {
let error = wire::message::ResponseStatus::from_i32(error_code)
.ok_or(ConversionError::BadStatusCode)?
.try_into()?;
Message::DiscoverResponse(Err(error))
}
} => Message::DiscoverResponse(Err(response_status.try_into()?)),
_ => return Err(ConversionError::InconsistentWireMessage),
};
@ -527,39 +511,39 @@ impl ConversionError {
}
}
impl TryFrom<wire::message::ResponseStatus> for ErrorCode {
impl TryFrom<proto::ResponseStatus> for ErrorCode {
type Error = UnmappableStatusCode;
fn try_from(value: wire::message::ResponseStatus) -> Result<Self, Self::Error> {
use wire::message::ResponseStatus::*;
fn try_from(value: proto::ResponseStatus) -> Result<Self, Self::Error> {
use proto::ResponseStatus::*;
let code = match value {
Ok => return Err(UnmappableStatusCode(value)),
EInvalidNamespace => ErrorCode::InvalidNamespace,
EInvalidSignedPeerRecord => ErrorCode::InvalidSignedPeerRecord,
EInvalidTtl => ErrorCode::InvalidTtl,
EInvalidCookie => ErrorCode::InvalidCookie,
ENotAuthorized => ErrorCode::NotAuthorized,
EInternalError => ErrorCode::InternalError,
EUnavailable => ErrorCode::Unavailable,
OK => return Err(UnmappableStatusCode(value)),
E_INVALID_NAMESPACE => ErrorCode::InvalidNamespace,
E_INVALID_SIGNED_PEER_RECORD => ErrorCode::InvalidSignedPeerRecord,
E_INVALID_TTL => ErrorCode::InvalidTtl,
E_INVALID_COOKIE => ErrorCode::InvalidCookie,
E_NOT_AUTHORIZED => ErrorCode::NotAuthorized,
E_INTERNAL_ERROR => ErrorCode::InternalError,
E_UNAVAILABLE => ErrorCode::Unavailable,
};
Result::Ok(code)
}
}
impl From<ErrorCode> for wire::message::ResponseStatus {
impl From<ErrorCode> for proto::ResponseStatus {
fn from(error_code: ErrorCode) -> Self {
use wire::message::ResponseStatus::*;
use proto::ResponseStatus::*;
match error_code {
ErrorCode::InvalidNamespace => EInvalidNamespace,
ErrorCode::InvalidSignedPeerRecord => EInvalidSignedPeerRecord,
ErrorCode::InvalidTtl => EInvalidTtl,
ErrorCode::InvalidCookie => EInvalidCookie,
ErrorCode::NotAuthorized => ENotAuthorized,
ErrorCode::InternalError => EInternalError,
ErrorCode::Unavailable => EUnavailable,
ErrorCode::InvalidNamespace => E_INVALID_NAMESPACE,
ErrorCode::InvalidSignedPeerRecord => E_INVALID_SIGNED_PEER_RECORD,
ErrorCode::InvalidTtl => E_INVALID_TTL,
ErrorCode::InvalidCookie => E_INVALID_COOKIE,
ErrorCode::NotAuthorized => E_NOT_AUTHORIZED,
ErrorCode::InternalError => E_INTERNAL_ERROR,
ErrorCode::Unavailable => E_UNAVAILABLE,
}
}
}
@ -572,11 +556,11 @@ impl From<UnmappableStatusCode> for ConversionError {
#[derive(Debug, thiserror::Error)]
#[error("The response code ({0:?}) cannot be mapped to our ErrorCode enum")]
pub struct UnmappableStatusCode(wire::message::ResponseStatus);
pub struct UnmappableStatusCode(proto::ResponseStatus);
#[allow(clippy::derive_partial_eq_without_eq)]
mod wire {
include!(concat!(env!("OUT_DIR"), "/rendezvous.pb.rs"));
mod proto {
include!("generated/mod.rs");
pub use self::rendezvous::pb::{mod_Message::*, Message};
}
#[cfg(test)]

2
protocols/rendezvous/src/generated/mod.rs Normal file
View File

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

2
protocols/rendezvous/src/generated/rendezvous/mod.rs Normal file
View File

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

364
protocols/rendezvous/src/generated/rendezvous/pb.rs Normal file
View File

@ -0,0 +1,364 @@
// 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 Message {
pub type_pb: Option<rendezvous::pb::mod_Message::MessageType>,
pub register: Option<rendezvous::pb::mod_Message::Register>,
pub registerResponse: Option<rendezvous::pb::mod_Message::RegisterResponse>,
pub unregister: Option<rendezvous::pb::mod_Message::Unregister>,
pub discover: Option<rendezvous::pb::mod_Message::Discover>,
pub discoverResponse: Option<rendezvous::pb::mod_Message::DiscoverResponse>,
}
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(8) => msg.type_pb = Some(r.read_enum(bytes)?),
Ok(18) => msg.register = Some(r.read_message::<rendezvous::pb::mod_Message::Register>(bytes)?),
Ok(26) => msg.registerResponse = Some(r.read_message::<rendezvous::pb::mod_Message::RegisterResponse>(bytes)?),
Ok(34) => msg.unregister = Some(r.read_message::<rendezvous::pb::mod_Message::Unregister>(bytes)?),
Ok(42) => msg.discover = Some(r.read_message::<rendezvous::pb::mod_Message::Discover>(bytes)?),
Ok(50) => msg.discoverResponse = Some(r.read_message::<rendezvous::pb::mod_Message::DiscoverResponse>(bytes)?),
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.type_pb.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.register.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.registerResponse.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.unregister.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.discover.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.discoverResponse.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.type_pb { w.write_with_tag(8, |w| w.write_enum(*s as i32))?; }
if let Some(ref s) = self.register { w.write_with_tag(18, |w| w.write_message(s))?; }
if let Some(ref s) = self.registerResponse { w.write_with_tag(26, |w| w.write_message(s))?; }
if let Some(ref s) = self.unregister { w.write_with_tag(34, |w| w.write_message(s))?; }
if let Some(ref s) = self.discover { w.write_with_tag(42, |w| w.write_message(s))?; }
if let Some(ref s) = self.discoverResponse { w.write_with_tag(50, |w| w.write_message(s))?; }
Ok(())
}
}
pub mod mod_Message {
use super::*;
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Register {
pub ns: Option<String>,
pub signedPeerRecord: Option<Vec<u8>>,
pub ttl: Option<u64>,
}
impl<'a> MessageRead<'a> for Register {
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.ns = Some(r.read_string(bytes)?.to_owned()),
Ok(18) => msg.signedPeerRecord = Some(r.read_bytes(bytes)?.to_owned()),
Ok(24) => msg.ttl = Some(r.read_uint64(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for Register {
fn get_size(&self) -> usize {
0
+ self.ns.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+ self.signedPeerRecord.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+ self.ttl.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.ns { w.write_with_tag(10, |w| w.write_string(&**s))?; }
if let Some(ref s) = self.signedPeerRecord { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
if let Some(ref s) = self.ttl { w.write_with_tag(24, |w| w.write_uint64(*s))?; }
Ok(())
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Debug, Default, PartialEq, Clone)]
pub struct RegisterResponse {
pub status: Option<rendezvous::pb::mod_Message::ResponseStatus>,
pub statusText: Option<String>,
pub ttl: Option<u64>,
}
impl<'a> MessageRead<'a> for RegisterResponse {
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.status = Some(r.read_enum(bytes)?),
Ok(18) => msg.statusText = Some(r.read_string(bytes)?.to_owned()),
Ok(24) => msg.ttl = Some(r.read_uint64(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for RegisterResponse {
fn get_size(&self) -> usize {
0
+ self.status.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.statusText.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+ self.ttl.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.status { w.write_with_tag(8, |w| w.write_enum(*s as i32))?; }
if let Some(ref s) = self.statusText { w.write_with_tag(18, |w| w.write_string(&**s))?; }
if let Some(ref s) = self.ttl { w.write_with_tag(24, |w| w.write_uint64(*s))?; }
Ok(())
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Unregister {
pub ns: Option<String>,
pub id: Option<Vec<u8>>,
}
impl<'a> MessageRead<'a> for Unregister {
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.ns = Some(r.read_string(bytes)?.to_owned()),
Ok(18) => msg.id = Some(r.read_bytes(bytes)?.to_owned()),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for Unregister {
fn get_size(&self) -> usize {
0
+ self.ns.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+ self.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.ns { w.write_with_tag(10, |w| w.write_string(&**s))?; }
if let Some(ref s) = self.id { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
Ok(())
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Discover {
pub ns: Option<String>,
pub limit: Option<u64>,
pub cookie: Option<Vec<u8>>,
}
impl<'a> MessageRead<'a> for Discover {
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.ns = Some(r.read_string(bytes)?.to_owned()),
Ok(16) => msg.limit = Some(r.read_uint64(bytes)?),
Ok(26) => msg.cookie = Some(r.read_bytes(bytes)?.to_owned()),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for Discover {
fn get_size(&self) -> usize {
0
+ self.ns.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+ self.limit.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.cookie.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.ns { w.write_with_tag(10, |w| w.write_string(&**s))?; }
if let Some(ref s) = self.limit { w.write_with_tag(16, |w| w.write_uint64(*s))?; }
if let Some(ref s) = self.cookie { w.write_with_tag(26, |w| w.write_bytes(&**s))?; }
Ok(())
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Debug, Default, PartialEq, Clone)]
pub struct DiscoverResponse {
pub registrations: Vec<rendezvous::pb::mod_Message::Register>,
pub cookie: Option<Vec<u8>>,
pub status: Option<rendezvous::pb::mod_Message::ResponseStatus>,
pub statusText: Option<String>,
}
impl<'a> MessageRead<'a> for DiscoverResponse {
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.registrations.push(r.read_message::<rendezvous::pb::mod_Message::Register>(bytes)?),
Ok(18) => msg.cookie = Some(r.read_bytes(bytes)?.to_owned()),
Ok(24) => msg.status = Some(r.read_enum(bytes)?),
Ok(34) => msg.statusText = Some(r.read_string(bytes)?.to_owned()),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for DiscoverResponse {
fn get_size(&self) -> usize {
0
+ self.registrations.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ self.cookie.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+ self.status.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.statusText.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.registrations { w.write_with_tag(10, |w| w.write_message(s))?; }
if let Some(ref s) = self.cookie { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
if let Some(ref s) = self.status { w.write_with_tag(24, |w| w.write_enum(*s as i32))?; }
if let Some(ref s) = self.statusText { w.write_with_tag(34, |w| w.write_string(&**s))?; }
Ok(())
}
}
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum MessageType {
REGISTER = 0,
REGISTER_RESPONSE = 1,
UNREGISTER = 2,
DISCOVER = 3,
DISCOVER_RESPONSE = 4,
}
impl Default for MessageType {
fn default() -> Self {
MessageType::REGISTER
}
}
impl From<i32> for MessageType {
fn from(i: i32) -> Self {
match i {
0 => MessageType::REGISTER,
1 => MessageType::REGISTER_RESPONSE,
2 => MessageType::UNREGISTER,
3 => MessageType::DISCOVER,
4 => MessageType::DISCOVER_RESPONSE,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for MessageType {
fn from(s: &'a str) -> Self {
match s {
"REGISTER" => MessageType::REGISTER,
"REGISTER_RESPONSE" => MessageType::REGISTER_RESPONSE,
"UNREGISTER" => MessageType::UNREGISTER,
"DISCOVER" => MessageType::DISCOVER,
"DISCOVER_RESPONSE" => MessageType::DISCOVER_RESPONSE,
_ => Self::default(),
}
}
}
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum ResponseStatus {
OK = 0,
E_INVALID_NAMESPACE = 100,
E_INVALID_SIGNED_PEER_RECORD = 101,
E_INVALID_TTL = 102,
E_INVALID_COOKIE = 103,
E_NOT_AUTHORIZED = 200,
E_INTERNAL_ERROR = 300,
E_UNAVAILABLE = 400,
}
impl Default for ResponseStatus {
fn default() -> Self {
ResponseStatus::OK
}
}
impl From<i32> for ResponseStatus {
fn from(i: i32) -> Self {
match i {
0 => ResponseStatus::OK,
100 => ResponseStatus::E_INVALID_NAMESPACE,
101 => ResponseStatus::E_INVALID_SIGNED_PEER_RECORD,
102 => ResponseStatus::E_INVALID_TTL,
103 => ResponseStatus::E_INVALID_COOKIE,
200 => ResponseStatus::E_NOT_AUTHORIZED,
300 => ResponseStatus::E_INTERNAL_ERROR,
400 => ResponseStatus::E_UNAVAILABLE,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for ResponseStatus {
fn from(s: &'a str) -> Self {
match s {
"OK" => ResponseStatus::OK,
"E_INVALID_NAMESPACE" => ResponseStatus::E_INVALID_NAMESPACE,
"E_INVALID_SIGNED_PEER_RECORD" => ResponseStatus::E_INVALID_SIGNED_PEER_RECORD,
"E_INVALID_TTL" => ResponseStatus::E_INVALID_TTL,
"E_INVALID_COOKIE" => ResponseStatus::E_INVALID_COOKIE,
"E_NOT_AUTHORIZED" => ResponseStatus::E_NOT_AUTHORIZED,
"E_INTERNAL_ERROR" => ResponseStatus::E_INTERNAL_ERROR,
"E_UNAVAILABLE" => ResponseStatus::E_UNAVAILABLE,
_ => Self::default(),
}
}
}
}

0
protocols/rendezvous/src/rpc.proto → protocols/rendezvous/src/generated/rpc.proto
View File