syndicate-lang
/
syndicate-rs
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

More error cleanup

This commit is contained in:
Tony Garnock-Jones 2020-05-25 16:13:11 +02:00
parent b72e5950bf
commit 9b3ced3165
4 changed files with 12 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/bin/syndicate-server.rs
View File

@ -22,24 +22,20 @@ fn other_eio<E: std::fmt::Display>(e: E) -> std::io::Error {
std::io::Error::new(std::io::ErrorKind::Other, e.to_string())
}
fn translate_sink_err(e: tungstenite::Error) -> packets::EncodeError {
packets::EncodeError::Write(other_eio(e))
}
fn encode_message(codec: &value::Codec<V, Syndicate>, p: packets::S2C) ->
Result<Message, packets::EncodeError>
Result<Message, std::io::Error>
{
use serde::ser::Serialize;
use preserves::ser::Serializer;
let mut bs = Vec::with_capacity(128);
let mut ser: Serializer<_, V, Syndicate> =
Serializer::new(&mut bs, codec.encode_placeholders.as_ref());
p.serialize(&mut ser).map_err(|e| std::io::Error::from(e))?;
p.serialize(&mut ser)?;
Ok(Message::Binary(bs))
}
fn message_encoder(codec: &value::Codec<V, Syndicate>)
-> impl Fn(packets::S2C) -> futures::future::Ready<Result<Message, packets::EncodeError>> + '_
-> impl Fn(packets::S2C) -> futures::future::Ready<Result<Message, std::io::Error>> + '_
{
return move |p| futures::future::ready(encode_message(codec, p));
}
@ -97,7 +93,7 @@ async fn run_connection(connid: ConnId,
let (o, i) = s.split();
let codec = packets::standard_preserves_codec();
let i = i.map(message_decoder(&codec));
let o = o.sink_map_err(translate_sink_err).with(message_encoder(&codec));
let o = o.sink_map_err(other_eio).with(message_encoder(&codec));
let mut p = Peer::new(connid, i, o);
p.run(spaces, &config).await?
},

6
src/dataspace.rs
View File

@ -138,8 +138,7 @@ impl Dataspace {
packets::Action::Assert(ref epname, ref assertion) => {
let ac = self.peers.get_mut(&id).unwrap();
if ac.endpoints.contains_key(&epname) {
return Err(("Duplicate endpoint name".to_string(),
value::to_value(a).unwrap()));
return Err(("Duplicate endpoint name".to_string(), value::to_value(a)));
}
let ar =
@ -171,8 +170,7 @@ impl Dataspace {
let ac = self.peers.get_mut(&id).unwrap();
match ac.endpoints.remove(epname) {
None => {
return Err(("Nonexistent endpoint name".to_string(),
value::to_value(a).unwrap()));
return Err(("Nonexistent endpoint name".to_string(), value::to_value(a)));
}
Some(ep) => {
self.remove_endpoint(&mut outbound_turns, id, epname, ep);

43
src/packets.rs
View File

@ -47,7 +47,7 @@ pub enum S2C {
#[derive(Debug)]
pub enum DecodeError {
Read(io::Error),
Parse(value::error::Error<Syndicate>, V),
Parse(value::de::error::Error<Syndicate>, V),
}
impl From<io::Error> for DecodeError {
@ -67,45 +67,6 @@ impl std::error::Error for DecodeError {
//---------------------------------------------------------------------------
#[derive(Debug)]
pub enum EncodeError {
Write(io::Error),
Unparse(value::error::Error<Syndicate>),
}
impl From<io::Error> for EncodeError {
fn from(v: io::Error) -> Self {
EncodeError::Write(v)
}
}
impl From<value::error::Error<Syndicate>> for EncodeError {
fn from(v: value::error::Error<Syndicate>) -> Self {
EncodeError::Unparse(v)
}
}
impl From<EncodeError> for io::Error {
fn from(v: EncodeError) -> Self {
match v {
EncodeError::Write(e) => e,
EncodeError::Unparse(e) =>
Self::new(io::ErrorKind::InvalidData, format!("{:?}", e)),
}
}
}
impl std::fmt::Display for EncodeError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{:?}", self)
}
}
impl std::error::Error for EncodeError {
}
//---------------------------------------------------------------------------
pub struct Codec<InT, OutT> {
codec: value::Codec<V, Syndicate>,
ph_in: PhantomData<InT>,
@ -161,7 +122,7 @@ impl<InT: serde::de::DeserializeOwned, OutT> tokio_util::codec::Decoder for Code
impl<InT, OutT: serde::Serialize> tokio_util::codec::Encoder<OutT> for Codec<InT, OutT>
{
type Error = EncodeError;
type Error = io::Error;
fn encode(&mut self, item: OutT, bs: &mut BytesMut) -> Result<(), Self::Error> {
let mut w = bs.writer();
let mut ser: Serializer<_, V, Syndicate> = Serializer::new(&mut w, self.codec.encode_placeholders.as_ref());

8
src/peer.rs
View File

@ -20,7 +20,7 @@ pub type ResultC2S = Result<packets::C2S, packets::DecodeError>;
pub struct Peer<I, O>
where I: Stream<Item = ResultC2S> + Send,
O: Sink<packets::S2C, Error = packets::EncodeError>,
O: Sink<packets::S2C, Error = std::io::Error>,
{
id: ConnId,
tx: UnboundedSender<packets::S2C>,
@ -36,7 +36,7 @@ fn err(s: &str, ctx: V) -> packets::S2C {
impl<I, O> Peer<I, O>
where I: Stream<Item = ResultC2S> + Send,
O: Sink<packets::S2C, Error = packets::EncodeError>,
O: Sink<packets::S2C, Error = std::io::Error>,
{
pub fn new(id: ConnId, i: I, o: O) -> Self {
let (tx, rx) = unbounded_channel();
@ -116,7 +116,7 @@ where I: Stream<Item = ResultC2S> + Send,
packets::C2S::Pong() =>
(),
packets::C2S::Connect(_) => {
to_send.push(err("Unexpected Connect", value::to_value(p).unwrap()));
to_send.push(err("Unexpected Connect", value::to_value(p)));
running = false;
}
}
@ -184,7 +184,7 @@ where I: Stream<Item = ResultC2S> + Send,
impl<I, O> Drop for Peer<I, O>
where I: Stream<Item = ResultC2S> + Send,
O: Sink<packets::S2C, Error = packets::EncodeError>,
O: Sink<packets::S2C, Error = std::io::Error>,
{
fn drop(&mut self) {
if let Some(ref s) = self.space {