= BTreeMap<
::Number, HashMap<
::Hash, QueuedHeader
>>; type SyncedChildren
= BTreeMap<
::Number, HashMap<
::Hash, HashSet =
BTreeMap< ::Number, HashMap< ::Hash, HeaderStatus>>;
/// We're trying to fetch completion data for single header at this interval.
const RETRY_FETCH_COMPLETION_INTERVAL: Duration = Duration::from_secs(20);
/// Headers queue.
#[derive(Debug)]
pub struct QueuedHeaders ,
/// Headers that are received from source node, and we (native sync code) have
/// checked that Substrate runtime doesn't know their parents. So we need to submit parents
/// first.
orphan: HeadersQueue ,
/// Headers that are ready to be submitted to target node, but we need to check
/// whether submission requires extra data to be provided.
maybe_extra: HeadersQueue ,
/// Headers that are ready to be submitted to target node, but we need to retrieve
/// extra data first.
extra: HeadersQueue ,
/// Headers that are ready to be submitted to target node.
ready: HeadersQueue ,
/// Headers that are ready to be submitted to target node, but their ancestor is incomplete.
/// Thus we're waiting for these ancestors to be completed first.
/// Note that the incomplete header itself is synced and it isn't in this queue.
incomplete: HeadersQueue ,
/// Headers that are (we believe) currently submitted to target node by our,
/// not-yet mined transactions.
submitted: HeadersQueue ,
/// Synced headers childrens. We need it to support case when header is synced, but some of
/// its parents are incomplete.
synced_children: SyncedChildren ,
/// Pointers to all headers that we ever seen and we believe we can touch in the future.
known_headers: KnownHeaders ,
/// Headers that are waiting for completion data from source node. Mapped (and auto-sorted
/// by) to the last fetch time.
incomplete_headers: LinkedHashMap {
fn default() -> Self {
QueuedHeaders {
maybe_orphan: HeadersQueue::new(),
orphan: HeadersQueue::new(),
maybe_extra: HeadersQueue::new(),
extra: HeadersQueue::new(),
ready: HeadersQueue::new(),
incomplete: HeadersQueue::new(),
submitted: HeadersQueue::new(),
synced_children: SyncedChildren:: ::new(),
known_headers: KnownHeaders:: ::new(),
incomplete_headers: LinkedHashMap::new(),
completion_data: LinkedHashMap::new(),
best_synced_number: Zero::zero(),
prune_border: Zero::zero(),
}
}
}
impl {
/// Returns prune border.
#[cfg(test)]
pub fn prune_border(&self) -> P::Number {
self.prune_border
}
/// Returns number of headers that are currently in given queue.
pub fn headers_in_status(&self, status: HeaderStatus) -> usize {
match status {
HeaderStatus::Unknown | HeaderStatus::Synced => 0,
HeaderStatus::MaybeOrphan => self
.maybe_orphan
.values()
.fold(0, |total, headers| total + headers.len()),
HeaderStatus::Orphan => self.orphan.values().fold(0, |total, headers| total + headers.len()),
HeaderStatus::MaybeExtra => self
.maybe_extra
.values()
.fold(0, |total, headers| total + headers.len()),
HeaderStatus::Extra => self.extra.values().fold(0, |total, headers| total + headers.len()),
HeaderStatus::Ready => self.ready.values().fold(0, |total, headers| total + headers.len()),
HeaderStatus::Incomplete => self.incomplete.values().fold(0, |total, headers| total + headers.len()),
HeaderStatus::Submitted => self.submitted.values().fold(0, |total, headers| total + headers.len()),
}
}
/// Returns number of headers that are currently in the queue.
pub fn total_headers(&self) -> usize {
self.maybe_orphan
.values()
.fold(0, |total, headers| total + headers.len())
+ self.orphan.values().fold(0, |total, headers| total + headers.len())
+ self
.maybe_extra
.values()
.fold(0, |total, headers| total + headers.len())
+ self.extra.values().fold(0, |total, headers| total + headers.len())
+ self.ready.values().fold(0, |total, headers| total + headers.len())
+ self.incomplete.values().fold(0, |total, headers| total + headers.len())
}
/// Returns number of best block in the queue.
pub fn best_queued_number(&self) -> P::Number {
std::cmp::max(
self.maybe_orphan.keys().next_back().cloned().unwrap_or_else(Zero::zero),
std::cmp::max(
self.orphan.keys().next_back().cloned().unwrap_or_else(Zero::zero),
std::cmp::max(
self.maybe_extra.keys().next_back().cloned().unwrap_or_else(Zero::zero),
std::cmp::max(
self.extra.keys().next_back().cloned().unwrap_or_else(Zero::zero),
std::cmp::max(
self.ready.keys().next_back().cloned().unwrap_or_else(Zero::zero),
std::cmp::max(
self.incomplete.keys().next_back().cloned().unwrap_or_else(Zero::zero),
self.submitted.keys().next_back().cloned().unwrap_or_else(Zero::zero),
),
),
),
),
),
)
}
/// Returns number of best synced block we have ever seen. It is either less
/// than `best_queued_number()`, or points to last synced block if queue is empty.
pub fn best_synced_number(&self) -> P::Number {
self.best_synced_number
}
/// Returns synchronization status of the header.
pub fn status(&self, id: &HeaderIdOf ) -> HeaderStatus {
self.known_headers
.get(&id.0)
.and_then(|x| x.get(&id.1))
.cloned()
.unwrap_or(HeaderStatus::Unknown)
}
/// Get oldest header from given queue.
pub fn header(&self, status: HeaderStatus) -> Option<&QueuedHeader > {
match status {
HeaderStatus::Unknown | HeaderStatus::Synced => None,
HeaderStatus::MaybeOrphan => oldest_header(&self.maybe_orphan),
HeaderStatus::Orphan => oldest_header(&self.orphan),
HeaderStatus::MaybeExtra => oldest_header(&self.maybe_extra),
HeaderStatus::Extra => oldest_header(&self.extra),
HeaderStatus::Ready => oldest_header(&self.ready),
HeaderStatus::Incomplete => oldest_header(&self.incomplete),
HeaderStatus::Submitted => oldest_header(&self.submitted),
}
}
/// Get oldest headers from given queue until functor will return false.
pub fn headers(
&self,
status: HeaderStatus,
f: impl FnMut(&QueuedHeader ) -> bool,
) -> Option ) {
self.header_synced(id)
}
/// Receive target node response for MaybeOrphan request.
pub fn maybe_orphan_response(&mut self, id: &HeaderIdOf , response: bool) {
if !response {
move_header_descendants:: (
&mut [&mut self.maybe_orphan],
&mut self.orphan,
&mut self.known_headers,
HeaderStatus::Orphan,
&id,
);
return;
}
move_header_descendants:: (
&mut [&mut self.maybe_orphan, &mut self.orphan],
&mut self.maybe_extra,
&mut self.known_headers,
HeaderStatus::MaybeExtra,
&id,
);
}
/// Receive target node response for MaybeExtra request.
pub fn maybe_extra_response(&mut self, id: &HeaderIdOf , response: bool) {
let (destination_status, destination_queue) = if response {
(HeaderStatus::Extra, &mut self.extra)
} else if self.is_parent_incomplete(id) {
(HeaderStatus::Incomplete, &mut self.incomplete)
} else {
(HeaderStatus::Ready, &mut self.ready)
};
move_header(
&mut self.maybe_extra,
destination_queue,
&mut self.known_headers,
destination_status,
&id,
|header| header,
);
}
/// Receive extra from source node.
pub fn extra_response(&mut self, id: &HeaderIdOf , extra: P::Extra) {
let (destination_status, destination_queue) = if self.is_parent_incomplete(id) {
(HeaderStatus::Incomplete, &mut self.incomplete)
} else {
(HeaderStatus::Ready, &mut self.ready)
};
// move header itself from extra to ready queue
move_header(
&mut self.extra,
destination_queue,
&mut self.known_headers,
destination_status,
id,
|header| header.set_extra(extra),
);
}
/// Receive completion response from source node.
pub fn completion_response(&mut self, id: &HeaderIdOf , completion: Option ) {
if self.completion_data.remove(id).is_some() {
log::debug!(
target: "bridge",
"Sent completion data to {} for header: {:?}",
P::TARGET_NAME,
id,
);
// transaction can be dropped by target chain nodes => it would never be mined
//
// in current implementation the sync loop would wait for some time && if best
// **source** header won't change on **target** node, then the sync will be restarted
// => we'll resubmit the same completion data again (the same is true for submitted
// headers)
//
// the other option would be to track emitted transactions at least on target node,
// but it won't give us 100% guarantee anyway
//
// => we're just dropping completion data just after it has been submitted
}
}
/// Marks given headers incomplete.
pub fn add_incomplete_headers(&mut self, make_header_incomplete: bool, new_incomplete_headers: Vec (&self.synced_children, &new_incomplete_header);
let move_origins = move_origins.into_iter().chain(std::iter::once(new_incomplete_header));
for move_origin in move_origins {
move_header_descendants:: (
&mut [&mut self.ready, &mut self.submitted],
&mut self.incomplete,
&mut self.known_headers,
HeaderStatus::Incomplete,
&move_origin,
);
}
if make_header_incomplete {
log::debug!(
target: "bridge",
"Scheduling completion data retrieval for header: {:?}",
new_incomplete_header,
);
self.incomplete_headers.insert(new_incomplete_header, None);
}
}
}
/// When incomplete headers ids are receved from target node.
pub fn incomplete_headers_response(&mut self, ids: HashSet (&self.synced_children, &just_completed_header);
let move_origins = move_origins.into_iter().chain(std::iter::once(just_completed_header));
for move_origin in move_origins {
move_header_descendants:: (
&mut [&mut self.incomplete],
&mut self.ready,
&mut self.known_headers,
HeaderStatus::Ready,
&move_origin,
);
}
log::debug!(
target: "bridge",
"Completion data is no longer required for header: {:?}",
just_completed_header,
);
self.incomplete_headers.remove(&just_completed_header);
self.completion_data.remove(&just_completed_header);
}
}
/// Returns true if given header requires completion data.
pub fn requires_completion_data(&self, id: &HeaderIdOf ) -> bool {
self.incomplete_headers.contains_key(id)
}
/// Returns id of the header for which we want to fetch completion data.
pub fn incomplete_header(&mut self) -> Option , &P::Completion)> {
queued_incomplete_header(&mut self.completion_data, |_| true)
}
/// Prune and never accept headers before this block.
pub fn prune(&mut self, prune_border: P::Number) {
if prune_border <= self.prune_border {
return;
}
prune_queue(&mut self.maybe_orphan, prune_border);
prune_queue(&mut self.orphan, prune_border);
prune_queue(&mut self.maybe_extra, prune_border);
prune_queue(&mut self.extra, prune_border);
prune_queue(&mut self.ready, prune_border);
prune_queue(&mut self.submitted, prune_border);
prune_queue(&mut self.incomplete, prune_border);
self.synced_children = self.synced_children.split_off(&prune_border);
prune_known_headers:: (&mut self.known_headers, prune_border);
self.prune_border = prune_border;
}
/// Forgets all ever known headers.
pub fn clear(&mut self) {
self.maybe_orphan.clear();
self.orphan.clear();
self.maybe_extra.clear();
self.extra.clear();
self.ready.clear();
self.incomplete.clear();
self.submitted.clear();
self.synced_children.clear();
self.known_headers.clear();
self.best_synced_number = Zero::zero();
self.prune_border = Zero::zero();
}
/// Returns true if parent of this header is either incomplete or waiting for
/// its own incomplete ancestor to be completed.
fn is_parent_incomplete(&self, id: &HeaderIdOf ) -> bool {
let status = self.status(id);
let header = match status {
HeaderStatus::MaybeOrphan => header(&self.maybe_orphan, id),
HeaderStatus::Orphan => header(&self.orphan, id),
HeaderStatus::MaybeExtra => header(&self.maybe_extra, id),
HeaderStatus::Extra => header(&self.extra, id),
HeaderStatus::Ready => header(&self.ready, id),
HeaderStatus::Incomplete => header(&self.incomplete, id),
HeaderStatus::Submitted => header(&self.submitted, id),
HeaderStatus::Unknown => return false,
HeaderStatus::Synced => return false,
};
match header {
Some(header) => {
let parent_id = header.header().parent_id();
self.incomplete_headers.contains_key(&parent_id)
|| self.completion_data.contains_key(&parent_id)
|| self.status(&parent_id) == HeaderStatus::Incomplete
}
None => false,
}
}
/// When we receive new Synced header from target node.
fn header_synced(&mut self, id: &HeaderIdOf ) {
// update best synced block number
self.best_synced_number = std::cmp::max(self.best_synced_number, id.0);
// all ancestors of this header are now synced => let's remove them from
// queues
let mut current = *id;
let mut id_processed = false;
let mut previous_current = None;
loop {
let header = match self.status(¤t) {
HeaderStatus::Unknown => break,
HeaderStatus::MaybeOrphan => remove_header(&mut self.maybe_orphan, ¤t),
HeaderStatus::Orphan => remove_header(&mut self.orphan, ¤t),
HeaderStatus::MaybeExtra => remove_header(&mut self.maybe_extra, ¤t),
HeaderStatus::Extra => remove_header(&mut self.extra, ¤t),
HeaderStatus::Ready => remove_header(&mut self.ready, ¤t),
HeaderStatus::Incomplete => remove_header(&mut self.incomplete, ¤t),
HeaderStatus::Submitted => remove_header(&mut self.submitted, ¤t),
HeaderStatus::Synced => break,
}
.expect("header has a given status; given queue has the header; qed");
// remember ids of all the children of the current header
let synced_children_entry = self
.synced_children
.entry(current.0)
.or_default()
.entry(current.1)
.or_default();
let all_queues = [
&self.maybe_orphan,
&self.orphan,
&self.maybe_extra,
&self.extra,
&self.ready,
&self.incomplete,
&self.submitted,
];
for queue in &all_queues {
let children_from_queue = queue
.get(&(current.0 + One::one()))
.map(|potential_children| {
potential_children
.values()
.filter(|potential_child| potential_child.header().parent_id() == current)
.map(|child| child.id())
.collect:: (&mut self.known_headers, ¤t, HeaderStatus::Synced);
previous_current = Some(current);
current = header.parent_id();
id_processed = true;
}
// remember that the header itself is synced
// (condition is here to avoid duplicate log messages)
if !id_processed {
set_header_status:: (&mut self.known_headers, &id, HeaderStatus::Synced);
}
// now let's move all descendants from maybe_orphan && orphan queues to
// maybe_extra queue
move_header_descendants:: (
&mut [&mut self.maybe_orphan, &mut self.orphan],
&mut self.maybe_extra,
&mut self.known_headers,
HeaderStatus::MaybeExtra,
id,
);
}
}
/// Insert header to the queue.
fn insert_header , id: HeaderIdOf , header: QueuedHeader ) {
queue.entry(id.0).or_default().insert(id.1, header);
}
/// Remove header from the queue.
fn remove_header , id: &HeaderIdOf ) -> Option , id: &HeaderIdOf ) -> Option<&'a QueuedHeader > {
queue.get(&id.0).and_then(|by_hash| by_hash.get(&id.1))
}
/// Move header from source to destination queue.
///
/// Returns ID of parent header, if header has been moved, or None otherwise.
fn move_header ,
destination_queue: &mut HeadersQueue ,
known_headers: &mut KnownHeaders ,
destination_status: HeaderStatus,
id: &HeaderIdOf ,
prepare: impl FnOnce(QueuedHeader ) -> QueuedHeader ,
) -> Option (known_headers, id, destination_status);
Some(parent_id)
}
/// Move all descendant headers from the source to destination queue.
fn move_header_descendants ],
destination_queue: &mut HeadersQueue ,
known_headers: &mut KnownHeaders ,
destination_status: HeaderStatus,
id: &HeaderIdOf ,
) {
let mut current_number = id.0 + One::one();
let mut current_parents = HashSet::new();
current_parents.insert(id.1);
while !current_parents.is_empty() {
let mut next_parents = HashSet::new();
for source_queue in source_queues.iter_mut() {
let mut source_entry = match source_queue.entry(current_number) {
BTreeMapEntry::Occupied(source_entry) => source_entry,
BTreeMapEntry::Vacant(_) => continue,
};
let mut headers_to_move = Vec::new();
let children_at_number = source_entry.get().keys().cloned().collect:: (known_headers, &header_to_move_id, destination_status);
}
}
if source_entry.get().is_empty() {
source_entry.remove();
}
next_parents.extend(headers_to_move.iter().map(|(id, _)| id.1));
destination_queue
.entry(current_number)
.or_default()
.extend(headers_to_move.into_iter().map(|(id, h)| (id.1, h)))
}
current_number = current_number + One::one();
std::mem::swap(&mut current_parents, &mut next_parents);
}
}
/// Selects (recursive) all synced children of given header.
fn select_synced_children ,
id: &HeaderIdOf ,
) -> Vec ) -> Option<&QueuedHeader > {
queue.values().flat_map(|h| h.values()).next()
}
/// Return oldest headers from the queue until functor will return false.
fn oldest_headers ,
mut f: impl FnMut(&QueuedHeader ) -> bool,
) -> Option , prune_border: P::Number) {
*queue = queue.split_off(&prune_border);
}
/// Forget all known headers with number less than given.
fn prune_known_headers , prune_border: P::Number) {
let new_known_headers = known_headers.split_off(&prune_border);
for (pruned_number, pruned_headers) in &*known_headers {
for pruned_hash in pruned_headers.keys() {
log::debug!(target: "bridge", "Pruning header {:?}.", HeaderId(*pruned_number, *pruned_hash));
}
}
*known_headers = new_known_headers;
}
/// Change header status.
fn set_header_status ,
id: &HeaderIdOf ,
status: HeaderStatus,
) {
log::debug!(
target: "bridge",
"{} header {:?} is now {:?}",
P::SOURCE_NAME,
id,
status,
);
*known_headers.entry(id.0).or_default().entry(id.1).or_insert(status) = status;
}
/// Returns queued incomplete header with maximal elapsed time since last update.
fn queued_incomplete_header