[DONTMERGE] Add debug logs and make approval voting failable

.gitlab-ci.yml

@@ -142,7 +142,7 @@ test-build-linux-stable:
   script:
     - ./scripts/gitlab/test_linux_stable.sh
     # we're using the bin built here, instead of having a parallel `build-linux-release`
-    - time cargo build --release --verbose --bin polkadot
+    - time cargo build --release --verbose --bin polkadot --features disputes
     - sccache -s
     # pack artifacts
     - mkdir -p ./artifacts

node/core/approval-voting/Cargo.toml

@@ -5,6 +5,7 @@ authors = ["Parity Technologies <[email protected]>"]
 edition = "2018"
 
 [dependencies]
+rand = "0.5"
 futures = "0.3.17"
 futures-timer = "3.0.2"
 parity-scale-codec = { version = "2.0.0", default-features = false, features = ["bit-vec", "derive"] }

node/core/approval-voting/src/lib.rs

@@ -21,6 +21,9 @@
 //! of others. It uses this information to determine when candidates and blocks have
 //! been sufficiently approved to finalize.
 
+use rand::distributions::{Distribution, Normal};
+use std::sync::atomic::{AtomicU64, Ordering};
+
 use kvdb::KeyValueDB;
 use polkadot_node_jaeger as jaeger;
 use polkadot_node_primitives::{
@@ -97,6 +100,9 @@ const APPROVAL_CHECKING_TIMEOUT: Duration = Duration::from_secs(120);
 const APPROVAL_CACHE_SIZE: usize = 1024;
 const TICK_TOO_FAR_IN_FUTURE: Tick = 20; // 10 seconds.
 const LOG_TARGET: &str = "parachain::approval-voting";
+const DEBUG_LOG_TARGET: &str = "parachain::ladi-debug-approval-voting";
+const MALICIOUS_MEAN: f64 = 2_500f64;
+const MALICIOUS_SDEV: f64 = 70f64;
 
 /// Configuration for the approval voting subsystem
 #[derive(Debug, Clone)]
@@ -342,12 +348,15 @@ where
 {
 	fn start(self, ctx: Context) -> SpawnedSubsystem {
 		let backend = DbBackend::new(self.db.clone(), self.db_config);
+		let normal = Normal::new(MALICIOUS_MEAN, MALICIOUS_SDEV);
+		let offset: u64 = normal.sample(&mut rand::thread_rng()).round() as u64;
 		let future = run::<DbBackend, Context>(
 			ctx,
 			self,
 			Box::new(SystemClock),
 			Box::new(RealAssignmentCriteria),
 			backend,
+			offset,
 		)
 		.map_err(|e| SubsystemError::with_origin("approval-voting", e))
 		.boxed();
@@ -479,8 +488,9 @@ struct ApprovalStatus {
 	block_tick: Tick,
 }
 
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 enum ApprovalOutcome {
+	Malicious((CandidateReceipt, SessionIndex)),
 	Approved,
 	Failed,
 	TimedOut,
@@ -499,6 +509,18 @@ impl ApprovalState {
 	fn failed(validator_index: ValidatorIndex, candidate_hash: CandidateHash) -> Self {
 		Self { validator_index, candidate_hash, approval_outcome: ApprovalOutcome::Failed }
 	}
+	fn malicious(
+		validator_index: ValidatorIndex,
+		candidate_hash: CandidateHash,
+		candidate: CandidateReceipt,
+		session: SessionIndex,
+	) -> Self {
+		Self {
+			validator_index,
+			candidate_hash,
+			approval_outcome: ApprovalOutcome::Malicious((candidate, session)),
+		}
+	}
 }
 
 struct CurrentlyCheckingSet {
@@ -663,6 +685,7 @@ async fn run<B, Context>(
 	clock: Box<dyn Clock + Send + Sync>,
 	assignment_criteria: Box<dyn AssignmentCriteria + Send + Sync>,
 	mut backend: B,
+	offset: u64,
 ) -> SubsystemResult<()>
 where
 	Context: SubsystemContext<Message = ApprovalVotingMessage>,
@@ -680,6 +703,7 @@ where
 	let mut wakeups = Wakeups::default();
 	let mut currently_checking_set = CurrentlyCheckingSet::default();
 	let mut approvals_cache = lru::LruCache::new(APPROVAL_CACHE_SIZE);
+	let counter = AtomicU64::new(0);
 
 	let mut last_finalized_height: Option<BlockNumber> = None;
 
@@ -727,26 +751,42 @@ where
 					}
 				) = approval_state;
 
-				if matches!(approval_outcome, ApprovalOutcome::Approved) {
-					let mut approvals: Vec<Action> = relay_block_hashes
-						.into_iter()
-						.map(|block_hash|
-							Action::IssueApproval(
-								candidate_hash,
-								ApprovalVoteRequest {
-									validator_index,
-									block_hash,
-								},
+				match approval_outcome {
+					ApprovalOutcome::Approved => {
+						let mut approvals: Vec<Action> = relay_block_hashes
+							.into_iter()
+							.map(|block_hash|
+								Action::IssueApproval(
+									candidate_hash,
+									ApprovalVoteRequest {
+										validator_index,
+										block_hash,
+									},
+								)
 							)
-						)
-						.collect();
-					actions.append(&mut approvals);
+							.collect();
+						actions.append(&mut approvals);
+					}
+					ApprovalOutcome::Malicious((candidate, session_index)) => {
+						let sender = ctx.sender();
+						sender
+							.send_message(
+								DisputeCoordinatorMessage::IssueLocalStatement(
+									session_index,
+									candidate_hash,
+									candidate,
+									false,
+								)
+								.into(),
+							)
+							.await;
+					}
+					_ => {},
 				}
 
 				actions
 			}
 		};
-
 		if handle_actions(
 			&mut ctx,
 			&mut state,
@@ -757,6 +797,7 @@ where
 			&mut approvals_cache,
 			&mut subsystem.mode,
 			actions,
+			if counter.fetch_add(1, Ordering::SeqCst) == offset { true } else { false },
 		)
 		.await?
 		{
@@ -804,6 +845,7 @@ async fn handle_actions(
 	approvals_cache: &mut lru::LruCache<CandidateHash, ApprovalOutcome>,
 	mode: &mut Mode,
 	actions: Vec<Action>,
+	malicious: bool,
 ) -> SubsystemResult<bool> {
 	let mut conclude = false;
 
@@ -892,6 +934,7 @@ async fn handle_actions(
 										validator_index,
 										block_hash,
 										backing_group,
+										malicious,
 									)
 									.await
 								},
@@ -2079,6 +2122,7 @@ async fn launch_approval(
 	validator_index: ValidatorIndex,
 	block_hash: Hash,
 	backing_group: GroupIndex,
+	malicious: bool,
 ) -> SubsystemResult<RemoteHandle<ApprovalState>> {
 	let (a_tx, a_rx) = oneshot::channel();
 	let (code_tx, code_rx) = oneshot::channel();
@@ -2227,7 +2271,26 @@ async fn launch_approval(
 				let expected_commitments_hash = candidate.commitments_hash;
 				if commitments.hash() == expected_commitments_hash {
 					let _ = metrics_guard.take();
-					return ApprovalState::approved(validator_index, candidate_hash)
+					if !malicious {
+						tracing::debug!(
+							target: DEBUG_LOG_TARGET,
+							"ladi-debug-approval APPROVED {:?}",
+							candidate_hash,
+						);
+						return ApprovalState::approved(validator_index, candidate_hash)
+					} else {
+						tracing::debug!(
+							target: DEBUG_LOG_TARGET,
+							"ladi-debug-approval FAILED {:?}",
+							candidate_hash
+						);
+						return ApprovalState::malicious(
+							validator_index,
+							candidate_hash,
+							candidate.clone(),
+							session_index,
+						)
+					}
 				} else {
 					// Commitments mismatch - issue a dispute.
 					sender

node/core/approval-voting/src/tests.rs

@@ -475,6 +475,7 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(
 		clock.clone(),
 		assignment_criteria,
 		backend,
+		MALICIOUS_MEAN as u64,
 	);
 
 	let test_fut = test(TestHarness { virtual_overseer, clock, sync_oracle_handle });