How to combine QUIC and relay client transports?

[mycognosist]

I'm attempting to combine a QUIC transport and relay client transport before passing it into a SwarmBuilder. I can't seem to find an example of this particular combination (most examples use TCP) and am struggling to understand the OrTransport procedure.

Here's an example that mentions QUIC and relay: #2883 (comment)

Here is my incorrect attempt:

// Generate a relay transport and client behaviour if relay client mode is selected
let (relay_transport, relay_client) = if network_config.relay_client {
    let (relay_transport, relay_client) = relay::client::new(key_pair.public().to_peer_id());
    (Some(relay_transport), Some(relay_client))
} else {
    (None, None)
};

// Configure the QUIC transport and define the listening address
let quic_config = quic::Config::new(&key_pair);
let quic_multiaddr =
    format!("/ip4/0.0.0.0/udp/{}/quic-v1", network_config.quic_port).parse()?;

// Create QUIC transport (provides transport, security and multiplexing in a single protocol)
let quic_transport = quic::tokio::Transport::new(quic_config)
    .map(|(p, c), _| (p, StreamMuxerBox::new(c)))
    .boxed();

/* This next code block is definitely incorrect... */

// Create a combined transport incorporating QUIC and relay
let transport = if let Some(relay_transport) = relay_transport {
    OrTransport::new(relay_transport, quic_transport)
        .map(|either_output, _| match either_output {
            Either::Left((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
            Either::Right((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
        })
        .boxed()
} else {
    quic_transport
};

// Instantiate the custom network behaviour with default configuration and the libp2p peer ID
let behaviour = Behaviour::new(&network_config, peer_id, key_pair, relay_client)?;

// Initialise a swarm with QUIC transports, our composed network behaviour and the default configuration parameters
let mut swarm = SwarmBuilder::with_tokio_executor(transport, behaviour, peer_id)
    .connection_limits(network_config.connection_limits())
    .dial_concurrency_factor(network_config.dial_concurrency_factor.try_into()?)
    .per_connection_event_buffer_size(network_config.per_connection_event_buffer_size)
    .notify_handler_buffer_size(network_config.notify_handler_buffer_size.try_into()?)
    .build();

Compiler output:

error[E0308]: mismatched types

   |
66 |             .map(|either_output, _| match either_output {
   |                                           ------------- this expression has type `futures::future::Either<libp2p::libp2p_relay::client::Connection, (PeerId, StreamMuxerBox)>`
67 |                 Either::Left((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
   |                              ^^^^^^^^^^^^^^^^ expected enum `libp2p::libp2p_relay::client::Connection`, found tuple
   |
   = note: expected enum `libp2p::libp2p_relay::client::Connection`
             found tuple `(_, _)`

[thomaseizinger]

You've picked a tricky one :)

The problem is that Option does not implement Transport (maybe it should?). We have Toggle for that.

Try wrapping your Option<relay_transport> in that by adding:

let relay_transport = Toggle::from(relay_transport);

cc @mxinden I remember we talked about Toggle in the past and whether it is discoverable or not. This might be a data point that Option itself is better.

[thomaseizinger]

Another idea would be to not make the relay-transport optional. Unless you hand it a relayed address to listen on, it doesn't do anything and thus doesn't hurt having it in there unconditionally.

[mycognosist]

Thanks for the swift assistance, @thomaseizinger.

Trying your first suggestion (converting the Option<relay_transport> to a Toggle) results in a "trait bounds not satisfied" error:

let (relay_transport, relay_client) = if network_config.relay_client {
    let (relay_transport, relay_client) = relay::client::new(key_pair.public().to_peer_id());
    (Some(relay_transport), Some(relay_client))
} else {
    (None, None)
};

let quic_transport = quic::tokio::Transport::new(quic_config)
    .map(|(p, c), _| (p, StreamMuxerBox::new(c)))
    .boxed();

let relay_transport = Toggle::from(relay_transport);

let transport = OrTransport::new(relay_transport, quic_transport)
    .map(|either_output, _| match either_output {
        Either::Left((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
        Either::Right((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
    })
    .boxed();

error[E0599]: the method `map` exists for struct `OrTransport<GenTransport<libp2p::libp2p_quic::tokio::Provider>, Toggle<libp2p::libp2p_relay::client::Transport>>`, but its trait bounds were not satisfied

   |
69 |         .map(|either_output, _| match either_output {
   |          ^^^ method cannot be called on `OrTransport<GenTransport<libp2p::libp2p_quic::tokio::Provider>, Toggle<libp2p::libp2p_relay::client::Transport>>` due to unsatisfied trait bounds
   |
  ::: /home/user/.cargo/registry/src/github.aaakk.us.kg-1ecc6299db9ec823/libp2p-swarm-0.42.0/src/behaviour/toggle.rs:41:1
   |
41 | pub struct Toggle<TBehaviour> {
   | ----------------------------- doesn't satisfy `_: libp2p::Transport`
   |
  ::: /home/user/.cargo/registry/src/github.aaakk.us.kg-1ecc6299db9ec823/libp2p-core-0.39.1/src/transport/choice.rs:31:1
   |
31 | pub struct OrTransport<A, B>(#[pin] A, #[pin] B);
   | ----------------------------
   | |
   | doesn't satisfy `_: Iterator`
   | doesn't satisfy `_: StreamExt`
   | doesn't satisfy `_: Stream`
   | doesn't satisfy `_: libp2p::Transport`

And the second suggestion (do not make the relay transport optional) results in a "mismatched types" error:

let (relay_transport, relay_client) = relay::client::new(key_pair.public().to_peer_id());
let relay_client = Some(relay_client);

let quic_transport = quic::tokio::Transport::new(quic_config)
    .map(|(p, c), _| (p, StreamMuxerBox::new(c)))
    .boxed();

let transport = OrTransport::new(relay_transport, quic_transport)
    .map(|either_output, _| match either_output {
        Either::Left((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
        Either::Right((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
    })
    .boxed();

error[E0308]: mismatched types

   |
69 |         .map(|either_output, _| match either_output {
   |                                       ------------- this expression has type `futures::future::Either<libp2p::libp2p_relay::client::Connection, (PeerId, libp2p::libp2p_quic::Connection)>`
70 |             Either::Left((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
   |                          ^^^^^^^^^^^^^^^^ expected enum `libp2p::libp2p_relay::client::Connection`, found tuple
   |
   = note: expected enum `libp2p::libp2p_relay::client::Connection`
             found tuple `(_, _)`

[thomaseizinger]

Ah yes, it is because a relay connection is not yet multiplexed and secured. Try this:

let (relay_transport, relay_client) = relay::client::new(local_peer_id);

  let relay_transport = relay_transport
      .upgrade(Version::V1)
      .authenticate(noise::NoiseAuthenticated::xx(&local_key).unwrap())
      .multiplex(yamux::YamuxConfig::default());

  let quic_transport = quic::tokio::Transport::new(quic::Config::new(&local_key));
  
  let transport = quic_transport
      .or_transport(relay_transport)
      .map(|either_output, _| match either_output {
          Either::Left((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
          Either::Right((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
      })
      .boxed();

[mycognosist]

Bingo! That did it :) 🙏🏻

[thomaseizinger]

Related: #3143.