gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix roots overrunning broadcast (#6884)

Browse Source 
* Add trusted pathway for insert_shreds to avoid checks
This commit is contained in:
carllin
2019-11-14 00:32:07 -08:00
committed by GitHub
parent 7b05b3dbb3
commit 43e2301e2c
14 changed files with 187 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/src/archiver.rs
View File

@ -927,7 +927,7 @@ impl Archiver {
.into_iter()
.filter_map(|p| Shred::new_from_serialized_shred(p.data.to_vec()).ok())
.collect();
blocktree.insert_shreds(shreds, None)?;
blocktree.insert_shreds(shreds, None, false)?;
}
// check if all the slots in the segment are complete
if Self::segment_complete(start_slot, slots_per_segment, blocktree) {

2
core/src/broadcast_stage/broadcast_fake_blobs_run.rs
View File

@ -76,7 +76,7 @@ impl BroadcastRun for BroadcastFakeBlobsRun {
self.last_blockhash = Hash::default();
}
blocktree.insert_shreds(data_shreds.clone(), None)?;
blocktree.insert_shreds(data_shreds.clone(), None, true)?;
// 3) Start broadcast step
let peers = cluster_info.read().unwrap().tvu_peers();

2
core/src/broadcast_stage/fail_entry_verification_broadcast_run.rs
View File

@ -59,7 +59,7 @@ impl BroadcastRun for FailEntryVerificationBroadcastRun {
.collect::<Vec<_>>();
let all_seeds: Vec<[u8; 32]> = all_shreds.iter().map(|s| s.seed()).collect();
blocktree
.insert_shreds(all_shreds, None)
.insert_shreds(all_shreds, None, true)
.expect("Failed to insert shreds in blocktree");
// 3) Start broadcast step

2
core/src/broadcast_stage/standard_broadcast_run.rs
View File

@ -218,7 +218,7 @@ impl StandardBroadcastRun {
let insert_shreds_start = Instant::now();
if insert {
blocktree
.insert_shreds(shreds.clone(), None)
.insert_shreds(shreds.clone(), None, true)
.expect("Failed to insert shreds in blocktree");
}
let insert_shreds_elapsed = insert_shreds_start.elapsed();

4
core/src/cluster_info.rs
View File

@ -1992,7 +1992,7 @@ mod tests {
);
blocktree
.insert_shreds(vec![shred_info], None)
.insert_shreds(vec![shred_info], None, false)
.expect("Expect successful ledger write");
let rv = ClusterInfo::run_window_request(
@ -2074,7 +2074,7 @@ mod tests {
let (shreds, _) = make_many_slot_entries(1, 3, 5);
blocktree
.insert_shreds(shreds, None)
.insert_shreds(shreds, None, false)
.expect("Expect successful ledger write");
// We don't have slot 4, so we don't know how to service this requeset

6
core/src/cluster_info_repair_listener.rs
View File

@ -670,7 +670,7 @@ mod tests {
let blocktree = Blocktree::open(&blocktree_path).unwrap();
let num_slots = 2;
let (shreds, _) = make_many_slot_entries(0, num_slots, 1);
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
// Write roots so that these slots will qualify to be sent by the repairman
let last_root = num_slots - 1;
@ -741,7 +741,7 @@ mod tests {
let num_shreds_per_slot = shreds.len() as u64 / num_slots;
// Write slots in the range [0, num_slots] to blocktree
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
// Write roots so that these slots will qualify to be sent by the repairman
let roots: Vec<_> = (0..=num_slots - 1).collect();
@ -819,7 +819,7 @@ mod tests {
// Create blobs for first two epochs and write them to blocktree
let total_slots = slots_per_epoch * 2;
let (shreds, _) = make_many_slot_entries(0, total_slots, 1);
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
// Write roots so that these slots will qualify to be sent by the repairman
let roots: Vec<_> = (0..=slots_per_epoch * 2 - 1).collect();

2
core/src/ledger_cleanup_service.rs
View File

@ -79,7 +79,7 @@ mod tests {
let blocktree_path = get_tmp_ledger_path!();
let blocktree = Blocktree::open(&blocktree_path).unwrap();
let (shreds, _) = make_many_slot_entries(0, 50, 5);
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
let blocktree = Arc::new(blocktree);
let (sender, receiver) = channel();

26
core/src/repair_service.rs
View File

@ -411,7 +411,7 @@ mod test {
let (mut shreds, _) = make_slot_entries(1, 0, 1);
let (shreds2, _) = make_slot_entries(5, 2, 1);
shreds.extend(shreds2);
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
assert_eq!(
RepairService::generate_repairs(&blocktree, 0, 2).unwrap(),
vec![RepairType::HighestBlob(0, 0), RepairType::Orphan(2)]
@ -431,7 +431,7 @@ mod test {
// Write this blob to slot 2, should chain to slot 0, which we haven't received
// any blobs for
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
// Check that repair tries to patch the empty slot
assert_eq!(
@ -467,7 +467,9 @@ mod test {
missing_indexes_per_slot.insert(0, index);
}
}
blocktree.insert_shreds(shreds_to_write, None).unwrap();
blocktree
.insert_shreds(shreds_to_write, None, false)
.unwrap();
// sleep so that the holes are ready for repair
sleep(Duration::from_secs(1));
let expected: Vec<RepairType> = (0..num_slots)
@ -506,7 +508,7 @@ mod test {
// Remove last shred (which is also last in slot) so that slot is not complete
shreds.pop();
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
// We didn't get the last blob for this slot, so ask for the highest blob for that slot
let expected: Vec<RepairType> =
@ -532,7 +534,7 @@ mod test {
let shreds = make_chaining_slot_entries(&slots, num_entries_per_slot);
for (mut slot_shreds, _) in shreds.into_iter() {
slot_shreds.remove(0);
blocktree.insert_shreds(slot_shreds, None).unwrap();
blocktree.insert_shreds(slot_shreds, None, false).unwrap();
}
// sleep to make slot eligible for repair
sleep(Duration::from_secs(1));
@ -585,7 +587,7 @@ mod test {
let parent = if i > 0 { i - 1 } else { 0 };
let (shreds, _) = make_slot_entries(i, parent, num_entries_per_slot as u64);
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
}
let end = 4;
@ -638,9 +640,9 @@ mod test {
.collect();
let mut full_slots = BTreeSet::new();
blocktree.insert_shreds(fork1_shreds, None).unwrap();
blocktree.insert_shreds(fork1_shreds, None, false).unwrap();
blocktree
.insert_shreds(fork2_incomplete_shreds, None)
.insert_shreds(fork2_incomplete_shreds, None, false)
.unwrap();
// Test that only slots > root from fork1 were included
@ -664,7 +666,7 @@ mod test {
.into_iter()
.flat_map(|(shreds, _)| shreds)
.collect();
blocktree.insert_shreds(fork3_shreds, None).unwrap();
blocktree.insert_shreds(fork3_shreds, None, false).unwrap();
RepairService::get_completed_slots_past_root(
&blocktree,
&mut full_slots,
@ -711,7 +713,9 @@ mod test {
let step = rng.gen_range(1, max_step + 1) as usize;
let step = std::cmp::min(step, num_shreds - i);
let shreds_to_insert = shreds.drain(..step).collect_vec();
blocktree_.insert_shreds(shreds_to_insert, None).unwrap();
blocktree_
.insert_shreds(shreds_to_insert, None, false)
.unwrap();
sleep(Duration::from_millis(repair_interval_ms));
i += step;
}
@ -741,7 +745,7 @@ mod test {
// Update with new root, should filter out the slots <= root
root = num_slots / 2;
let (shreds, _) = make_slot_entries(num_slots + 2, num_slots + 1, entries_per_slot);
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
RepairService::update_epoch_slots(
Pubkey::default(),
root,

6
core/src/replay_stage.rs
View File

@ -973,7 +973,7 @@ mod test {
// Insert blob for slot 1, generate new forks, check result
let (shreds, _) = make_slot_entries(1, 0, 8);
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
assert!(bank_forks.get(1).is_none());
ReplayStage::generate_new_bank_forks(
&blocktree,
@ -984,7 +984,7 @@ mod test {
// Insert blob for slot 3, generate new forks, check result
let (shreds, _) = make_slot_entries(2, 0, 8);
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
assert!(bank_forks.get(2).is_none());
ReplayStage::generate_new_bank_forks(
&blocktree,
@ -1230,7 +1230,7 @@ mod test {
let last_blockhash = bank0.last_blockhash();
progress.insert(bank0.slot(), ForkProgress::new(0, last_blockhash));
let shreds = shred_to_insert(&mint_keypair, bank0.clone());
blocktree.insert_shreds(shreds, None).unwrap();
blocktree.insert_shreds(shreds, None, false).unwrap();
let (res, _tx_count) =
ReplayStage::replay_blocktree_into_bank(&bank0, &blocktree, &mut progress);

5
core/src/window_service.rs
View File

@ -132,7 +132,8 @@ where
}
}
let blocktree_insert_metrics = blocktree.insert_shreds(shreds, Some(leader_schedule_cache))?;
let blocktree_insert_metrics =
blocktree.insert_shreds(shreds, Some(leader_schedule_cache), false)?;
blocktree_insert_metrics.report_metrics("recv-window-insert-shreds");
trace!(
@ -322,7 +323,7 @@ mod test {
let mut shreds = local_entries_to_shred(&original_entries, 0, 0, &Arc::new(Keypair::new()));
shreds.reverse();
blocktree
.insert_shreds(shreds, None)
.insert_shreds(shreds, None, false)
.expect("Expect successful processing of shred");
assert_eq!(