Error when trying to use the request_response protocol

[elton-cs]

I'm trying to setup the request_response protocol to be able to send data between two nodes. I've taken a look at the tests and I seem to be following the flow correctly. I think there's some issue with the way my transport layer(s) are setup but I'm not quite sure where to go from here. I initially tried using QUIC and got a KeepAliveTimout error. After switching to TCP with TLS+Yamux, I'm now getting a IncomingConnectionError instead.

Here's my current implementation:

use libp2p::{
    multiaddr::Protocol,
    request_response::{self, ProtocolSupport},
    tls, yamux, Multiaddr, StreamProtocol,
};
use serde::{Deserialize, Serialize};
use tokio_stream::StreamExt;

#[tokio::main]
async fn main() {
    let oracle_behavior = request_response::cbor::Behaviour::<OracleRequest, OracleResponse>::new(
        [(StreamProtocol::new("/oracle"), ProtocolSupport::Full)],
        request_response::Config::default(),
    );

    let mut oracle_switch = libp2p::SwarmBuilder::with_new_identity()
        .with_tokio()
        .with_tcp(Default::default(), tls::Config::new, yamux::Config::default)
        .unwrap()
        .with_behaviour(|_| oracle_behavior)
        .unwrap()
        .build();

    let client_behavior = request_response::cbor::Behaviour::<OracleRequest, OracleResponse>::new(
        [(StreamProtocol::new("/oracle"), ProtocolSupport::Full)],
        request_response::Config::default(),
    );

    let mut client_switch = libp2p::SwarmBuilder::with_new_identity()
        .with_tokio()
        .with_tcp(Default::default(), tls::Config::new, yamux::Config::default)
        .unwrap()
        .with_behaviour(|_| client_behavior)
        .unwrap()
        .build();

    let tcp_multiaddress = Multiaddr::empty()
        .with(Protocol::Ip4("127.0.0.1".parse().unwrap()))
        .with(Protocol::Tcp(12345));

    oracle_switch.listen_on(tcp_multiaddress.clone()).unwrap();
    client_switch.dial(tcp_multiaddress.clone()).unwrap();

    let client = async move {
        loop {
            match client_switch.next().await {
                something => {
                    println!("CLIENT: {:?}", something);
                }
            }
        }
    };

    let oracle = async move {
        loop {
            match oracle_switch.next().await {
                something => {
                    println!("ORACLE: {:?}", something);
                }
            }
        }
    };

    tokio::spawn(client);
    oracle.await;
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct OracleRequest {
    pub request: String,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct OracleResponse {
    pub response: String,
}

[elton-cs]

Also, here's the exact error that the oracle node outputs:

Some(IncomingConnectionError { connection_id: ConnectionId(2), local_addr: "/ip4/127.0.0.1/tcp/12345", send_back_addr: "/ip4/127.0.0.1/tcp/56940", error: Transport(Other(Custom { kind: Other, error: Other(Right(Select(ProtocolError(IoError(Kind(UnexpectedEof)))))) })) })

[dariusc93]

The KeepAliveTimout error you got is likely due to the connection timing out after no activity. Increasing the idle time should help with that. As for IncomingConnectionError do you have any further logs you could provide?