hi,
Can't seem to be able to use it my code.

I did import tokio-serde = "0.8.0" in my dependencies, maybe I'm missing something ?

Though when i put use tokio_serde::SymmetricallyFramed in code for example it does recognize it.

Using the lib on a length_delimited like this:

caused data to accumulate (buffer up), and when I would close the sending connection it would flush the buffered values somehow, causing lag, this was really hard to locate.

rewriting the functionality like (which is functionality wise identical), removed the lag and the "buffering". Any idea what causes this "buffering" to happen?

Perhaps I'm missing something obvious but I'm finding it difficult to wrap one object which implements both Stream+Sink, with both the FramedRead and FramedWrite wrappers. If there is a simple way to do this, maybe an example could be added.

Thanks

I have a large client-server software where the messages are encoded and decoded through bincode and may contain a bunch of strings, integers, floats, etc.

I recently tried to move to tokio which simplifies and fixes portability bugs (random os error 35 on macOS for example). To move the code I've used tokio-serde to support deserializing the packets serialize through bincode. Unfortunately, every-time a packet contains a bunch of strings tokio-serde errors with "frame size too big".

Is there any workaround to this bug?

Currently, this only works for streams over BytesMut. It would be nice to also support streams that yield String, for example.

Thanks for this library, really appreciate it. Its saving me a lot of time.

I was wondering if https://docs.rs/tokio/1.0.2/tokio/net/struct.TcpStream.html#method.into_split would ever get any support?

I want to read and write from the same stream, I kinda needed to do something hacky to achieve this, is there any alternative to this?

let stream1 = stream.into_std().unwrap();
let stream2 = stream1.try_clone().unwrap();

let stream1_ = TcpStream::from_std(stream1).unwrap();
let stream2_ = TcpStream::from_std(stream2).unwrap();

let length_delimited = FramedWrite::new(stream1_, LengthDelimitedCodec::new());
let length_delimited_ = FramedRead::new(stream2_, LengthDelimitedCodec::new());

Is there any reason why it isn't already?

This crate is now the crate to be used, isn't it?

Hi, just tried tokio-serde and I might be doing it wrong.

Client is modified to look like:

#[tokio::main]
pub async fn main() {
    let socket = TcpStream::connect("127.0.0.1:17653").await.unwrap();
    let length_delimited = FramedWrite::new(socket, LengthDelimitedCodec::new());
    let mut serialized = tokio_serde::SymmetricallyFramed::new(length_delimited, SymmetricalBincode::default());

    let thing = tokio_serde::Thing { val: 123 };
    let some_data = bincode_crate::serialize(&thing).unwrap();

    serialized
        .send(some_data)
        .await
        .unwrap()
}

Server is now:

#[tokio::main]
pub async fn main() {
    let mut listener = TcpListener::bind("127.0.0.1:17653").await.unwrap();
    println!("listening on {:?}", listener.local_addr());

    while let Some(socket) = listener.try_next().await.unwrap() {
        let length_delimited = FramedRead::new(socket, LengthDelimitedCodec::new());

        let mut deserialized = tokio_serde::SymmetricallyFramed::new(
            length_delimited,
            SymmetricalBincode::<Thing>::default(),
        );

        tokio::spawn(async move {
            while let Some(msg) = deserialized.try_next().await.unwrap() {
                println!("GOT: {:?}", msg);
            }
        });
    }
}

And thing is simply:

#[derive(Debug, Serialize, Deserialize)]
pub struct Thing {
    pub val: usize,
}

Client sends successfully, but server panics:

called Result::unwrap() on an Err value: Custom { kind: InvalidData, error: Custom("Slice had bytes remaining after deserialization") }

I see that the bincode options default to rejecting extra bytes, which I would assume is a good thing.
Have I just missed something?

Thanks!