fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-07-03 11:41:34 +00:00
Code Issues Projects Releases Wiki Activity

protocols/dcutr/examples: Wait to tell relay its public addr (#2659)

Browse Source 
As a listening client, when requesting a reservation with a relay, the relay
responds with its public addresses. The listening client can then use the public
addresses of the relay to advertise itself as reachable under a relayed
address (`/<public-relay-addr>/p2p-circuit/p2p/<listening-client-peer-id>`).

The above operates under the assumption that the relay knows its public address.
A relay learns its public address from remote peers, via the identify protocol.
In the case where the relay just started up, the listening client might be the
very first node to connect to it.

Such scenario allows for a race condition. The listening client requests a
reservation from the relay, while the relay requests its public address from the
listening client. The former needs to contain the response from the latter.

This commit serializes the two requests, making sure, in the case of a freshly
started relay, that the listening client tells the relay its public address
before requesting a reservation from the relay.

Co-authored-by: Elena Frank <elena.frank@protonmail.com>
This commit is contained in:
Max Inden
2022-05-20 21:59:32 +02:00
committed by GitHub
parent 686d6ff363
commit 1d6b08b0b6
2 changed files with 34 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
protocols/dcutr/examples/client.rs
View File

@ -186,22 +186,12 @@ fn main() -> Result<(), Box<dyn Error>> {
}
});
match opts.mode {
Mode::Dial => {
// Connect to the relay server. Not for the reservation or relayed connection, but to (a) learn
// our local public address and (b) enable a freshly started relay to learn its public address.
swarm.dial(opts.relay_address.clone()).unwrap();
}
Mode::Listen => {
swarm
.listen_on(opts.relay_address.clone().with(Protocol::P2pCircuit))
.unwrap();
}
}
// Wait till connected to relay to learn external address. In case we are in listening mode,
// wait for the relay to accept our reservation request.
block_on(async {
let mut learned_observed_addr = false;
let mut relay_accepted_reservation = false;
let mut told_relay_observed_addr = false;
loop {
match swarm.next().await.unwrap() {
@ -209,47 +199,42 @@ fn main() -> Result<(), Box<dyn Error>> {
SwarmEvent::Dialing { .. } => {}
SwarmEvent::ConnectionEstablished { .. } => {}
SwarmEvent::Behaviour(Event::Ping(_)) => {}
SwarmEvent::Behaviour(Event::Relay(client::Event::ReservationReqAccepted {
..
})) => {
info!("Relay accepted our reservation request.");
relay_accepted_reservation = true
SwarmEvent::Behaviour(Event::Identify(IdentifyEvent::Sent { .. })) => {
info!("Told relay its public address.");
told_relay_observed_addr = true;
}
SwarmEvent::Behaviour(Event::Identify(IdentifyEvent::Sent { .. })) => {}
SwarmEvent::Behaviour(Event::Identify(IdentifyEvent::Received {
info: IdentifyInfo { observed_addr, .. },
..
})) => {
info!("Relay observes us under the address: {:?}", observed_addr);
info!("Relay told us our public address: {:?}", observed_addr);
learned_observed_addr = true;
}
event => panic!("{:?}", event),
}
// Check whether we are done.
if !learned_observed_addr {
continue;
}
if opts.mode == Mode::Listen && !relay_accepted_reservation {
continue;
}
if learned_observed_addr && told_relay_observed_addr {
break;
}
}
});
if opts.mode == Mode::Dial {
match opts.mode {
Mode::Dial => {
swarm
.dial(
opts.relay_address
.clone()
.with(Protocol::P2pCircuit)
.with(Protocol::P2p(opts.remote_peer_id.unwrap().into())),
)
.unwrap();
}
Mode::Listen => {
swarm
.listen_on(opts.relay_address.with(Protocol::P2pCircuit))
.unwrap();
}
}
block_on(async {
loop {
@ -257,6 +242,12 @@ fn main() -> Result<(), Box<dyn Error>> {
SwarmEvent::NewListenAddr { address, .. } => {
info!("Listening on {:?}", address);
}
SwarmEvent::Behaviour(Event::Relay(client::Event::ReservationReqAccepted {
..
})) => {
assert!(opts.mode == Mode::Listen);
info!("Relay accepted our reservation request.");
}
SwarmEvent::Behaviour(Event::Relay(event)) => {
info!("{:?}", event)
}

4
src/tutorials/hole_punching.rs
View File

@ -136,8 +136,10 @@
//! [2022-05-11T10:38:52Z INFO client] Local peer id: PeerId("XXX")
//! [2022-05-11T10:38:52Z INFO client] Listening on "/ip4/127.0.0.1/tcp/44703"
//! [2022-05-11T10:38:52Z INFO client] Listening on "/ip4/XXX/tcp/44703"
//! [2022-05-11T10:38:54Z INFO client] Relay told us our public address: "/ip4/XXX/tcp/53160"
//! [2022-05-11T10:38:54Z INFO client] Told relay its public address.
//! [2022-05-11T10:38:54Z INFO client] Relay accepted our reservation request.
//! [2022-05-11T10:38:54Z INFO client] Relay observes us under the address: "/ip4/XXX/tcp/53160"
//! [2022-05-11T10:38:54Z INFO client] Listening on "/ip4/$RELAY_SERVER_IP/tcp/4001/p2p/12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN/p2p-circuit/p2p/XXX"
//! ```
//!
//! Now let's make sure that the listening client is not public, in other words let's make sure one