Move runtime upgrade to frame-executive (#5197)

* Move runtime upgrade to `frame-executive`

Instead of storing the runtime upgraded in the space of `frame-system`,
this moves it to `frame-executive`. We also start storing the
`spec_version` and `impl_version` the last runtime upgrade was applied.

This scheme has multiple advantages:
- We don't need to make sure that runtime upgrade was set.
- This will work in the future when we want to test a runtime upgrade,
because the `on_runtime_upgrade` will be executed automatically when the
runtime changes.

* Move `LAST_RUNTIME_UPGRADE` key to `frame-executive`

* Add some more documentation

* Make sure `spec_version` always increases between runtime upgrades

* Fix test

* Upgrade `parity-multiaddr` to fix compilation

* Also check if the `spec_name` changed

* Remove `RuntimeUpgraded` storage entry

* Don't run on genesis

substrate/frame/executive/src/lib.rs

@@ -75,10 +75,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use sp_std::{prelude::*, marker::PhantomData};
-use frame_support::{
-	storage::StorageValue,
-	weights::{GetDispatchInfo, WeighBlock, DispatchInfo}
-};
+use frame_support::{storage::StorageValue, weights::{GetDispatchInfo, WeighBlock, DispatchInfo}};
 use sp_runtime::{
 	generic::Digest, ApplyExtrinsicResult,
 	traits::{
@@ -179,7 +176,9 @@ where
 		extrinsics_root: &System::Hash,
 		digest: &Digest<System::Hash>,
 	) {
-		if frame_system::RuntimeUpgraded::take() {
+		if Self::runtime_upgraded() {
+			// System is not part of `AllModules`, so we need to call this manually.
+			<frame_system::Module::<System> as OnRuntimeUpgrade>::on_runtime_upgrade();
 			<AllModules as OnRuntimeUpgrade>::on_runtime_upgrade();
 			<frame_system::Module<System>>::register_extra_weight_unchecked(
 				<AllModules as WeighBlock<System::BlockNumber>>::on_runtime_upgrade()
@@ -201,6 +200,21 @@ where
 		);
 	}
 
+	/// Returns if the runtime was upgraded since the last time this function was called.
+	fn runtime_upgraded() -> bool {
+		let last = frame_system::LastRuntimeUpgrade::get();
+		let current = <System::Version as frame_support::traits::Get<_>>::get();
+
+		if last.map(|v| v.was_upgraded(&current)).unwrap_or(true) {
+			frame_system::LastRuntimeUpgrade::put(
+				frame_system::LastRuntimeUpgradeInfo::from(current),
+			);
+			true
+		} else {
+			false
+		}
+	}
+
 	fn initial_checks(block: &Block) {
 		let header = block.header();
 
@@ -376,7 +390,7 @@ mod tests {
 		weights::Weight,
 		traits::{Currency, LockIdentifier, LockableCurrency, WithdrawReasons, WithdrawReason},
 	};
-	use frame_system::{self as system, Call as SystemCall, ChainContext};
+	use frame_system::{self as system, Call as SystemCall, ChainContext, LastRuntimeUpgradeInfo};
 	use pallet_balances::Call as BalancesCall;
 	use hex_literal::hex;
 
@@ -461,7 +475,7 @@ mod tests {
 		type MaximumBlockWeight = MaximumBlockWeight;
 		type AvailableBlockRatio = AvailableBlockRatio;
 		type MaximumBlockLength = MaximumBlockLength;
-		type Version = ();
+		type Version = RuntimeVersion;
 		type ModuleToIndex = ();
 		type AccountData = pallet_balances::AccountData<u64>;
 		type OnNewAccount = ();
@@ -507,6 +521,18 @@ mod tests {
 		}
 	}
 
+	pub struct RuntimeVersion;
+	impl frame_support::traits::Get<sp_version::RuntimeVersion> for RuntimeVersion {
+		fn get() -> sp_version::RuntimeVersion {
+			RUNTIME_VERSION.with(|v| v.borrow().clone())
+		}
+	}
+
+	thread_local! {
+		pub static RUNTIME_VERSION: std::cell::RefCell<sp_version::RuntimeVersion> =
+			Default::default();
+	}
+
 	type SignedExtra = (
 		frame_system::CheckEra<Runtime>,
 		frame_system::CheckNonce<Runtime>,
@@ -569,7 +595,7 @@ mod tests {
 				header: Header {
 					parent_hash: [69u8; 32].into(),
 					number: 1,
-					state_root: hex!("8a22606e925c39bb0c8e8f6f5871c0aceab88a2fcff6b2d92660af8f6daff0b1").into(),
+					state_root: hex!("e97d724f480f6e3215bd5c24b9ba51250e2514ac1c99e563fd77bfb9d6100b1c").into(),
 					extrinsics_root: hex!("03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314").into(),
 					digest: Digest { logs: vec![], },
 				},
@@ -759,4 +785,76 @@ mod tests {
 			assert_eq!(<frame_system::Module<Runtime>>::all_extrinsics_weight(), 150 + 25);
 		})
 	}
+
+	#[test]
+	fn runtime_upgraded_should_work() {
+		new_test_ext(1).execute_with(|| {
+			RUNTIME_VERSION.with(|v| *v.borrow_mut() = Default::default());
+			// It should be added at genesis
+			assert!(frame_system::LastRuntimeUpgrade::exists());
+			assert!(!Executive::runtime_upgraded());
+
+			RUNTIME_VERSION.with(|v| *v.borrow_mut() = sp_version::RuntimeVersion {
+				spec_version: 1,
+				..Default::default()
+			});
+			assert!(Executive::runtime_upgraded());
+			assert_eq!(
+				Some(LastRuntimeUpgradeInfo { spec_version: 1.into(), spec_name: "".into() }),
+				frame_system::LastRuntimeUpgrade::get(),
+			);
+
+			RUNTIME_VERSION.with(|v| *v.borrow_mut() = sp_version::RuntimeVersion {
+				spec_version: 1,
+				spec_name: "test".into(),
+				..Default::default()
+			});
+			assert!(Executive::runtime_upgraded());
+			assert_eq!(
+				Some(LastRuntimeUpgradeInfo { spec_version: 1.into(), spec_name: "test".into() }),
+				frame_system::LastRuntimeUpgrade::get(),
+			);
+
+			RUNTIME_VERSION.with(|v| *v.borrow_mut() = sp_version::RuntimeVersion {
+				spec_version: 1,
+				spec_name: "test".into(),
+				impl_version: 2,
+				..Default::default()
+			});
+			assert!(!Executive::runtime_upgraded());
+
+			frame_system::LastRuntimeUpgrade::take();
+			assert!(Executive::runtime_upgraded());
+			assert_eq!(
+				Some(LastRuntimeUpgradeInfo { spec_version: 1.into(), spec_name: "test".into() }),
+				frame_system::LastRuntimeUpgrade::get(),
+			);
+		})
+	}
+
+	#[test]
+	fn last_runtime_upgrade_was_upgraded_works() {
+		let test_data = vec![
+			(0, "", 1, "", true),
+			(1, "", 1, "", false),
+			(1, "", 1, "test", true),
+			(1, "", 0, "", false),
+			(1, "", 0, "test", true),
+		];
+
+		for (spec_version, spec_name, c_spec_version, c_spec_name, result) in test_data {
+			let current = sp_version::RuntimeVersion {
+				spec_version: c_spec_version,
+				spec_name: c_spec_name.into(),
+				..Default::default()
+			};
+
+			let last = LastRuntimeUpgradeInfo {
+				spec_version: spec_version.into(),
+				spec_name: spec_name.into(),
+			};
+
+			assert_eq!(result, last.was_upgraded(&current));
+		}
+	}
 }