JSON message exchange between js and rust peer

[Isakovic-Arim]

Setup

I am trying to send a JSON message from a peer with the js implementation to a peer with the rust implementation.
So far it only works the other way around, I can successfully retrieve a message sent from the rust peer on my js peer.

I am using webrtc-direct as the transport protocol for both implementations.

JS peer

This is the handler, which successfully retrieves a JSON message from the rust peer:

await libp2p.handle("/docker/1.0.0", async ({stream}) => {
    const sender = pushable();
    sender.push(uint8ArrayFromString(JSON.stringify({
        message: 'example'
    })));

    await pipe(
        stream,
        async function (source) {
            for await (const data of source) {
                console.log('data:', uint8ArrayToString(data.subarray()))
            }
        }
    )

    await pipe(sender, stream)
})

After I try to send a response back, the rust peer responds with an error of Io(Kind(BrokenPipe)).

When I try to send a request from the js peer to the rust peer with the following:

try {
    await pipe(
        [uint8ArrayFromString(JSON.stringify({
            name: 'example',
            image: 'alpine:3'
        }))],
        stream,
        async function (source) {
            for await (const data of source) {
                console.log('data', data)
            }
        }
    )
} catch (e) {
    console.error(e)
}

I receive an error of stream reset at WebRTCStream.reset.
The rust peer does not react to the message at all.

Rust peer

I am using the request-response protocol with the predefined json codec:

#[derive(Debug, Serialize, Deserialize)]
pub struct DockerRequest {
    pub name: String,
    pub image: String
}

#[derive(Debug, Serialize, Deserialize)]
pub struct DockerResponse {
    pub message: String
}

let docker_behaviour = json::Behaviour::<DockerRequest, DockerResponse>::new(
    [(StreamProtocol::new("/docker/1.0.0"), ProtocolSupport::Full)],
    request_response::Config::default()
);

I am also using the webrtc-direct protocol with the version 0.7.1-alpha:

.with_other_transport(|key| {
    Ok(webrtc::tokio::Transport::new(
        key.clone(),
        certificate,
    )
    .map(|(peer_id, conn), _| (peer_id, StreamMuxerBox::new(conn))))
})?

Problem

Other services, such as identify and ping work between the peers without any problems.
I have read here that rust does not support a webrtc-direct listener.
So is what I am trying to do even possible? If not, what is the best alternative?

I was uncertain whether this belonged here, since I don't know if the problem lies in the js- or rust-implementation.
I will remove the discussion if the issue lies on the js side.

Edit: The issue most likely lies with the webrtc transport. It is impossible to exchange streams or other behaviours over webrtc between two rust peers, as only one receives a message before the connection is ultimately reset.

[jxs]

Hi, do you have a MRE? Does your example work with other transports like TCP?

[dariusc93]

It almost sounds like you might want to give libp2p-stream a try or maybe use the Oneshot connection handler and parse your message after reading from the socket.