Change the Config of the MaxRococoNum Slot from a Constant to a Storage function

runtime/common/src/assigned_slots/migration.rs

@@ -0,0 +1,62 @@
+// Copyright (C) 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/>.
+
+use super::{Config, MaxPermanentSlots, MaxTemporarySlots, Pallet, LOG_TARGET};
+use frame_support::{
+	dispatch::GetStorageVersion,
+	traits::{Get, OnRuntimeUpgrade, StorageVersion},
+	weights::Weight,
+};
+
+pub mod v1 {
+
+	use super::*;
+	pub struct MigrateToV1<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV1<T> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, &'static str> {
+			let onchain_version = Pallet::<T>::on_chain_storage_version();
+			ensure!(onchain_version < 1, "assigned_slots::MigrateToV1 migration can be deleted");
+			Ok(Default::default())
+		}
+
+		fn on_runtime_upgrade() -> frame_support::weights::Weight {
+			let onchain_version = Pallet::<T>::on_chain_storage_version();
+			if onchain_version < 1 {
+				const MAX_PERMANENT_SLOTS: u32 = 100;
+				const MAX_TEMPORARY_SLOTS: u32 = 100;
+
+				<MaxPermanentSlots<T>>::put(MAX_PERMANENT_SLOTS);
+				<MaxTemporarySlots<T>>::put(MAX_TEMPORARY_SLOTS);
+				// Update storage version.
+				StorageVersion::new(1).put::<Pallet<T>>();
+				// Return the weight consumed by the migration.
+				T::DbWeight::get().reads_writes(1, 3)
+			} else {
+				log::info!(target: LOG_TARGET, "assigned_slots::MigrateToV1 should be removed");
+
+				Weight::zero()
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_state: Vec<u8>) -> Result<(), &'static str> {
+			let onchain_version = Pallet::<T>::on_chain_storage_version();
+			ensure!(onchain_version == 1, "assigned_slots::MigrateToV1 needs to be run");
+			Ok(())
+		}
+	}
+}

runtime/common/src/assigned_slots.rs → runtime/common/src/assigned_slots/mod.rs

@@ -23,6 +23,8 @@
 //! This pallet should not be used on a production relay chain,
 //! only on a test relay chain (e.g. Rococo).
 
