Malus: improvements in dispute ancestor and suggest garbage candidate implementation

node/malus/src/malus.rs

@@ -16,7 +16,7 @@
 
 //! A malus or nemesis node launch code.
 
-use clap::Parser;
+use clap::{ArgEnum, Parser};
 use color_eyre::eyre;
 use polkadot_cli::{Cli, RunCmd};
 
@@ -48,11 +48,24 @@ enum NemesisVariant {
 	PvfExecuteWorker(polkadot_cli::ValidationWorkerCommand),
 }
 
+#[derive(ArgEnum, Clone, Debug, PartialEq)]
+#[clap(rename_all = "kebab-case")]
+pub enum FakeCandidateValidation {
+	Invalid,
+	// TODO: impl Valid.
+}
+
 #[derive(Debug, Parser)]
 #[allow(missing_docs)]
 struct MalusCli {
 	#[clap(subcommand)]
 	pub variant: NemesisVariant,
+
+	#[clap(long, arg_enum, ignore_case = true)]
+	pub fake_backing_validation: Option<FakeCandidateValidation>,
+
+	#[clap(long, arg_enum, ignore_case = true)]
+	pub fake_approval_validation: Option<FakeCandidateValidation>,
 }
 
 fn run_cmd(run: RunCmd) -> Cli {
@@ -67,8 +80,13 @@ impl MalusCli {
 				polkadot_cli::run_node(run_cmd(cmd), BackGarbageCandidate)?,
 			NemesisVariant::SuggestGarbageCandidate(cmd) =>
 				polkadot_cli::run_node(run_cmd(cmd), SuggestGarbageCandidate)?,
-			NemesisVariant::DisputeAncestor(cmd) =>
-				polkadot_cli::run_node(run_cmd(cmd), DisputeValidCandidates)?,
+			NemesisVariant::DisputeAncestor(cmd) => polkadot_cli::run_node(
+				run_cmd(cmd),
+				DisputeValidCandidates::new(
+					self.fake_backing_validation,
+					self.fake_approval_validation,
+				),
+			)?,
 			NemesisVariant::PvfPrepareWorker(cmd) => {
 				#[cfg(target_os = "android")]
 				{

node/malus/src/variants/common.rs

@@ -0,0 +1,133 @@
+// Copyright 2022 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Implements common code for nemesis. Currently, only `FakeValidationResult`
+//! interceptor is implemented.
+
+#![allow(missing_docs)]
+
+// Filter wrapping related types.
+use crate::{interceptor::*, shared::MALUS, FakeCandidateValidation};
+use polkadot_node_primitives::{InvalidCandidate, ValidationResult};
+use polkadot_node_subsystem::messages::CandidateValidationMessage;
+
+#[derive(Clone, Debug)]
+/// An interceptor which fakes validation result with a preconfigured result.
+/// Replaces `CandidateValidationSubsystem`.
+pub struct ReplaceValidationResult {
+	fake_backing_validation: Option<FakeCandidateValidation>,
+	fake_approval_validation: Option<FakeCandidateValidation>,
+}
+
+impl ReplaceValidationResult {
+	pub fn new(
+		fake_backing_validation: Option<FakeCandidateValidation>,
+		fake_approval_validation: Option<FakeCandidateValidation>,
+	) -> Self {
+		Self { fake_backing_validation, fake_approval_validation }
+	}
+}
+
+impl<Sender> MessageInterceptor<Sender> for ReplaceValidationResult
+where
+	Sender: overseer::SubsystemSender<CandidateValidationMessage> + Clone + Send + 'static,
+{
+	type Message = CandidateValidationMessage;
+
+	// Capture all candidate validation requests and depending on configuration fail them.
+	// MaybeTODO: add option to configure the failure reason.
+	fn intercept_incoming(
+		&self,
+		_sender: &mut Sender,
+		msg: FromOverseer<Self::Message>,
+	) -> Option<FromOverseer<Self::Message>> {
+		if self.fake_backing_validation.is_none() && self.fake_approval_validation.is_none() {
+			return Some(msg)
+		}
+
+		match msg {
+			FromOverseer::Communication {
+				msg:
+					CandidateValidationMessage::ValidateFromExhaustive(
+						validation_data,
+						validation_code,
+						descriptor,
+						pov,
+						timeout,
+						sender,
+					),
+			} => {
+				if let Some(FakeCandidateValidation::Invalid) = self.fake_approval_validation {
+					let validation_result =
+						ValidationResult::Invalid(InvalidCandidate::InvalidOutputs);
+
+					tracing::info!(
+						target = MALUS,
+						para_id = ?descriptor.para_id,
+						candidate_hash = ?descriptor.para_head,
+						"ValidateFromExhaustive result: {:?}",
+						&validation_result
+					);
+					// We're not even checking the candidate, this makes us appear faster than honest validators.
+					sender.send(Ok(validation_result)).unwrap();
+					None
+				} else {
+					Some(FromOverseer::Communication {
+						msg: CandidateValidationMessage::ValidateFromExhaustive(
+							validation_data,
+							validation_code,
+							descriptor,
+							pov,
+							timeout,
+							sender,
+						),
+					})
+				}
+			},
+			FromOverseer::Communication {
+				msg:
+					CandidateValidationMessage::ValidateFromChainState(descriptor, pov, timeout, sender),
+			} => {
+				if let Some(FakeCandidateValidation::Invalid) = self.fake_backing_validation {
+					let validation_result =
+						ValidationResult::Invalid(InvalidCandidate::InvalidOutputs);
+					tracing::info!(
+						target = MALUS,
+						para_id = ?descriptor.para_id,
+						candidate_hash = ?descriptor.para_head,
+						"ValidateFromChainState result: {:?}",
+						&validation_result
+					);
+
+					// We're not even checking the candidate, this makes us appear faster than honest validators.
+					sender.send(Ok(validation_result)).unwrap();
+					None
+				} else {
+					Some(FromOverseer::Communication {
+						msg: CandidateValidationMessage::ValidateFromChainState(
+							descriptor, pov, timeout, sender,
+						),
+					})
+				}
+			},
+			msg => Some(msg),
+		}
+	}
+
+	fn intercept_outgoing(&self, msg: AllMessages) -> Option<AllMessages> {
+		Some(msg)
+	}
+}

node/malus/src/variants/dispute_valid_candidates.rs

@@ -31,11 +31,15 @@ use polkadot_cli::{
 };
 
 // Filter wrapping related types.
-use crate::interceptor::*;
+use crate::{
+	interceptor::*, shared::MALUS, variants::ReplaceValidationResult, FakeCandidateValidation,
+};
 
 // Import extra types relevant to the particular
 // subsystem.
 use polkadot_node_core_backing::CandidateBackingSubsystem;
+use polkadot_node_core_candidate_validation::CandidateValidationSubsystem;
+
 use polkadot_node_subsystem::messages::{
 	ApprovalDistributionMessage, CandidateBackingMessage, DisputeCoordinatorMessage,
 };
@@ -75,6 +79,12 @@ where
 				session,
 				..
 			}) => {
+				tracing::info!(
+					target = MALUS,
+					para_id = ?candidate_receipt.descriptor.para_id,
+					?candidate_hash,
+					"Disputing candidate",
+				);
 				// this would also dispute candidates we were not assigned to approve
 				Some(AllMessages::DisputeCoordinator(
 					DisputeCoordinatorMessage::IssueLocalStatement(
@@ -89,9 +99,27 @@ where
 		}
 	}
 }
+pub(crate) struct DisputeValidCandidates {
+	/// Backing configuration.
+	fake_backing_validation: Option<FakeCandidateValidation>,
+	/// Approval voting configuration (applies to disputes as well).
+	fake_approval_validation: Option<FakeCandidateValidation>,
+}
 
-/// Generates an overseer that disputes instead of approving valid candidates.
-pub(crate) struct DisputeValidCandidates;
+impl Default for DisputeValidCandidates {
+	fn default() -> Self {
+		Self { fake_backing_validation: None, fake_approval_validation: None }
+	}
+}
+
+impl DisputeValidCandidates {
+	pub fn new(
+		fake_backing_validation: Option<FakeCandidateValidation>,
+		fake_approval_validation: Option<FakeCandidateValidation>,
+	) -> Self {
+		Self { fake_backing_validation, fake_approval_validation }
+	}
+}
 
 impl OverseerGen for DisputeValidCandidates {
 	fn generate<'a, Spawner, RuntimeClient>(
@@ -106,13 +134,32 @@ impl OverseerGen for DisputeValidCandidates {
 	{
 		let spawner = args.spawner.clone();
 		let crypto_store_ptr = args.keystore.clone() as SyncCryptoStorePtr;
-		let filter = ReplaceApprovalsWithDisputes;
+		let backing_filter = ReplaceApprovalsWithDisputes;
+		let validation_filter = ReplaceValidationResult::new(
+			self.fake_backing_validation.clone(),
+			self.fake_approval_validation.clone(),
+		);
+		let candidate_validation_config = args.candidate_validation_config.clone();
 
 		prepared_overseer_builder(args)?
-			.replace_candidate_backing(move |cb| {
+			.replace_candidate_backing(move |cb_subsystem| {
+				InterceptedSubsystem::new(
+					CandidateBackingSubsystem::new(
+						spawner,
+						crypto_store_ptr,
+						cb_subsystem.params.metrics,
+					),
+					backing_filter,
+				)
+			})
+			.replace_candidate_validation(move |cv_subsystem| {
 				InterceptedSubsystem::new(
-					CandidateBackingSubsystem::new(spawner, crypto_store_ptr, cb.params.metrics),
-					filter,
+					CandidateValidationSubsystem::with_config(
+						candidate_validation_config,
+						cv_subsystem.metrics,
+						cv_subsystem.pvf_metrics,
+					),
+					validation_filter,
 				)
 			})
 			.build_with_connector(connector)

node/malus/src/variants/mod.rs

@@ -17,10 +17,12 @@
 //! Collection of behavior variants.
 
 mod back_garbage_candidate;
+mod common;
 mod dispute_valid_candidates;
 mod suggest_garbage_candidate;
 
 pub(crate) use self::{
 	back_garbage_candidate::BackGarbageCandidate, dispute_valid_candidates::DisputeValidCandidates,
 	suggest_garbage_candidate::SuggestGarbageCandidate,
 };
+pub(crate) use common::ReplaceValidationResult;