From c6f4191aba2881129ff3335565f2331c78d5681c Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Wed, 17 Jul 2024 12:31:25 +0300 Subject: [PATCH 01/11] transport: Fix double lock and state overwrite on disconnected peers Signed-off-by: Alexandru Vasile --- src/transport/manager/mod.rs | 74 ++++++++++++++++++++++-------------- 1 file changed, 46 insertions(+), 28 deletions(-) diff --git a/src/transport/manager/mod.rs b/src/transport/manager/mod.rs index a7248811a..e8b6e4f6d 100644 --- a/src/transport/manager/mod.rs +++ b/src/transport/manager/mod.rs @@ -44,7 +44,7 @@ use parking_lot::RwLock; use tokio::sync::mpsc::{channel, Receiver, Sender}; use std::{ - collections::{HashMap, HashSet}, + collections::{hash_map::Entry, HashMap, HashSet}, pin::Pin, sync::{ atomic::{AtomicUsize, Ordering}, @@ -435,7 +435,7 @@ impl TransportManager { tracing::debug!( target: LOG_TARGET, ?peer, - "peer is aready being dialed", + "peer is already being dialed", ); peers.insert( @@ -625,35 +625,53 @@ impl TransportManager { { let mut peers = self.peers.write(); - match peers.get_mut(&remote_peer_id) { - None => { - drop(peers); - self.peers.write().insert( - remote_peer_id, - PeerContext { - state: PeerState::Dialing { - record: record.clone(), - }, - addresses: AddressStore::new(), - secondary_connection: None, - }, + match peers.entry(remote_peer_id) { + Entry::Occupied(occupied) => { + let context = occupied.into_mut(); + + tracing::debug!( + target: LOG_TARGET, + peer = ?remote_peer_id, + state = ?context.state, + "peer state exists", ); + + match context.state { + PeerState::Connected { .. } => { + return Err(Error::AlreadyConnected); + } + PeerState::Dialing { .. } | PeerState::Opening { .. } => { + return Ok(()); + } + PeerState::Disconnected { + dial_record: Some(_), + } => { + tracing::debug!( + target: LOG_TARGET, + peer = ?remote_peer_id, + state = ?context.state, + "peer is already being dialed from a disconnected state" + ); + + return Ok(()); + } + PeerState::Disconnected { dial_record: None } => { + context.state = PeerState::Dialing { + record: record.clone(), + }; + } + } } - Some(PeerContext { - state: - PeerState::Dialing { .. } - | PeerState::Connected { .. } - | PeerState::Opening { .. }, - .. - }) => return Ok(()), - Some(PeerContext { ref mut state, .. }) => { - // TODO: verify that the address is not in `addresses` already - // addresses.insert(address.clone()); - *state = PeerState::Dialing { - record: record.clone(), - }; + Entry::Vacant(vacant) => { + vacant.insert(PeerContext { + state: PeerState::Dialing { + record: record.clone(), + }, + addresses: AddressStore::new(), + secondary_connection: None, + }); } - } + }; } self.transports From c54c0c833a709a404f0dd129e9a3b8e9e924d0f4 Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Wed, 17 Jul 2024 12:54:08 +0300 Subject: [PATCH 02/11] transport: Warn missmatching dial failures wrt connection IDs Signed-off-by: Alexandru Vasile --- src/transport/manager/mod.rs | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/src/transport/manager/mod.rs b/src/transport/manager/mod.rs index e8b6e4f6d..b8e69308f 100644 --- a/src/transport/manager/mod.rs +++ b/src/transport/manager/mod.rs @@ -652,10 +652,10 @@ impl TransportManager { state = ?context.state, "peer is already being dialed from a disconnected state" ); - return Ok(()); } PeerState::Disconnected { dial_record: None } => { + // TODO: verify that the address is not in `context.addresses` already. context.state = PeerState::Dialing { record: record.clone(), }; @@ -702,7 +702,7 @@ impl TransportManager { target: LOG_TARGET, ?peer, ?connection_id, - "dial failed for a peer that doens't exist", + "dial failed for a peer that doesn't exist", ); debug_assert!(false); @@ -715,6 +715,22 @@ impl TransportManager { ) { PeerState::Dialing { ref mut record } => { debug_assert_eq!(record.connection_id(), &Some(connection_id)); + if record.connection_id() != &Some(connection_id) { + tracing::warn!( + target: LOG_TARGET, + ?peer, + ?connection_id, + ?record, + "unknown dial failure, ignore secondary dial failure", + ); + + context.state = PeerState::Dialing { + record: record.clone(), + }; + debug_assert!(false); + + return Ok(()); + } record.update_score(SCORE_CONNECT_FAILURE); context.addresses.insert(record.clone()); From 3461347588e2acf60e24941f1efa2569d9a2cc18 Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Wed, 17 Jul 2024 13:49:00 +0300 Subject: [PATCH 03/11] transport: Update address score accordingly on on_dial_failure Signed-off-by: Alexandru Vasile --- src/transport/manager/mod.rs | 40 ++++++++++++++++++++++++++++++---- src/transport/manager/types.rs | 4 ++-- 2 files changed, 38 insertions(+), 6 deletions(-) diff --git a/src/transport/manager/mod.rs b/src/transport/manager/mod.rs index b8e69308f..9bd6c8bac 100644 --- a/src/transport/manager/mod.rs +++ b/src/transport/manager/mod.rs @@ -721,14 +721,13 @@ impl TransportManager { ?peer, ?connection_id, ?record, - "unknown dial failure, ignore secondary dial failure", + "unknown dial failure for a dialing peer", ); context.state = PeerState::Dialing { record: record.clone(), }; debug_assert!(false); - return Ok(()); } @@ -745,6 +744,23 @@ impl TransportManager { record, dial_record: Some(mut dial_record), } => { + if dial_record.connection_id() != &Some(connection_id) { + tracing::warn!( + target: LOG_TARGET, + ?peer, + ?connection_id, + ?record, + "unknown dial failure for a connected peer", + ); + + context.state = PeerState::Connected { + record, + dial_record: Some(dial_record), + }; + debug_assert!(false); + return Ok(()); + } + dial_record.update_score(SCORE_CONNECT_FAILURE); context.addresses.insert(dial_record); @@ -764,6 +780,22 @@ impl TransportManager { "dial failed for a disconnected peer", ); + if dial_record.connection_id() != &Some(connection_id) { + tracing::warn!( + target: LOG_TARGET, + ?peer, + ?connection_id, + ?dial_record, + "unknown dial failure for a disconnected peer", + ); + + context.state = PeerState::Disconnected { + dial_record: Some(dial_record), + }; + debug_assert!(false); + return Ok(()); + } + dial_record.update_score(SCORE_CONNECT_FAILURE); context.addresses.insert(dial_record); @@ -1085,9 +1117,9 @@ impl TransportManager { }); // since an inbound connection was removed, the outbound connection can be - // removed from pendind dials + // removed from pending dials // - // all records have the same `ConnectionId` so it doens't matter which of them + // all records have the same `ConnectionId` so it doesn't matter which of them // is used to remove the pending dial self.pending_connections.remove( &records diff --git a/src/transport/manager/types.rs b/src/transport/manager/types.rs index 8bcdcdb9c..befabf0f3 100644 --- a/src/transport/manager/types.rs +++ b/src/transport/manager/types.rs @@ -55,7 +55,7 @@ pub enum PeerState { /// /// While the local node was dialing a remote peer, the remote peer might've dialed /// the local node and connection was established successfully. This dial address - /// is stored for processing later when the dial attempt conclused as either + /// is stored for processing later when the dial attempt concluded as either /// successful/failed. dial_record: Option, }, @@ -97,7 +97,7 @@ pub struct PeerContext { /// Peer state. pub state: PeerState, - /// Seconary connection, if it's open. + /// Secondary connection, if it's open. pub secondary_connection: Option, /// Known addresses of peer. From f902a78fa5372d86ab4c50c8b9a8836c8a69837c Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Wed, 17 Jul 2024 13:54:26 +0300 Subject: [PATCH 04/11] transport: Track dial addresses Signed-off-by: Alexandru Vasile --- src/transport/manager/mod.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/transport/manager/mod.rs b/src/transport/manager/mod.rs index 9bd6c8bac..72bc90420 100644 --- a/src/transport/manager/mod.rs +++ b/src/transport/manager/mod.rs @@ -629,6 +629,12 @@ impl TransportManager { Entry::Occupied(occupied) => { let context = occupied.into_mut(); + // `context.addresses.insert` does not overwrite the existing record. + // This inserts the record with a score of 0 if it doesn't exist, for + // keeping track of the potential address. This becomes useful for + // consecutive `fn dial` calls. + context.addresses.insert(record.clone()); + tracing::debug!( target: LOG_TARGET, peer = ?remote_peer_id, @@ -655,7 +661,6 @@ impl TransportManager { return Ok(()); } PeerState::Disconnected { dial_record: None } => { - // TODO: verify that the address is not in `context.addresses` already. context.state = PeerState::Dialing { record: record.clone(), }; From 0c4aa518b4d82b30605df15a405207ef6e7e3ec0 Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Wed, 17 Jul 2024 14:20:04 +0300 Subject: [PATCH 05/11] transport/tests: Ensure multiple dials do not overwrite the current dial Signed-off-by: Alexandru Vasile --- src/transport/manager/mod.rs | 94 ++++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) diff --git a/src/transport/manager/mod.rs b/src/transport/manager/mod.rs index 72bc90420..3cf964044 100644 --- a/src/transport/manager/mod.rs +++ b/src/transport/manager/mod.rs @@ -2997,6 +2997,25 @@ mod tests { }; manager.dial(peer).await.unwrap(); + + // Check state is unaltered. + { + let peers = manager.peers.read(); + let peer_context = peers.get(&peer).unwrap(); + + match &peer_context.state { + PeerState::Dialing { record } => { + assert_eq!( + record.address(), + &Multiaddr::empty() + .with(Protocol::Ip4(std::net::Ipv4Addr::new(127, 0, 0, 1))) + .with(Protocol::Tcp(8888)) + .with(Protocol::P2p(Multihash::from(peer))) + ); + } + state => panic!("invalid state: {state:?}"), + } + } } #[tokio::test] @@ -3337,4 +3356,79 @@ mod tests { state => panic!("invalid peer state: {state:?}"), } } + + #[tokio::test] + async fn do_not_overwrite_dial_addresses() { + let _ = tracing_subscriber::fmt() + .with_env_filter(tracing_subscriber::EnvFilter::from_default_env()) + .try_init(); + + let (mut manager, _handle) = TransportManager::new( + Keypair::generate(), + HashSet::new(), + BandwidthSink::new(), + 8usize, + ); + let peer = PeerId::random(); + let dial_address = Multiaddr::empty() + .with(Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1))) + .with(Protocol::Tcp(8888)) + .with(Protocol::P2p( + Multihash::from_bytes(&peer.to_bytes()).unwrap(), + )); + + let connection_id = ConnectionId::from(0); + let transport = Box::new({ + let mut transport = DummyTransport::new(); + transport.inject_event(TransportEvent::ConnectionEstablished { + peer, + endpoint: Endpoint::listener(dial_address.clone(), connection_id), + }); + transport + }); + manager.register_transport(SupportedTransport::Tcp, transport); + + // First dial attempt. + manager.dial_address(dial_address.clone()).await.unwrap(); + // check the state of the peer. + { + let peers = manager.peers.read(); + let peer_context = peers.get(&peer).unwrap(); + match &peer_context.state { + PeerState::Dialing { record } => { + assert_eq!(record.address(), &dial_address); + } + state => panic!("invalid state: {state:?}"), + } + + // The address is not saved yet. + assert!(!peer_context.addresses.contains(&dial_address)); + } + + let second_address = Multiaddr::empty() + .with(Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1))) + .with(Protocol::Tcp(8889)) + .with(Protocol::P2p( + Multihash::from_bytes(&peer.to_bytes()).unwrap(), + )); + + // Second dial attempt with different address. + manager.dial_address(second_address.clone()).await.unwrap(); + // check the state of the peer. + { + let peers = manager.peers.read(); + let peer_context = peers.get(&peer).unwrap(); + match &peer_context.state { + // Must still be dialing the first address. + PeerState::Dialing { record } => { + assert_eq!(record.address(), &dial_address); + } + state => panic!("invalid state: {state:?}"), + } + + // The address is saved. + assert!(!peer_context.addresses.contains(&dial_address)); + assert!(peer_context.addresses.contains(&second_address)); + } + } } From 9a804a787728ee3295b3b069c90cffac085fee7c Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Wed, 17 Jul 2024 14:30:22 +0300 Subject: [PATCH 06/11] transport: Saturating add Signed-off-by: Alexandru Vasile --- src/transport/manager/address.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/transport/manager/address.rs b/src/transport/manager/address.rs index 9a4627d24..399a7dc03 100644 --- a/src/transport/manager/address.rs +++ b/src/transport/manager/address.rs @@ -102,7 +102,7 @@ impl AddressRecord { /// Update score of an address. pub fn update_score(&mut self, score: i32) { - self.score += score; + self.score = self.score.saturating_add(score); } /// Set `ConnectionId` for the [`AddressRecord`]. From 68bb6791c114ed9da6e3c2b4ea19e36ca3ca3f84 Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Wed, 17 Jul 2024 14:33:15 +0300 Subject: [PATCH 07/11] transport: Extend todo with more information for separate PR Signed-off-by: Alexandru Vasile --- src/transport/manager/mod.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/transport/manager/mod.rs b/src/transport/manager/mod.rs index 3cf964044..0d36d5bef 100644 --- a/src/transport/manager/mod.rs +++ b/src/transport/manager/mod.rs @@ -633,7 +633,8 @@ impl TransportManager { // This inserts the record with a score of 0 if it doesn't exist, for // keeping track of the potential address. This becomes useful for // consecutive `fn dial` calls. - context.addresses.insert(record.clone()); + // However, the record score cannot be updated in the future. + // TODO: context.addresses.insert(record.clone()); tracing::debug!( target: LOG_TARGET, @@ -3426,9 +3427,8 @@ mod tests { state => panic!("invalid state: {state:?}"), } - // The address is saved. assert!(!peer_context.addresses.contains(&dial_address)); - assert!(peer_context.addresses.contains(&second_address)); + assert!(!peer_context.addresses.contains(&second_address)); } } } From daa147b163c8c9bcd4d4117bf3a61c2e52c3d7ba Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Wed, 17 Jul 2024 19:48:05 +0300 Subject: [PATCH 08/11] transport/tests: Backport test from PR #176 Signed-off-by: Alexandru Vasile --- src/transport/manager/mod.rs | 156 ++++++++++++++++++++++++++++++++++- 1 file changed, 155 insertions(+), 1 deletion(-) diff --git a/src/transport/manager/mod.rs b/src/transport/manager/mod.rs index 0d36d5bef..0a79ed8e0 100644 --- a/src/transport/manager/mod.rs +++ b/src/transport/manager/mod.rs @@ -75,7 +75,7 @@ const SCORE_CONNECT_SUCCESS: i32 = 100i32; /// Score for a non-working address. const SCORE_CONNECT_FAILURE: i32 = -100i32; -/// TODO: +#[derive(Debug, Clone, Copy, PartialEq, Eq)] enum ConnectionEstablishedResult { /// Accept connection and inform `Litep2p` about the connection. Accept, @@ -3431,4 +3431,158 @@ mod tests { assert!(!peer_context.addresses.contains(&second_address)); } } + + #[tokio::test] + async fn reject_unknown_secondary_connections_with_different_connection_ids() { + // This is the repro case for https://github.com/paritytech/litep2p/issues/172. + let _ = tracing_subscriber::fmt() + .with_env_filter(tracing_subscriber::EnvFilter::from_default_env()) + .try_init(); + + let (mut manager, _handle) = TransportManager::new( + Keypair::generate(), + HashSet::new(), + BandwidthSink::new(), + 8usize, + ); + manager.register_transport(SupportedTransport::Tcp, Box::new(DummyTransport::new())); + + // Random peer ID. + let peer = PeerId::random(); + + let setup_dial_addr = |connection_id: u16| { + let dial_address = Multiaddr::empty() + .with(Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1))) + .with(Protocol::Tcp(8888 + connection_id)) + .with(Protocol::P2p( + Multihash::from_bytes(&peer.to_bytes()).unwrap(), + )); + let connection_id = ConnectionId::from(connection_id as usize); + + (dial_address, connection_id) + }; + + // Setup addresses. + let (first_addr, first_connection_id) = setup_dial_addr(0); + let (second_addr, _second_connection_id) = setup_dial_addr(1); + let (remote_addr, remote_connection_id) = setup_dial_addr(2); + + // Step 1. Dialing state to peer. + manager.dial_address(first_addr.clone()).await.unwrap(); + { + let peers = manager.peers.read(); + let peer_context = peers.get(&peer).unwrap(); + match &peer_context.state { + PeerState::Dialing { record } => { + assert_eq!(record.address(), &first_addr); + } + state => panic!("invalid state: {state:?}"), + } + } + + // Step 2. Connection established by the remote peer. + let result = manager + .on_connection_established( + peer, + &Endpoint::listener(remote_addr.clone(), remote_connection_id), + ) + .unwrap(); + assert_eq!(result, ConnectionEstablishedResult::Accept); + { + let peers = manager.peers.read(); + let peer_context = peers.get(&peer).unwrap(); + match &peer_context.state { + PeerState::Connected { + record, + dial_record, + } => { + assert_eq!(record.address(), &remote_addr); + assert_eq!(record.connection_id(), &Some(remote_connection_id)); + + let dial_record = dial_record.as_ref().unwrap(); + assert_eq!(dial_record.address(), &first_addr); + assert_eq!(dial_record.connection_id(), &Some(first_connection_id)) + } + state => panic!("invalid state: {state:?}"), + } + } + + // Step 3. The peer disconnects while we have a dialing in flight. + let event = manager.on_connection_closed(peer, remote_connection_id).unwrap().unwrap(); + match event { + TransportEvent::ConnectionClosed { + peer: event_peer, + connection_id: event_connection_id, + } => { + assert_eq!(peer, event_peer); + assert_eq!(event_connection_id, remote_connection_id); + } + event => panic!("invalid event: {event:?}"), + } + { + let peers = manager.peers.read(); + let peer_context = peers.get(&peer).unwrap(); + match &peer_context.state { + PeerState::Disconnected { dial_record } => { + let dial_record = dial_record.as_ref().unwrap(); + assert_eq!(dial_record.address(), &first_addr); + assert_eq!(dial_record.connection_id(), &Some(first_connection_id)); + } + state => panic!("invalid state: {state:?}"), + } + } + + // Step 4. Dial by the second address and expect to not overwrite the state. + manager.dial_address(second_addr.clone()).await.unwrap(); + // The state remains unchanged since we already have a dialing in flight. + { + let peers = manager.peers.read(); + let peer_context = peers.get(&peer).unwrap(); + match &peer_context.state { + PeerState::Disconnected { dial_record } => { + let dial_record = dial_record.as_ref().unwrap(); + assert_eq!(dial_record.address(), &first_addr); + assert_eq!(dial_record.connection_id(), &Some(first_connection_id)); + } + state => panic!("invalid state: {state:?}"), + } + } + + // Step 5. Remote peer reconnects again. + let result = manager + .on_connection_established( + peer, + &Endpoint::listener(remote_addr.clone(), remote_connection_id), + ) + .unwrap(); + assert_eq!(result, ConnectionEstablishedResult::Accept); + { + let peers = manager.peers.read(); + let peer_context = peers.get(&peer).unwrap(); + match &peer_context.state { + PeerState::Connected { + record, + dial_record, + } => { + assert_eq!(record.address(), &remote_addr); + assert_eq!(record.connection_id(), &Some(remote_connection_id)); + + // We have not overwritten the first dial record in step 4. + let dial_record = dial_record.as_ref().unwrap(); + assert_eq!(dial_record.address(), &first_addr); + assert_eq!(dial_record.connection_id(), &Some(first_connection_id)); + } + state => panic!("invalid state: {state:?}"), + } + } + + // Step 6. First dial responds. + let result = manager + .on_connection_established( + peer, + &Endpoint::dialer(first_addr.clone(), first_connection_id), + ) + .unwrap(); + assert_eq!(result, ConnectionEstablishedResult::Accept); + } } From 062ed6d3940b1394e9c908ead033835c45ddeca2 Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Fri, 2 Aug 2024 18:19:55 +0300 Subject: [PATCH 09/11] transport/manager: Update comment with link to issue Signed-off-by: Alexandru Vasile --- src/transport/manager/mod.rs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/transport/manager/mod.rs b/src/transport/manager/mod.rs index 0a79ed8e0..d8efcecd6 100644 --- a/src/transport/manager/mod.rs +++ b/src/transport/manager/mod.rs @@ -629,11 +629,9 @@ impl TransportManager { Entry::Occupied(occupied) => { let context = occupied.into_mut(); - // `context.addresses.insert` does not overwrite the existing record. - // This inserts the record with a score of 0 if it doesn't exist, for - // keeping track of the potential address. This becomes useful for - // consecutive `fn dial` calls. - // However, the record score cannot be updated in the future. + // For a better address tacking, see: + // https://github.com/paritytech/litep2p/issues/180 + // // TODO: context.addresses.insert(record.clone()); tracing::debug!( From e659bafefcdca45ccba42aef5b57221bfbed7ddf Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Fri, 2 Aug 2024 18:45:14 +0300 Subject: [PATCH 10/11] transport/tests: Reject secondary unknown from theoretical state Signed-off-by: Alexandru Vasile --- src/transport/manager/mod.rs | 54 ++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/src/transport/manager/mod.rs b/src/transport/manager/mod.rs index f4b391da4..fbd680d15 100644 --- a/src/transport/manager/mod.rs +++ b/src/transport/manager/mod.rs @@ -3738,6 +3738,60 @@ mod tests { #[tokio::test] async fn reject_unknown_secondary_connections_with_different_connection_ids() { + let _ = tracing_subscriber::fmt() + .with_env_filter(tracing_subscriber::EnvFilter::from_default_env()) + .try_init(); + + let (mut manager, _handle) = TransportManager::new( + Keypair::generate(), + HashSet::new(), + BandwidthSink::new(), + 8usize, + ConnectionLimitsConfig::default(), + ); + manager.register_transport(SupportedTransport::Tcp, Box::new(DummyTransport::new())); + + // Random peer ID. + let peer = PeerId::random(); + let (first_addr, first_connection_id) = setup_dial_addr(peer, 0); + let second_connection_id = ConnectionId::from(1); + let different_connection_id = ConnectionId::from(2); + + // Setup a connected peer with a dial record active. + { + let mut peers = manager.peers.write(); + + let state = PeerState::Connected { + record: AddressRecord::new(&peer, first_addr.clone(), 0, Some(first_connection_id)), + dial_record: Some(AddressRecord::new( + &peer, + first_addr.clone(), + 0, + Some(second_connection_id), + )), + }; + + let peer_context = PeerContext { + state, + secondary_connection: None, + addresses: AddressStore::from_iter(vec![first_addr.clone()].into_iter()), + }; + + peers.insert(peer, peer_context); + } + + // Establish a connection, however the connection ID is different. + let result = manager + .on_connection_established( + peer, + &Endpoint::dialer(first_addr.clone(), different_connection_id), + ) + .unwrap(); + assert_eq!(result, ConnectionEstablishedResult::Reject); + } + + #[tokio::test] + async fn guard_against_secondary_connections_with_different_connection_ids() { // This is the repro case for https://github.com/paritytech/litep2p/issues/172. let _ = tracing_subscriber::fmt() .with_env_filter(tracing_subscriber::EnvFilter::from_default_env()) From adc4657c09507f55a38dfe94118d2c98a883c806 Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Fri, 2 Aug 2024 18:50:18 +0300 Subject: [PATCH 11/11] transport/manager: Remove debug_asserts Signed-off-by: Alexandru Vasile --- src/transport/manager/mod.rs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/transport/manager/mod.rs b/src/transport/manager/mod.rs index fbd680d15..be732b1f2 100644 --- a/src/transport/manager/mod.rs +++ b/src/transport/manager/mod.rs @@ -710,8 +710,6 @@ impl TransportManager { ?connection_id, "dial failed for a connection that doesn't exist", ); - debug_assert!(false); - Error::InvalidState })?; @@ -1398,8 +1396,6 @@ impl TransportManager { ?connection_id, "open failure but dial record doesn't exist", ); - - debug_assert!(false); return Err(Error::InvalidState); };