+pub mod migration;
+
 use crate::{
 	slots::{self, Pallet as Slots, WeightInfo},
 	traits::{LeaseError, Leaser, Registrar},
@@ -41,6 +43,8 @@ use scale_info::TypeInfo;
 use sp_runtime::traits::{One, Saturating, Zero};
 use sp_std::prelude::*;
 
+const LOG_TARGET: &str = "runtime::assigned_slots";
+
 /// Lease period an assigned slot should start from (current, or next one).
 #[derive(Encode, Decode, Clone, Copy, Eq, PartialEq, RuntimeDebug, TypeInfo)]
 pub enum SlotLeasePeriodStart {
@@ -77,7 +81,11 @@ type LeasePeriodOf<T> =
 pub mod pallet {
 	use super::*;
 
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
 	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
 	pub struct Pallet<T>(_);
 
 	#[pallet::config]
@@ -104,14 +112,6 @@ pub mod pallet {
 		#[pallet::constant]
 		type TemporarySlotLeasePeriodLength: Get<u32>;
 
-		/// The max number of permanent slots that can be assigned.
-		#[pallet::constant]
-		type MaxPermanentSlots: Get<u32>;
-
-		/// The max number of temporary slots that can be assigned.
-		#[pallet::constant]
-		type MaxTemporarySlots: Get<u32>;
-
 		/// The max number of temporary slots to be scheduled per lease periods.
 		#[pallet::constant]
 		type MaxTemporarySlotPerLeasePeriod: Get<u32>;
@@ -149,13 +149,40 @@ pub mod pallet {
 	#[pallet::getter(fn active_temporary_slot_count)]
 	pub type ActiveTemporarySlotCount<T: Config> = StorageValue<_, u32, ValueQuery>;
 
+	/// Assigned max temporary slots storage.
+	#[pallet::storage]
+	pub type MaxTemporarySlots<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	/// Assigned max permanent slots storage.
+	#[pallet::storage]
+	pub type MaxPermanentSlots<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(Default)]
+	pub struct GenesisConfig {
+		pub max_temporary_slots: u32,
+		pub max_permanent_slots: u32,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> GenesisBuild<T> for GenesisConfig {
+		fn build(&self) {
+			<MaxPermanentSlots<T>>::put(&self.max_permanent_slots);
+			<MaxTemporarySlots<T>>::put(&self.max_temporary_slots);
+		}
+	}
+
 	#[pallet::event]
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {
 		/// A para was assigned a permanent parachain slot
 		PermanentSlotAssigned(ParaId),
 		/// A para was assigned a temporary parachain slot
 		TemporarySlotAssigned(ParaId),
+		/// A maximum number of permanent slots has been assigned
+		MaxPermanentSlotsAssigned { slots: u32 },
+		/// A maximum number of temporary slots has been assigned
+		MaxTemporarySlotsAssigned { slots: u32 },
 	}
 
 	#[pallet::error]
@@ -228,7 +255,7 @@ pub mod pallet {
 			);
 
 			ensure!(
-				PermanentSlotCount::<T>::get() < T::MaxPermanentSlots::get(),
+				PermanentSlotCount::<T>::get() < MaxPermanentSlots::<T>::get(),
 				Error::<T>::MaxPermanentSlotsExceeded
 			);
 
@@ -291,7 +318,7 @@ pub mod pallet {
 			);
 
 			ensure!(
-				TemporarySlotCount::<T>::get() < T::MaxTemporarySlots::get(),
+				TemporarySlotCount::<T>::get() < MaxTemporarySlots::<T>::get(),
 				Error::<T>::MaxTemporarySlotsExceeded
 			);
 
@@ -324,9 +351,12 @@ pub mod pallet {
 					Err(err) => {
 						// Treat failed lease creation as warning .. slot will be allocated a lease
 						// in a subsequent lease period by the `allocate_temporary_slot_leases` function.
-						log::warn!(target: "assigned_slots",
+						log::warn!(
+							target: LOG_TARGET,
 							"Failed to allocate a temp slot for para {:?} at period {:?}: {:?}",
-							id, current_lease_period, err
+							id,
+							current_lease_period,
+							err
 						);
 					},
 				}
@@ -377,15 +407,48 @@ pub mod pallet {
 					// Treat failed downgrade as warning .. slot lease has been cleared,
 					// so the parachain will be downgraded anyway by the slots pallet
 					// at the end of the lease period .
-					log::warn!(target: "assigned_slots",
+					log::warn!(
+						target: LOG_TARGET,
 						"Failed to downgrade parachain {:?} at period {:?}: {:?}",
-						id, Self::current_lease_period_index(), err
+						id,
+						Self::current_lease_period_index(),
+						err
 					);
 				}
 			}
 
 			Ok(())
 		}
+
+		// TODO: Benchmark this
+		/// Assign a max permanent slot number.
+		#[pallet::call_index(3)]
+		#[pallet::weight(((MAXIMUM_BLOCK_WEIGHT / 10) as Weight, DispatchClass::Operational))]
+		pub fn set_max_permanent_slots(origin: OriginFor<T>, slots: u32) -> DispatchResult {
+			ensure_root(origin)?;
+
+			<MaxPermanentSlots<T>>::put(slots);
+
+			// Emit an event.
+			Self::deposit_event(Event::<T>::MaxPermanentSlotsAssigned { slots });
+			// Return a successful DispatchResult
+			Ok(())
+		}
+
+		// TODO: Benchmark this
+		/// Assign a max temporary slot number.
+		#[pallet::call_index(4)]
+		#[pallet::weight(((MAXIMUM_BLOCK_WEIGHT / 10) as Weight, DispatchClass::Operational))]
+		pub fn set_max_temporary_slots(origin: OriginFor<T>, slots: u32) -> DispatchResult {
+			ensure_root(origin)?;
+
+			<MaxTemporarySlots<T>>::put(slots);
+
+			// Emit an event.
+			Self::deposit_event(Event::<T>::MaxTemporarySlotsAssigned { slots });
+			// Return a successful DispatchResult
+			Ok(())
+		}
 	}
 }
 
@@ -528,9 +591,11 @@ impl<T: Config> Pallet<T> {
 	fn manage_lease_period_start(lease_period_index: LeasePeriodOf<T>) -> Weight {
 		// Note: leases that have ended in previous lease period, should have been cleaned in slots pallet.
 		if let Err(err) = Self::allocate_temporary_slot_leases(lease_period_index) {
-			log::error!(target: "assigned_slots",
+			log::error!(
+				target: LOG_TARGET,
 				"Allocating slots failed for lease period {:?}, with: {:?}",
-				lease_period_index, err
+				lease_period_index,
+				err
 			);
 		}
 		<T as slots::Config>::WeightInfo::force_lease() *
@@ -673,8 +738,6 @@ mod tests {
 	parameter_types! {
 		pub const PermanentSlotLeasePeriodLength: u32 = 3;
 		pub const TemporarySlotLeasePeriodLength: u32 = 2;
-		pub const MaxPermanentSlots: u32 = 2;
-		pub const MaxTemporarySlots: u32 = 6;
 		pub const MaxTemporarySlotPerLeasePeriod: u32 = 2;
 	}
 
@@ -684,8 +747,6 @@ mod tests {
 		type Leaser = Slots;
 		type PermanentSlotLeasePeriodLength = PermanentSlotLeasePeriodLength;
 		type TemporarySlotLeasePeriodLength = TemporarySlotLeasePeriodLength;
-		type MaxPermanentSlots = MaxPermanentSlots;
-		type MaxTemporarySlots = MaxTemporarySlots;
 		type MaxTemporarySlotPerLeasePeriod = MaxTemporarySlotPerLeasePeriod;
 	}
 
@@ -698,6 +759,16 @@ mod tests {
 		}
 		.assimilate_storage(&mut t)
 		.unwrap();
+
+		GenesisBuild::<Test>::assimilate_storage(
+			&crate::assigned_slots::GenesisConfig {
+				max_temporary_slots: 6,
+				max_permanent_slots: 2,
+			},
+			&mut t,
+		)
+		.unwrap();
+
 		t.into()
 	}
 
@@ -1324,4 +1395,47 @@ mod tests {
 			assert_eq!(Slots::already_leased(ParaId::from(1_u32), 0, 1), false);
 		});
 	}
+	#[test]
+	fn set_max_permanent_slots_fails_for_no_root_origin() {
+		new_test_ext().execute_with(|| {
+			run_to_block(1);
+
+			assert_noop!(
+				AssignedSlots::set_max_permanent_slots(RuntimeOrigin::signed(1), 5),
+				BadOrigin
+			);
+		});
+	}
+	#[test]
+	fn set_max_permanent_slots_succeeds() {
+		new_test_ext().execute_with(|| {
+			run_to_block(1);
+
+			assert_eq!(MaxPermanentSlots::<Test>::get(), 2);
+			assert_ok!(AssignedSlots::set_max_permanent_slots(RuntimeOrigin::root(), 10),);
+			assert_eq!(MaxPermanentSlots::<Test>::get(), 10);
+		});
+	}
+
+	#[test]
+	fn set_max_temporary_slots_fails_for_no_root_origin() {
+		new_test_ext().execute_with(|| {
+			run_to_block(1);
+
+			assert_noop!(
+				AssignedSlots::set_max_temporary_slots(RuntimeOrigin::signed(1), 5),
+				BadOrigin
+			);
+		});
+	}
+	#[test]
+	fn set_max_temporary_slots_succeeds() {
+		new_test_ext().execute_with(|| {
+			run_to_block(1);
+
+			assert_eq!(MaxTemporarySlots::<Test>::get(), 6);
+			assert_ok!(AssignedSlots::set_max_temporary_slots(RuntimeOrigin::root(), 12),);
+			assert_eq!(MaxTemporarySlots::<Test>::get(), 12);
+		});
+	}
 }

runtime/rococo/src/lib.rs

@@ -1296,8 +1296,6 @@ impl paras_sudo_wrapper::Config for Runtime {}
 parameter_types! {
 	pub const PermanentSlotLeasePeriodLength: u32 = 365;
 	pub const TemporarySlotLeasePeriodLength: u32 = 5;
-	pub const MaxPermanentSlots: u32 = 100;
-	pub const MaxTemporarySlots: u32 = 100;
 	pub const MaxTemporarySlotPerLeasePeriod: u32 = 5;
 }
 
@@ -1307,8 +1305,6 @@ impl assigned_slots::Config for Runtime {
 	type Leaser = Slots;
 	type PermanentSlotLeasePeriodLength = PermanentSlotLeasePeriodLength;
 	type TemporarySlotLeasePeriodLength = TemporarySlotLeasePeriodLength;
-	type MaxPermanentSlots = MaxPermanentSlots;
-	type MaxTemporarySlots = MaxTemporarySlots;
 	type MaxTemporarySlotPerLeasePeriod = MaxTemporarySlotPerLeasePeriod;
 }
 
@@ -1495,7 +1491,7 @@ pub mod migrations {
 	);
 
 	/// Unreleased migrations. Add new ones here:
-	pub type Unreleased = ();
+	pub type Unreleased = (assigned_slots::migration::v1::MigrateToV1<Runtime>,);
 }
 
 /// Executive: handles dispatch to the various modules.

runtime/westend/src/lib.rs

@@ -947,8 +947,6 @@ impl paras_sudo_wrapper::Config for Runtime {}
 parameter_types! {
 	pub const PermanentSlotLeasePeriodLength: u32 = 26;
 	pub const TemporarySlotLeasePeriodLength: u32 = 1;
-	pub const MaxPermanentSlots: u32 = 5;
-	pub const MaxTemporarySlots: u32 = 20;
 	pub const MaxTemporarySlotPerLeasePeriod: u32 = 5;
 }
 
@@ -958,8 +956,6 @@ impl assigned_slots::Config for Runtime {
 	type Leaser = Slots;
 	type PermanentSlotLeasePeriodLength = PermanentSlotLeasePeriodLength;
 	type TemporarySlotLeasePeriodLength = TemporarySlotLeasePeriodLength;
-	type MaxPermanentSlots = MaxPermanentSlots;
-	type MaxTemporarySlots = MaxTemporarySlots;
 	type MaxTemporarySlotPerLeasePeriod = MaxTemporarySlotPerLeasePeriod;
 }