Girazoki xcm queues to maintenance mode

pallets/maintenance-mode/Cargo.toml

@@ -14,6 +14,9 @@ frame-system = { git = "https://github.com/purestake/substrate", branch = "moonb
 parity-scale-codec = { version = "2.2", default-features = false }
 scale-info = { version = "1.0", default-features = false, features = [ "derive" ] }
 sp-runtime = { git = "https://github.com/purestake/substrate", branch = "moonbeam-polkadot-v0.9.12", default-features = false }
+sp-std = { git = "https://github.com/purestake/substrate", branch = "moonbeam-polkadot-v0.9.12", default-features = false }
+
+cumulus-primitives-core = { git = "https://github.com/purestake/cumulus", branch = "moonbeam-polkadot-v0.9.12", default-features = false }
 
 [dev-dependencies]
 sp-core = { git = "https://github.com/purestake/substrate", branch = "moonbeam-polkadot-v0.9.12" }
@@ -26,5 +29,7 @@ std = [
 	"frame-system/std",
 	"scale-info/std",
 	"sp-runtime/std",
+	"cumulus-primitives-core/std",
+	"sp-std/std",
 ]
 try-runtime = [ "frame-support/try-runtime" ]

pallets/maintenance-mode/src/lib.rs

@@ -49,16 +49,24 @@ mod mock;
 #[cfg(test)]
 mod tests;
 
+mod types;
+pub use types::*;
+
 use frame_support::pallet;
 
 pub use pallet::*;
 
 #[pallet]
 pub mod pallet {
+	use cumulus_primitives_core::{
+		relay_chain::BlockNumber as RelayBlockNumber, DmpMessageHandler, ParaId, XcmpMessageHandler,
+	};
 	use frame_support::pallet_prelude::*;
-	use frame_support::traits::{Contains, EnsureOrigin};
+	use frame_support::traits::{
+		Contains, EnsureOrigin, OffchainWorker, OnFinalize, OnIdle, OnInitialize, OnRuntimeUpgrade,
+	};
 	use frame_system::pallet_prelude::*;
-
+	use sp_std::vec::Vec;
 	/// Pallet for migrations
 	#[pallet::pallet]
 	#[pallet::generate_storage_info]
@@ -81,6 +89,34 @@ pub mod pallet {
 		/// able to return to normal mode. For example, if your MaintenanceOrigin is a council, make
 		/// sure that your councilors can still cast votes.
 		type MaintenanceOrigin: EnsureOrigin<Self::Origin>;
+		/// The DMP handler to be used in normal operating mode
+		type NormalDmpHandler: DmpMessageHandler;
+		/// The DMP handler to be used in maintenance mode
+		type MaintenanceDmpHandler: DmpMessageHandler;
+		/// The XCMP handler to be used in normal operating mode
+		type NormalXcmpHandler: XcmpMessageHandler;
+		/// The XCMP handler to be used in maintenance mode
+		type MaintenanceXcmpHandler: XcmpMessageHandler;
+		/// The OnIdle hooks that should be called on normal operating mode
+		type NormalOnIdle: OnIdle<Self::BlockNumber>;
+		/// The OnIdle hooks that should be called on maintenance mode
+		type MaintenanceOnIdle: OnIdle<Self::BlockNumber>;
+		/// The OnInitialize hooks that should be called on normal operating mode
+		type NormalOnInitialize: OnInitialize<Self::BlockNumber>;
+		/// The OnInitialize hooks that should be called on maintenance mode
+		type MaintenanceOnInitialize: OnInitialize<Self::BlockNumber>;
+		/// The OnFinalize hooks that should be called on normal operating mode
+		type NormalOnFinalize: OnFinalize<Self::BlockNumber>;
+		/// The OnFinalize hooks that should be called on maintenance mode
+		type MaintenanceOnFinalize: OnFinalize<Self::BlockNumber>;
+		/// The OffchainWorker hooks that should be called on normal operating mode
+		type NormalOffchainWorker: OffchainWorker<Self::BlockNumber>;
+		/// The OffchainWorker hooks that should be called on maintenance mode
+		type MaintenanceOffchainWorker: OffchainWorker<Self::BlockNumber>;
+		/// The OnRuntimeUpgrade hooks that should be called on normal operating mode
+		type NormalOnRuntimeUpgrade: OnRuntimeUpgrade;
+		/// The OnRuntimeUpgrade hook that should be called on maintenance mode
+		type MaintenanceOnRuntimeUpgrade: OnRuntimeUpgrade;
 	}
 
 	#[pallet::event]
@@ -189,4 +225,29 @@ pub mod pallet {
 			}
 		}
 	}
