From 42fe3088e9295994d47f4749bdc3861667bee9f8 Mon Sep 17 00:00:00 2001 From: arkpar Date: Tue, 17 Sep 2019 15:59:02 +0200 Subject: [PATCH 1/5] Explicit sync API --- core/network/src/protocol.rs | 11 ++++++ core/network/src/protocol/sync.rs | 47 ++++++++++++++++++++++++++ core/network/src/service.rs | 10 ++++++ core/network/src/test/mod.rs | 10 ++++++ core/network/src/test/sync.rs | 56 +++++++++++++++++++++++++++++++ 5 files changed, 134 insertions(+) diff --git a/core/network/src/protocol.rs b/core/network/src/protocol.rs index ea993bdce0b38..b57c5eb980188 100644 --- a/core/network/src/protocol.rs +++ b/core/network/src/protocol.rs @@ -1228,6 +1228,17 @@ impl, H: ExHashT> Protocol { self.sync.request_justification(&hash, number) } + /// Request syncing for the given block from given set of peers. + /// Uses `protocol` to queue a new block download request and tries to dispatch all pending + /// requests. + pub fn sync_fork(&mut self, peers: Vec, hash: &B::Hash, number: NumberFor) { + let requests = self.sync.sync_fork(peers, hash, number); + for (who, request) in requests { + self.update_peer_info(&who); + self.send_message(who, GenericMessage::BlockRequest(request)); + } + } + /// A batch of blocks have been processed, with or without errors. /// Call this when a batch of blocks have been processed by the importqueue, with or without /// errors. diff --git a/core/network/src/protocol/sync.rs b/core/network/src/protocol/sync.rs index 52e88034a385d..beee29feb5dca 100644 --- a/core/network/src/protocol/sync.rs +++ b/core/network/src/protocol/sync.rs @@ -441,6 +441,53 @@ impl ChainSync { }) } + /// Request syncing for the given block from given set of peers. + // This is similar to on_block_announce with unknown parent hash. + pub fn sync_fork(&mut self, peers: Vec, hash: &B::Hash, number: NumberFor) -> + Vec<(PeerId, BlockRequest)> + { + debug!(target: "sync", "Explicit sync request for block {:?} with {:?}", hash, peers); + if self.is_known(&hash) || self.is_already_downloading(&hash) { + debug!(target: "sync", "Refusing to sync known hash {:?}", hash); + return Vec::default(); + } + + let block_status = self.client.block_status(&BlockId::Number(number - One::one())) + .unwrap_or(BlockStatus::Unknown); + if block_status == BlockStatus::InChainPruned { + trace!(target: "sync", "Refusing to sync ancient block {:?}", hash); + return Vec::default(); + } + + self.is_idle = false; + let mut requests = Vec::new(); + for peer_id in peers { + let peer = if let Some(peer) = self.peers.get_mut(&peer_id) { + peer + } else { + debug!(target: "sync", "Called sync_fork with a bad peer ID"); + continue; + }; + if let PeerSyncState::AncestorSearch(_, _) = peer.state { + continue; + } + + if number > peer.best_number { + peer.best_number = number; + peer.best_hash = hash.clone(); + } + + if number <= self.best_queued_number { + if let Some(request) = self.download_unknown_stale(&peer_id, &hash) { + requests.push((peer_id, request)); + } + } else if let Some((_, request)) = self.select_new_blocks(peer_id.clone()) { + requests.push((peer_id, request)); + } + } + requests + } + /// Get an iterator over all scheduled justification requests. pub fn justification_requests(&mut self) -> impl Iterator)> + '_ { let peers = &mut self.peers; diff --git a/core/network/src/service.rs b/core/network/src/service.rs index a1cba0395e360..b9586742e105d 100644 --- a/core/network/src/service.rs +++ b/core/network/src/service.rs @@ -497,6 +497,13 @@ impl, H: ExHashT> NetworkServic Ok(()) } + /// Adds a `PeerId` and its address as reserved. + pub fn sync_fork(&self, peers: Vec, hash: B::Hash, number: NumberFor) { + let _ = self + .to_worker + .unbounded_send(ServerToWorkerMsg::SyncFork(peers, hash, number)); + } + /// Modify a peerset priority group. pub fn set_priority_group(&self, group_id: String, peers: HashSet) -> Result<(), String> { let peers = peers.into_iter().map(|p| { @@ -587,6 +594,7 @@ enum ServerToWorkerMsg> { GetValue(record::Key), PutValue(record::Key, Vec), AddKnownAddress(PeerId, Multiaddr), + SyncFork(Vec, B::Hash, NumberFor), } /// Main network worker. Must be polled in order for the network to advance. @@ -665,6 +673,8 @@ impl, H: ExHashT> Stream for Ne self.network_service.put_value(key, value), ServerToWorkerMsg::AddKnownAddress(peer_id, addr) => self.network_service.add_known_address(peer_id, addr), + ServerToWorkerMsg::SyncFork(peer_ids, hash, number) => + self.network_service.user_protocol_mut().sync_fork(peer_ids, &hash, number), } } diff --git a/core/network/src/test/mod.rs b/core/network/src/test/mod.rs index 5fd67acd1b625..e039d16bce6fe 100644 --- a/core/network/src/test/mod.rs +++ b/core/network/src/test/mod.rs @@ -226,6 +226,11 @@ pub struct Peer> { } impl> Peer { + /// Get this peer ID. + pub fn id(&self) -> PeerId { + self.network.service().local_peer_id() + } + /// Returns true if we're major syncing. pub fn is_major_syncing(&self) -> bool { self.network.service().is_major_syncing() @@ -256,6 +261,11 @@ impl> Peer { self.network.service().announce_block(hash); } + /// Request explicit fork sync. + pub fn sync_fork(&self, peers: Vec, hash: ::Hash, number: NumberFor) { + self.network.service().sync_fork(peers, hash, number); + } + /// Add blocks to the peer -- edit the block before adding pub fn generate_blocks(&mut self, count: usize, origin: BlockOrigin, edit_block: F) -> H256 where F: FnMut(BlockBuilder) -> Block diff --git a/core/network/src/test/sync.rs b/core/network/src/test/sync.rs index 6cba21c1719bd..0599cf2a76163 100644 --- a/core/network/src/test/sync.rs +++ b/core/network/src/test/sync.rs @@ -526,3 +526,59 @@ fn light_peer_imports_header_from_announce() { let known_stale_hash = net.peer(0).push_blocks_at(BlockId::Number(0), 1, true); import_with_announce(&mut net, &mut runtime, known_stale_hash); } + +#[test] +fn can_sync_explicit_forks() { + let _ = ::env_logger::try_init(); + let mut runtime = current_thread::Runtime::new().unwrap(); + let mut net = TestNet::new(2); + net.peer(0).push_blocks(30, false); + net.peer(1).push_blocks(30, false); + + // small fork + reorg on peer 1. + net.peer(0).push_blocks_at(BlockId::Number(30), 2, true); + let small_hash = net.peer(0).client().info().chain.best_hash; + let small_number = net.peer(0).client().info().chain.best_number; + net.peer(0).push_blocks_at(BlockId::Number(30), 10, false); + assert_eq!(net.peer(0).client().info().chain.best_number, 40); + + // peer 1 only ever had the long fork. + net.peer(1).push_blocks(10, false); + assert_eq!(net.peer(1).client().info().chain.best_number, 40); + + assert!(net.peer(0).client().header(&BlockId::Hash(small_hash)).unwrap().is_some()); + assert!(net.peer(1).client().header(&BlockId::Hash(small_hash)).unwrap().is_none()); + + // poll until the two nodes connect, otherwise announcing the block will not work + runtime.block_on(futures::future::poll_fn::<(), (), _>(|| -> Result<_, ()> { + net.poll(); + if net.peer(0).num_peers() == 0 || net.peer(1).num_peers() == 0 { + Ok(Async::NotReady) + } else { + Ok(Async::Ready(())) + } + })).unwrap(); + + // synchronization: 0 synced to longer chain and 1 didn't sync to small chain. + + assert_eq!(net.peer(0).client().info().chain.best_number, 40); + + assert!(net.peer(0).client().header(&BlockId::Hash(small_hash)).unwrap().is_some()); + assert!(!net.peer(1).client().header(&BlockId::Hash(small_hash)).unwrap().is_some()); + + // request explicit sync + let first_peer_id = net.peer(0).id(); + net.peer(1).sync_fork(vec![first_peer_id], small_hash, small_number); + + // peer 1 downloads the block. + runtime.block_on(futures::future::poll_fn::<(), (), _>(|| -> Result<_, ()> { + net.poll(); + + assert!(net.peer(0).client().header(&BlockId::Hash(small_hash)).unwrap().is_some()); + if net.peer(1).client().header(&BlockId::Hash(small_hash)).unwrap().is_none() { + return Ok(Async::NotReady) + } + Ok(Async::Ready(())) + })).unwrap(); +} + From 97e18d950877a66238e7a5c0cc9d695a85ac632f Mon Sep 17 00:00:00 2001 From: arkpar Date: Sat, 21 Sep 2019 09:57:31 +0200 Subject: [PATCH 2/5] Keep sync requests --- core/network/src/protocol.rs | 8 +-- core/network/src/protocol/sync.rs | 99 ++++++++++++++++++++++--------- 2 files changed, 72 insertions(+), 35 deletions(-) diff --git a/core/network/src/protocol.rs b/core/network/src/protocol.rs index b57c5eb980188..ee2ce485d12bb 100644 --- a/core/network/src/protocol.rs +++ b/core/network/src/protocol.rs @@ -728,7 +728,7 @@ impl, H: ExHashT> Protocol { match request.direction { message::Direction::Ascending => id = BlockId::Number(number + One::one()), message::Direction::Descending => { - if number.is_zero() { + if number.is_one() { break; } id = BlockId::Hash(parent_hash) @@ -1232,11 +1232,7 @@ impl, H: ExHashT> Protocol { /// Uses `protocol` to queue a new block download request and tries to dispatch all pending /// requests. pub fn sync_fork(&mut self, peers: Vec, hash: &B::Hash, number: NumberFor) { - let requests = self.sync.sync_fork(peers, hash, number); - for (who, request) in requests { - self.update_peer_info(&who); - self.send_message(who, GenericMessage::BlockRequest(request)); - } + self.sync.sync_fork(peers, hash, number) } /// A batch of blocks have been processed, with or without errors. diff --git a/core/network/src/protocol/sync.rs b/core/network/src/protocol/sync.rs index beee29feb5dca..44c79a2429be0 100644 --- a/core/network/src/protocol/sync.rs +++ b/core/network/src/protocol/sync.rs @@ -119,7 +119,10 @@ pub struct ChainSync { queue_blocks: HashSet, /// The best block number that we are currently importing. best_importing_number: NumberFor, + /// Finality proof handler. request_builder: Option>, + /// Explicit sync requests. + sync_requests: HashMap>, /// A flag that caches idle state with no pending requests. is_idle: bool, } @@ -151,6 +154,11 @@ pub struct PeerInfo { pub best_number: NumberFor } +struct SyncRequest { + number: NumberFor, + peers: HashSet, +} + /// The state of syncing between a Peer and ourselves. /// /// Generally two categories, "busy" or `Available`. If busy, the enum @@ -292,6 +300,7 @@ impl ChainSync { queue_blocks: Default::default(), best_importing_number: Zero::zero(), request_builder, + sync_requests: Default::default(), is_idle: false, } } @@ -443,49 +452,41 @@ impl ChainSync { /// Request syncing for the given block from given set of peers. // This is similar to on_block_announce with unknown parent hash. - pub fn sync_fork(&mut self, peers: Vec, hash: &B::Hash, number: NumberFor) -> - Vec<(PeerId, BlockRequest)> - { + pub fn sync_fork(&mut self, peers: Vec, hash: &B::Hash, number: NumberFor) { debug!(target: "sync", "Explicit sync request for block {:?} with {:?}", hash, peers); - if self.is_known(&hash) || self.is_already_downloading(&hash) { + if self.is_known(&hash) { debug!(target: "sync", "Refusing to sync known hash {:?}", hash); - return Vec::default(); + return; } let block_status = self.client.block_status(&BlockId::Number(number - One::one())) .unwrap_or(BlockStatus::Unknown); if block_status == BlockStatus::InChainPruned { trace!(target: "sync", "Refusing to sync ancient block {:?}", hash); - return Vec::default(); + return; } self.is_idle = false; - let mut requests = Vec::new(); - for peer_id in peers { - let peer = if let Some(peer) = self.peers.get_mut(&peer_id) { - peer - } else { - debug!(target: "sync", "Called sync_fork with a bad peer ID"); - continue; - }; - if let PeerSyncState::AncestorSearch(_, _) = peer.state { - continue; - } - - if number > peer.best_number { - peer.best_number = number; - peer.best_hash = hash.clone(); - } + for peer_id in &peers { + if let Some(peer) = self.peers.get_mut(peer_id) { + if let PeerSyncState::AncestorSearch(_, _) = peer.state { + continue; + } - if number <= self.best_queued_number { - if let Some(request) = self.download_unknown_stale(&peer_id, &hash) { - requests.push((peer_id, request)); + if number > peer.best_number { + peer.best_number = number; + peer.best_hash = hash.clone(); } - } else if let Some((_, request)) = self.select_new_blocks(peer_id.clone()) { - requests.push((peer_id, request)); } } - requests + + self.sync_requests + .entry(hash.clone()) + .or_insert_with(|| SyncRequest { + number, + peers: Default::default(), + }) + .peers.extend(peers); } /// Get an iterator over all scheduled justification requests. @@ -547,13 +548,21 @@ impl ChainSync { } let blocks = &mut self.blocks; let attrs = &self.required_block_attributes; + let sync_requests = &self.sync_requests; let mut have_requests = false; + let last_finalized = self.client.info().chain.finalized_hash; + let best_queued = self.best_queued_number; let iter = self.peers.iter_mut().filter_map(move |(id, peer)| { if !peer.state.is_available() { trace!(target: "sync", "Peer {} is busy", id); return None } - if let Some((range, req)) = peer_block_request(id, peer, blocks, attrs) { + if let Some((hash, req)) = explicit_sync_request(id, sync_requests, best_queued, &last_finalized, attrs) { + trace!(target: "sync", "Downloading explicitly requested block {:?} from {}", hash, id); + peer.state = PeerSyncState::DownloadingStale(hash); + have_requests = true; + Some((id.clone(), req)) + } else if let Some((range, req)) = peer_block_request(id, peer, blocks, attrs) { peer.state = PeerSyncState::DownloadingNew(range.start); trace!(target: "sync", "New block request for {}", id); have_requests = true; @@ -901,6 +910,9 @@ impl ChainSync { self.best_queued_number = number; self.best_queued_hash = *hash; } + if let Some(_) = self.sync_requests.remove(&hash) { + trace!(target: "sync", "Completed explicit sync request {:?}", hash); + } // Update common blocks for (n, peer) in self.peers.iter_mut() { if let PeerSyncState::AncestorSearch(_, _) = peer.state { @@ -1258,3 +1270,32 @@ fn peer_block_request( None } } + +/// Get pending explicit sync request for a peer. +fn explicit_sync_request( + id: &PeerId, + requests: &HashMap>, + best_num: NumberFor, + finalized: &B::Hash, + attributs: &message::BlockAttributes, +) -> Option<(B::Hash, BlockRequest)> +{ + for (hash, r) in requests { + if !r.peers.contains(id) { + continue + } + if r.number <= best_num { + trace!(target: "sync", "Downloading requested fork {:?} from {}", hash, id); + return Some((hash.clone(), message::generic::BlockRequest { + id: 0, + fields: attributs.clone(), + from: message::FromBlock::Hash(hash.clone()), + to: Some(finalized.clone()), + direction: message::Direction::Descending, + max: None, + })) + } + } + None +} + From 38151301b992dc937aec1ac563edb455d850dbaf Mon Sep 17 00:00:00 2001 From: arkpar Date: Sun, 22 Sep 2019 10:34:31 +0200 Subject: [PATCH 3/5] Don't request the finalized block we already have --- core/network/src/protocol.rs | 2 +- core/network/src/protocol/sync.rs | 14 +++++++------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/core/network/src/protocol.rs b/core/network/src/protocol.rs index ee2ce485d12bb..cd3b69e28c09d 100644 --- a/core/network/src/protocol.rs +++ b/core/network/src/protocol.rs @@ -728,7 +728,7 @@ impl, H: ExHashT> Protocol { match request.direction { message::Direction::Ascending => id = BlockId::Number(number + One::one()), message::Direction::Descending => { - if number.is_one() { + if number.is_zero() { break; } id = BlockId::Hash(parent_hash) diff --git a/core/network/src/protocol/sync.rs b/core/network/src/protocol/sync.rs index 44c79a2429be0..6b7281f3b9f1f 100644 --- a/core/network/src/protocol/sync.rs +++ b/core/network/src/protocol/sync.rs @@ -550,14 +550,14 @@ impl ChainSync { let attrs = &self.required_block_attributes; let sync_requests = &self.sync_requests; let mut have_requests = false; - let last_finalized = self.client.info().chain.finalized_hash; + let last_finalized = self.client.info().chain.finalized_number; let best_queued = self.best_queued_number; let iter = self.peers.iter_mut().filter_map(move |(id, peer)| { if !peer.state.is_available() { trace!(target: "sync", "Peer {} is busy", id); return None } - if let Some((hash, req)) = explicit_sync_request(id, sync_requests, best_queued, &last_finalized, attrs) { + if let Some((hash, req)) = explicit_sync_request(id, sync_requests, best_queued, last_finalized, attrs) { trace!(target: "sync", "Downloading explicitly requested block {:?} from {}", hash, id); peer.state = PeerSyncState::DownloadingStale(hash); have_requests = true; @@ -1276,8 +1276,8 @@ fn explicit_sync_request( id: &PeerId, requests: &HashMap>, best_num: NumberFor, - finalized: &B::Hash, - attributs: &message::BlockAttributes, + finalized: NumberFor, + attributes: &message::BlockAttributes, ) -> Option<(B::Hash, BlockRequest)> { for (hash, r) in requests { @@ -1288,11 +1288,11 @@ fn explicit_sync_request( trace!(target: "sync", "Downloading requested fork {:?} from {}", hash, id); return Some((hash.clone(), message::generic::BlockRequest { id: 0, - fields: attributs.clone(), + fields: attributes.clone(), from: message::FromBlock::Hash(hash.clone()), - to: Some(finalized.clone()), + to: None, direction: message::Direction::Descending, - max: None, + max: Some((r.number - finalized).saturated_into::()), // up to the last finalized block })) } } From d687a545a80994724a220ee447183210e0e1fe52 Mon Sep 17 00:00:00 2001 From: arkpar Date: Tue, 24 Sep 2019 16:30:30 +0200 Subject: [PATCH 4/5] Dropping requests & docs --- core/network/src/protocol/sync.rs | 6 ++++++ core/network/src/service.rs | 5 +++++ 2 files changed, 11 insertions(+) diff --git a/core/network/src/protocol/sync.rs b/core/network/src/protocol/sync.rs index c17c11ee99438..f5c4c727eb052 100644 --- a/core/network/src/protocol/sync.rs +++ b/core/network/src/protocol/sync.rs @@ -461,6 +461,12 @@ impl ChainSync { /// Request syncing for the given block from given set of peers. // This is similar to on_block_announce with unknown parent hash. pub fn sync_fork(&mut self, peers: Vec, hash: &B::Hash, number: NumberFor) { + if peers.is_empty() { + if let Some(_) = self.sync_requests.remove(hash) { + debug!(target: "sync", "Cleared sync request for block {:?} with {:?}", hash, peers); + } + return; + } debug!(target: "sync", "Explicit sync request for block {:?} with {:?}", hash, peers); if self.is_known(&hash) { debug!(target: "sync", "Refusing to sync known hash {:?}", hash); diff --git a/core/network/src/service.rs b/core/network/src/service.rs index 76e2f738e2011..ee4f60b6ede00 100644 --- a/core/network/src/service.rs +++ b/core/network/src/service.rs @@ -497,6 +497,11 @@ impl, H: ExHashT> NetworkServic } /// Adds a `PeerId` and its address as reserved. + /// Note that this function should not be used for recent blocks. + /// Sync should be able to download all the recent forks normally. + /// `sync_fork` should only be used if external code detects that there's + /// a stale fork missing. + /// Passing empty `peers` set effectively removes the sync request. pub fn sync_fork(&self, peers: Vec, hash: B::Hash, number: NumberFor) { let _ = self .to_worker From 19673f7e220536e2abfe6264d9a30ab7e02a6ef4 Mon Sep 17 00:00:00 2001 From: arkpar Date: Fri, 27 Sep 2019 16:50:47 +0200 Subject: [PATCH 5/5] Renamed a function --- core/network/src/protocol.rs | 4 ++-- core/network/src/protocol/sync.rs | 4 ++-- core/network/src/service.rs | 8 ++++---- core/network/src/test/mod.rs | 4 ++-- core/network/src/test/sync.rs | 2 +- 5 files changed, 11 insertions(+), 11 deletions(-) diff --git a/core/network/src/protocol.rs b/core/network/src/protocol.rs index 889aeb6d60092..ef581a6e43c3d 100644 --- a/core/network/src/protocol.rs +++ b/core/network/src/protocol.rs @@ -1239,8 +1239,8 @@ impl, H: ExHashT> Protocol { /// Request syncing for the given block from given set of peers. /// Uses `protocol` to queue a new block download request and tries to dispatch all pending /// requests. - pub fn sync_fork(&mut self, peers: Vec, hash: &B::Hash, number: NumberFor) { - self.sync.sync_fork(peers, hash, number) + pub fn set_sync_fork_request(&mut self, peers: Vec, hash: &B::Hash, number: NumberFor) { + self.sync.set_sync_fork_request(peers, hash, number) } /// A batch of blocks have been processed, with or without errors. diff --git a/core/network/src/protocol/sync.rs b/core/network/src/protocol/sync.rs index f5c4c727eb052..2dbab8aebd50d 100644 --- a/core/network/src/protocol/sync.rs +++ b/core/network/src/protocol/sync.rs @@ -459,8 +459,8 @@ impl ChainSync { } /// Request syncing for the given block from given set of peers. - // This is similar to on_block_announce with unknown parent hash. - pub fn sync_fork(&mut self, peers: Vec, hash: &B::Hash, number: NumberFor) { + // The implementation is similar to on_block_announce with unknown parent hash. + pub fn set_sync_fork_request(&mut self, peers: Vec, hash: &B::Hash, number: NumberFor) { if peers.is_empty() { if let Some(_) = self.sync_requests.remove(hash) { debug!(target: "sync", "Cleared sync request for block {:?} with {:?}", hash, peers); diff --git a/core/network/src/service.rs b/core/network/src/service.rs index ee4f60b6ede00..2cf949116f012 100644 --- a/core/network/src/service.rs +++ b/core/network/src/service.rs @@ -496,13 +496,13 @@ impl, H: ExHashT> NetworkServic Ok(()) } - /// Adds a `PeerId` and its address as reserved. + /// Configure an explicit fork sync request. /// Note that this function should not be used for recent blocks. /// Sync should be able to download all the recent forks normally. - /// `sync_fork` should only be used if external code detects that there's + /// `set_sync_fork_request` should only be used if external code detects that there's /// a stale fork missing. /// Passing empty `peers` set effectively removes the sync request. - pub fn sync_fork(&self, peers: Vec, hash: B::Hash, number: NumberFor) { + pub fn set_sync_fork_request(&self, peers: Vec, hash: B::Hash, number: NumberFor) { let _ = self .to_worker .unbounded_send(ServerToWorkerMsg::SyncFork(peers, hash, number)); @@ -678,7 +678,7 @@ impl, H: ExHashT> Stream for Ne ServerToWorkerMsg::AddKnownAddress(peer_id, addr) => self.network_service.add_known_address(peer_id, addr), ServerToWorkerMsg::SyncFork(peer_ids, hash, number) => - self.network_service.user_protocol_mut().sync_fork(peer_ids, &hash, number), + self.network_service.user_protocol_mut().set_sync_fork_request(peer_ids, &hash, number), } } diff --git a/core/network/src/test/mod.rs b/core/network/src/test/mod.rs index f1776100eac3a..302ef78d7d43d 100644 --- a/core/network/src/test/mod.rs +++ b/core/network/src/test/mod.rs @@ -265,8 +265,8 @@ impl> Peer { } /// Request explicit fork sync. - pub fn sync_fork(&self, peers: Vec, hash: ::Hash, number: NumberFor) { - self.network.service().sync_fork(peers, hash, number); + pub fn set_sync_fork_request(&self, peers: Vec, hash: ::Hash, number: NumberFor) { + self.network.service().set_sync_fork_request(peers, hash, number); } /// Add blocks to the peer -- edit the block before adding diff --git a/core/network/src/test/sync.rs b/core/network/src/test/sync.rs index 73107eea18f71..3d8e57cad038b 100644 --- a/core/network/src/test/sync.rs +++ b/core/network/src/test/sync.rs @@ -568,7 +568,7 @@ fn can_sync_explicit_forks() { // request explicit sync let first_peer_id = net.peer(0).id(); - net.peer(1).sync_fork(vec![first_peer_id], small_hash, small_number); + net.peer(1).set_sync_fork_request(vec![first_peer_id], small_hash, small_number); // peer 1 downloads the block. runtime.block_on(futures::future::poll_fn::<(), (), _>(|| -> Result<_, ()> {