+	impl<T: Config> DmpMessageHandler for Pallet<T> {
+		fn handle_dmp_messages(
+			iter: impl Iterator<Item = (RelayBlockNumber, Vec<u8>)>,
+			limit: Weight,
+		) -> Weight {
+			if MaintenanceMode::<T>::get() {
+				T::MaintenanceDmpHandler::handle_dmp_messages(iter, limit)
+			} else {
+				T::NormalDmpHandler::handle_dmp_messages(iter, limit)
+			}
+		}
+	}
+
+	impl<T: Config> XcmpMessageHandler for Pallet<T> {
+		fn handle_xcmp_messages<'a, I: Iterator<Item = (ParaId, RelayBlockNumber, &'a [u8])>>(
+			iter: I,
+			limit: Weight,
+		) -> Weight {
+			if MaintenanceMode::<T>::get() {
+				T::MaintenanceXcmpHandler::handle_xcmp_messages(iter, limit)
+			} else {
+				T::NormalXcmpHandler::handle_xcmp_messages(iter, limit)
+			}
+		}
+	}
 }

pallets/maintenance-mode/src/types.rs

@@ -0,0 +1,111 @@
+// Copyright 2019-2021 PureStake Inc.
+// This file is part of Moonbeam.
+
+// Moonbeam 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.
+
+// Moonbeam 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 Moonbeam.  If not, see <http://www.gnu.org/licenses/>.
+
+// This file contains the ExecutiveHooks type which is intended to be used
+// with frame_executive::Executive. This instructs which pallets execute
+// hooks in each of the normal and maintenance modes.
+use super::*;
+use frame_support::{
+	traits::{OffchainWorker, OnFinalize, OnIdle, OnInitialize, OnRuntimeUpgrade},
+	weights::Weight,
+};
+use sp_std::marker::PhantomData;
+
+pub struct ExecutiveHooks<T>(PhantomData<T>);
+type BlockNumberOf<T> = <T as frame_system::Config>::BlockNumber;
+
+impl<T> OnIdle<BlockNumberOf<T>> for ExecutiveHooks<T>
+where
+	T: Config,
+{
+	fn on_idle(n: BlockNumberOf<T>, remaining_weight: Weight) -> Weight {
+		if Pallet::<T>::maintenance_mode() {
+			T::MaintenanceOnIdle::on_idle(n, remaining_weight)
+		} else {
+			T::NormalOnIdle::on_idle(n, remaining_weight)
+		}
+	}
+}
+
+impl<T> OnInitialize<BlockNumberOf<T>> for ExecutiveHooks<T>
+where
+	T: Config,
+{
+	fn on_initialize(n: BlockNumberOf<T>) -> Weight {
+		if Pallet::<T>::maintenance_mode() {
+			T::MaintenanceOnInitialize::on_initialize(n)
+		} else {
+			T::NormalOnInitialize::on_initialize(n)
+		}
+	}
+}
+
+impl<T> OnFinalize<BlockNumberOf<T>> for ExecutiveHooks<T>
+where
+	T: Config,
+{
+	fn on_finalize(n: BlockNumberOf<T>) {
+		if Pallet::<T>::maintenance_mode() {
+			T::MaintenanceOnFinalize::on_finalize(n)
+		} else {
+			T::NormalOnFinalize::on_finalize(n)
+		}
+	}
+}
+
+impl<T> OffchainWorker<BlockNumberOf<T>> for ExecutiveHooks<T>
+where
+	T: Config,
+{
+	fn offchain_worker(n: BlockNumberOf<T>) {
+		if Pallet::<T>::maintenance_mode() {
+			T::MaintenanceOffchainWorker::offchain_worker(n)
+		} else {
+			T::NormalOffchainWorker::offchain_worker(n)
+		}
+	}
+}
+
+impl<T> OnRuntimeUpgrade for ExecutiveHooks<T>
+where
+	T: Config,
+{
+	fn on_runtime_upgrade() -> Weight {
+		if Pallet::<T>::maintenance_mode() {
+			T::MaintenanceOnRuntimeUpgrade::on_runtime_upgrade()
+		} else {
+			T::NormalOnRuntimeUpgrade::on_runtime_upgrade()
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<(), &'static str> {
+		if Pallet::<T>::maintenance_mode() {
+			T::MaintenanceOnRuntimeUpgrade::pre_upgrade()
+		} else {
+			T::NormalOnRuntimeUpgrade::pre_upgrade()
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade() -> Result<(), &'static str> {
+		if Pallet::<T>::maintenance_mode() {
+			T::MaintenanceOnRuntimeUpgrade::post_upgrade()
+		} else {
+			T::NormalOnRuntimeUpgrade::post_upgrade()
+		}
+	}
+}

runtime/moonbase/src/lib.rs

@@ -691,10 +691,10 @@ impl cumulus_pallet_parachain_system::Config for Runtime {
 	type Event = Event;
 	type OnValidationData = ();
 	type SelfParaId = ParachainInfo;
-	type DmpMessageHandler = DmpQueue;
+	type DmpMessageHandler = MaintenanceMode;
 	type ReservedDmpWeight = ReservedDmpWeight;
 	type OutboundXcmpMessageSource = XcmpQueue;
-	type XcmpMessageHandler = XcmpQueue;
+	type XcmpMessageHandler = MaintenanceMode;
 	type ReservedXcmpWeight = ReservedXcmpWeight;
 }
 
@@ -1425,12 +1425,62 @@ impl Contains<Call> for NormalFilter {
 	}
 }
 
+use cumulus_primitives_core::{
+	relay_chain::BlockNumber as RelayBlockNumber, DmpMessageHandler, ParaId, XcmpMessageHandler,
+};
+pub struct MaintenanceDmpHandler;
+impl DmpMessageHandler for MaintenanceDmpHandler {
+	// This implementation makes messages be queued
+	// Since the limit is 0, messages are queued for next iteration
+	fn handle_dmp_messages(
+		iter: impl Iterator<Item = (RelayBlockNumber, Vec<u8>)>,
+		_limit: Weight,
+	) -> Weight {
+		DmpQueue::handle_dmp_messages(iter, 0)
+	}
+}
+
+pub struct MaintenanceXcmpHandler;
+impl XcmpMessageHandler for MaintenanceXcmpHandler {
+	// This implementation makes messages be queued
+	// Since the limit is 0, messages are queued for next iteration
+	fn handle_xcmp_messages<'a, I: Iterator<Item = (ParaId, RelayBlockNumber, &'a [u8])>>(
+		iter: I,
+		_limit: Weight,
+	) -> Weight {
+		XcmpQueue::handle_xcmp_messages(iter, 0)
+	}
+}
+
+// Default implementation already returns 0
+// For some reason using empty tuple () isnt working
+pub struct NoOnIdle;
+impl frame_support::traits::OnIdle<BlockNumber> for NoOnIdle {}
+
 impl pallet_maintenance_mode::Config for Runtime {
 	type Event = Event;
 	type NormalCallFilter = NormalFilter;
 	type MaintenanceCallFilter = MaintenanceFilter;
 	type MaintenanceOrigin =
 		pallet_collective::EnsureProportionAtLeast<_2, _3, AccountId, TechCommitteeInstance>;
+	type NormalDmpHandler = DmpQueue;
+	type MaintenanceDmpHandler = MaintenanceDmpHandler;
+	type NormalXcmpHandler = XcmpQueue;
+	type MaintenanceXcmpHandler = MaintenanceXcmpHandler;
+	type NormalOnIdle = AllPallets;
+	// There exist only two pallets that use onIdle and these are xcmp and dmp queues
+	// For some reason putting an empty tumple does not work (transaction never finishes)
+	// We use an empty onIdle, if on the future we want one of the pallets to execute it
+	// we need to provide it here
+	type MaintenanceOnIdle = NoOnIdle;
+	type NormalOnInitialize = AllPallets;
+	type MaintenanceOnInitialize = AllPallets;
+	type NormalOnFinalize = AllPallets;
+	type MaintenanceOnFinalize = AllPallets;
+	type NormalOffchainWorker = AllPallets;
+	type MaintenanceOffchainWorker = AllPallets;
+	type NormalOnRuntimeUpgrade = AllPallets;
+	type MaintenanceOnRuntimeUpgrade = AllPallets;
 }
 
 impl pallet_proxy_genesis_companion::Config for Runtime {
@@ -1513,7 +1563,7 @@ pub type Executive = frame_executive::Executive<
 	Block,
 	frame_system::ChainContext<Runtime>,
 	Runtime,
-	AllPallets,
+	pallet_maintenance_mode::ExecutiveHooks<Runtime>,
 >;
 
 // All of our runtimes share most of their Runtime API implementations.

runtime/moonbase/tests/xcm_mock/parachain.rs

@@ -629,6 +629,35 @@ impl xcm_transactor::Config for Runtime {
 	type BaseXcmWeight = BaseXcmWeight;
 }
 
+pub struct NormalFilter;
+impl frame_support::traits::Contains<Call> for NormalFilter {
+	fn contains(c: &Call) -> bool {
+		match c {
+			_ => true,
+		}
+	}
+}
+
+pub struct MaintenanceFilter;
+impl frame_support::traits::Contains<Call> for MaintenanceFilter {
+	fn contains(c: &Call) -> bool {
+		match c {
+			Call::Balances(_) => false,
+			Call::XTokens(_) => false,
+			_ => true,
+		}
+	}
+}
+
+impl pallet_maintenance_mode::Config for Runtime {
+	type Event = Event;
+	type NormalCallFilter = NormalFilter;
+	type MaintenanceCallFilter = MaintenanceFilter;
+	type MaintenanceOrigin = EnsureRoot<AccountId>;
+	type NormalDmpHandler = MsgQueue;
+	type MaintenanceDmpHandler = ();
+}
+
 // We need to use the encoding from the relay mock runtime
 #[derive(Encode, Decode)]
 pub enum RelayCall {
@@ -691,7 +720,7 @@ construct_runtime!(
 		XTokens: orml_xtokens::{Pallet, Call, Storage, Event<T>},
 		AssetManager: pallet_asset_manager::{Pallet, Call, Storage, Event<T>},
 		XcmTransactor: xcm_transactor::{Pallet, Call, Storage, Event<T>},
-
+		MaintenanceMode: pallet_maintenance_mode::{Pallet, Call, Config, Storage, Event}
 	}
 );
 

runtime/moonbeam/src/lib.rs

@@ -914,6 +914,20 @@ impl pallet_maintenance_mode::Config for Runtime {
 	type MaintenanceCallFilter = MaintenanceFilter;
 	type MaintenanceOrigin =
 		pallet_collective::EnsureProportionAtLeast<_2, _3, AccountId, TechCommitteeInstance>;
+	type NormalDmpHandler = ();
+	type MaintenanceDmpHandler = ();
+	type NormalXcmpHandler = ();
+	type MaintenanceXcmpHandler = ();
+	type NormalOnIdle = AllPallets;
+	type MaintenanceOnIdle = AllPallets;
+	type NormalOnInitialize = AllPallets;
+	type MaintenanceOnInitialize = AllPallets;
+	type NormalOnFinalize = AllPallets;
+	type MaintenanceOnFinalize = AllPallets;
+	type NormalOffchainWorker = AllPallets;
+	type MaintenanceOffchainWorker = AllPallets;
+	type NormalOnRuntimeUpgrade = AllPallets;
+	type MaintenanceOnRuntimeUpgrade = AllPallets;
 }
 
 impl pallet_proxy_genesis_companion::Config for Runtime {
@@ -1005,7 +1019,7 @@ pub type Executive = frame_executive::Executive<
 	Block,
 	frame_system::ChainContext<Runtime>,
 	Runtime,
-	AllPallets,
+	MaintenanceMode::ExecutiveHooks,
 >;
 
 // All of our runtimes share most of their Runtime API implementations.