initializer.rs 13.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Copyright 2020 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/>.

//! This module is responsible for maintaining a consistent initialization order for all other
//! parachains modules. It's also responsible for finalization and session change notifications.
//!
//! This module can throw fatal errors if session-change notifications are received after initialization.

use sp_std::prelude::*;
23
use primitives::v1::{ValidatorId, SessionIndex, ConsensusLog, BlockNumber};
24
use frame_support::traits::{Randomness, OneSessionHandler};
25
use parity_scale_codec::{Encode, Decode};
26
27
use crate::{
	configuration::{self, HostConfiguration},
28
	shared, paras, scheduler, inclusion, session_info, dmp, ump, hrmp,
29
};
asynchronous rob's avatar
asynchronous rob committed
30

31
32
pub use pallet::*;

asynchronous rob's avatar
asynchronous rob committed
33
/// Information about a session change that has just occurred.
34
#[derive(Clone)]
asynchronous rob's avatar
asynchronous rob committed
35
36
37
38
39
40
41
42
43
44
45
pub struct SessionChangeNotification<BlockNumber> {
	/// The new validators in the session.
	pub validators: Vec<ValidatorId>,
	/// The qeueud validators for the following session.
	pub queued: Vec<ValidatorId>,
	/// The configuration before handling the session change
	pub prev_config: HostConfiguration<BlockNumber>,
	/// The configuration after handling the session change.
	pub new_config: HostConfiguration<BlockNumber>,
	/// A secure random seed for the session, gathered from BABE.
	pub random_seed: [u8; 32],
asynchronous rob's avatar
asynchronous rob committed
46
	/// New session index.
47
	pub session_index: SessionIndex,
asynchronous rob's avatar
asynchronous rob committed
48
}
49

50
51
52
53
54
55
56
57
58
59
60
61
62
impl<BlockNumber: Default + From<u32>> Default for SessionChangeNotification<BlockNumber> {
	fn default() -> Self {
		Self {
			validators: Vec::new(),
			queued: Vec::new(),
			prev_config: HostConfiguration::default(),
			new_config: HostConfiguration::default(),
			random_seed: Default::default(),
			session_index: Default::default(),
		}
	}
}

63
#[derive(Encode, Decode)]
64
struct BufferedSessionChange {
65
66
	validators: Vec<ValidatorId>,
	queued: Vec<ValidatorId>,
67
	session_index: SessionIndex,
68
69
}

70
71
72
73
74
#[frame_support::pallet]
pub mod pallet {
	use frame_support::pallet_prelude::*;
	use frame_system::pallet_prelude::*;
	use super::*;
75

76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
	#[pallet::pallet]
	#[pallet::generate_store(pub(super) trait Store)]
	pub struct Pallet<T>(_);

	#[pallet::config]
	pub trait Config:
		frame_system::Config
		+ configuration::Config
		+ shared::Config
		+ paras::Config
		+ scheduler::Config
		+ inclusion::Config
		+ session_info::Config
		+ dmp::Config
		+ ump::Config
		+ hrmp::Config
	{
		/// A randomness beacon.
		type Randomness: Randomness<Self::Hash, Self::BlockNumber>;
		/// An origin which is allowed to force updates to parachains.
		type ForceOrigin: EnsureOrigin<<Self as frame_system::Config>::Origin>;
97
98
99
	}


100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
	/// Whether the parachains modules have been initialized within this block.
	///
	/// Semantically a bool, but this guarantees it should never hit the trie,
	/// as this is cleared in `on_finalize` and Frame optimizes `None` values to be empty values.
	///
	/// As a bool, `set(false)` and `remove()` both lead to the next `get()` being false, but one of
	/// them writes to the trie and one does not. This confusion makes `Option<()>` more suitable for
	/// the semantics of this variable.
	#[pallet::storage]
	pub(super) type HasInitialized<T: Config> = StorageValue<_, ()>;

	/// Buffered session changes along with the block number at which they should be applied.
	///
	/// Typically this will be empty or one element long. Apart from that this item never hits
	/// the storage.
	///
	/// However this is a `Vec` regardless to handle various edge cases that may occur at runtime
	/// upgrade boundaries or if governance intervenes.
	#[pallet::storage]
	pub(super) type BufferedSessionChanges<T: Config> = StorageValue<_, Vec<BufferedSessionChange>, ValueQuery>;

	#[pallet::hooks]
	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
123
124
125
126
127
128
		fn on_initialize(now: T::BlockNumber) -> Weight {
			// The other modules are initialized in this order:
			// - Configuration
			// - Paras
			// - Scheduler
			// - Inclusion
129
			// - SessionInfo
130
			// - Validity
131
132
133
			// - DMP
			// - UMP
			// - HRMP
134
			let total_weight = configuration::Module::<T>::initializer_initialize(now) +
135
				shared::Module::<T>::initializer_initialize(now) +
ferrell-code's avatar
ferrell-code committed
136
				paras::Pallet::<T>::initializer_initialize(now) +
asynchronous rob's avatar
asynchronous rob committed
137
				scheduler::Module::<T>::initializer_initialize(now) +
138
				inclusion::Module::<T>::initializer_initialize(now) +
139
				session_info::Module::<T>::initializer_initialize(now) +
140
141
142
				dmp::Module::<T>::initializer_initialize(now) +
				ump::Module::<T>::initializer_initialize(now) +
				hrmp::Module::<T>::initializer_initialize(now);
143

144
			HasInitialized::<T>::set(Some(()));
145
146
147
148

			total_weight
		}

149
		fn on_finalize(_: T::BlockNumber) {
asynchronous rob's avatar
asynchronous rob committed
150
			// reverse initialization order.
151
152
153
			hrmp::Module::<T>::initializer_finalize();
			ump::Module::<T>::initializer_finalize();
			dmp::Module::<T>::initializer_finalize();
154
			session_info::Module::<T>::initializer_finalize();
asynchronous rob's avatar
asynchronous rob committed
155
			inclusion::Module::<T>::initializer_finalize();
asynchronous rob's avatar
asynchronous rob committed
156
			scheduler::Module::<T>::initializer_finalize();
ferrell-code's avatar
ferrell-code committed
157
			paras::Pallet::<T>::initializer_finalize();
158
			shared::Module::<T>::initializer_finalize();
159
			configuration::Module::<T>::initializer_finalize();
160
161
162
163
164
165
166
167
168

			// Apply buffered session changes as the last thing. This way the runtime APIs and the
			// next block will observe the next session.
			//
			// Note that we only apply the last session as all others lasted less than a block (weirdly).
			if let Some(BufferedSessionChange {
				session_index,
				validators,
				queued,
169
			}) = BufferedSessionChanges::<T>::take().pop()
170
171
172
173
			{
				Self::apply_new_session(session_index, validators, queued);
			}

174
			HasInitialized::<T>::take();
175
		}
176
	}
177

178
179
	#[pallet::call]
	impl<T: Config> Pallet<T> {
180
181
182
		/// Issue a signal to the consensus engine to forcibly act as though all parachain
		/// blocks in all relay chain blocks up to and including the given number in the current
		/// chain are valid and should be finalized.
183
184
		#[pallet::weight((0, DispatchClass::Operational))]
		pub fn force_approve(origin: OriginFor<T>, up_to: BlockNumber) -> DispatchResult {
185
186
187
			T::ForceOrigin::ensure_origin(origin)?;

			frame_system::Pallet::<T>::deposit_log(ConsensusLog::ForceApprove(up_to).into());
188
			Ok(())
189
		}
190
191
192
	}
}

193
impl<T: Config> Pallet<T> {
194
	fn apply_new_session(
195
		session_index: SessionIndex,
196
		all_validators: Vec<ValidatorId>,
197
198
		queued: Vec<ValidatorId>,
	) {
asynchronous rob's avatar
asynchronous rob committed
199
200
201
202
		let prev_config = <configuration::Module<T>>::config();

		let random_seed = {
			let mut buf = [0u8; 32];
203
204
205
			// TODO: audit usage of randomness API
			// https://github.com/paritytech/polkadot/issues/2601
			let (random_hash, _) = T::Randomness::random(&b"paras"[..]);
asynchronous rob's avatar
asynchronous rob committed
206
207
208
209
210
211
212
			let len = sp_std::cmp::min(32, random_hash.as_ref().len());
			buf[..len].copy_from_slice(&random_hash.as_ref()[..len]);
			buf
		};

		// We can't pass the new config into the thing that determines the new config,
		// so we don't pass the `SessionChangeNotification` into this module.
213
		configuration::Module::<T>::initializer_on_new_session(&session_index);
asynchronous rob's avatar
asynchronous rob committed
214
215
216

		let new_config = <configuration::Module<T>>::config();

217
218
219
220
221
222
223
		let validators = shared::Module::<T>::initializer_on_new_session(
			session_index,
			random_seed.clone(),
			&new_config,
			all_validators,
		);

asynchronous rob's avatar
asynchronous rob committed
224
225
226
227
228
229
		let notification = SessionChangeNotification {
			validators,
			queued,
			prev_config,
			new_config,
			random_seed,
asynchronous rob's avatar
asynchronous rob committed
230
			session_index,
asynchronous rob's avatar
asynchronous rob committed
231
232
		};

ferrell-code's avatar
ferrell-code committed
233
		let outgoing_paras = paras::Pallet::<T>::initializer_on_new_session(&notification);
asynchronous rob's avatar
asynchronous rob committed
234
		scheduler::Module::<T>::initializer_on_new_session(&notification);
asynchronous rob's avatar
asynchronous rob committed
235
		inclusion::Module::<T>::initializer_on_new_session(&notification);
236
		session_info::Module::<T>::initializer_on_new_session(&notification);
237
238
239
		dmp::Module::<T>::initializer_on_new_session(&notification, &outgoing_paras);
		ump::Module::<T>::initializer_on_new_session(&notification, &outgoing_paras);
		hrmp::Module::<T>::initializer_on_new_session(&notification, &outgoing_paras);
240
	}
241
242

	/// Should be called when a new session occurs. Buffers the session notification to be applied
243
	/// at the end of the block. If `queued` is `None`, the `validators` are considered queued.
244
245
	fn on_new_session<'a, I: 'a>(
		_changed: bool,
246
		session_index: SessionIndex,
247
248
249
250
251
252
253
254
255
256
257
258
		validators: I,
		queued: Option<I>,
	)
		where I: Iterator<Item=(&'a T::AccountId, ValidatorId)>
	{
		let validators: Vec<_> = validators.map(|(_, v)| v).collect();
		let queued: Vec<_> = if let Some(queued) = queued {
			queued.map(|(_, v)| v).collect()
		} else {
			validators.clone()
		};

259
260
261
262
		if session_index == 0 {
			// Genesis session should be immediately enacted.
			Self::apply_new_session(0, validators, queued);
		} else {
263
			BufferedSessionChanges::<T>::mutate(|v| v.push(BufferedSessionChange {
264
265
266
267
268
269
				validators,
				queued,
				session_index,
			}));
		}

270
	}
271
272
}

273
impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {
274
275
276
	type Public = ValidatorId;
}

277
impl<T: pallet_session::Config + Config> OneSessionHandler<T::AccountId> for Pallet<T> {
278
279
	type Key = ValidatorId;

280
	fn on_genesis_session<'a, I: 'a>(validators: I)
281
282
		where I: Iterator<Item=(&'a T::AccountId, Self::Key)>
	{
283
		<Pallet<T>>::on_new_session(false, 0, validators, None);
284
285
286
287
288
	}

	fn on_new_session<'a, I: 'a>(changed: bool, validators: I, queued: I)
		where I: Iterator<Item=(&'a T::AccountId, Self::Key)>
	{
289
290
		let session_index = <pallet_session::Pallet<T>>::current_index();
		<Pallet<T>>::on_new_session(changed, session_index, validators, Some(queued));
291
292
293
294
295
296
297
298
	}

	fn on_disabled(_i: usize) { }
}

#[cfg(test)]
mod tests {
	use super::*;
299
300
301
	use primitives::v1::{Id as ParaId};
	use crate::mock::{
		new_test_ext,
302
		Initializer, System, Dmp, Paras, Configuration, SessionInfo, MockGenesisConfig,
303
	};
304

305
306
307
308
	use frame_support::{
		assert_ok,
		traits::{OnFinalize, OnInitialize},
	};
309

310
311
312
313
314
315
316
317
318
319
	#[test]
	fn session_0_is_instantly_applied() {
		new_test_ext(Default::default()).execute_with(|| {
			Initializer::on_new_session(
				false,
				0,
				Vec::new().into_iter(),
				Some(Vec::new().into_iter()),
			);

320
			let v = <Initializer as Store>::BufferedSessionChanges::get();
321
322
323
324
325
326
327
			assert!(v.is_empty());

			assert_eq!(SessionInfo::earliest_stored_session(), 0);
			assert!(SessionInfo::session_info(0).is_some());
		});
	}

328
	#[test]
329
330
331
332
333
334
335
336
337
338
339
340
	fn session_change_before_initialize_is_still_buffered_after() {
		new_test_ext(Default::default()).execute_with(|| {
			Initializer::on_new_session(
				false,
				1,
				Vec::new().into_iter(),
				Some(Vec::new().into_iter()),
			);

			let now = System::block_number();
			Initializer::on_initialize(now);

341
			let v = <Initializer as Store>::BufferedSessionChanges::get();
342
343
344
345
346
			assert_eq!(v.len(), 1);
		});
	}

	#[test]
347
	fn session_change_applied_on_finalize() {
348
349
		new_test_ext(Default::default()).execute_with(|| {
			Initializer::on_initialize(1);
asynchronous rob's avatar
asynchronous rob committed
350
351
352
353
354
355
			Initializer::on_new_session(
				false,
				1,
				Vec::new().into_iter(),
				Some(Vec::new().into_iter()),
			);
356

357
			Initializer::on_finalize(1);
358

359
			assert!(<Initializer as Store>::BufferedSessionChanges::get().is_empty());
360
361
362
363
364
365
366
367
		});
	}

	#[test]
	fn sets_flag_on_initialize() {
		new_test_ext(Default::default()).execute_with(|| {
			Initializer::on_initialize(1);

368
			assert!(<Initializer as Store>::HasInitialized::get().is_some());
369
370
371
372
373
374
375
376
377
		})
	}

	#[test]
	fn clears_flag_on_finalize() {
		new_test_ext(Default::default()).execute_with(|| {
			Initializer::on_initialize(1);
			Initializer::on_finalize(1);

378
			assert!(<Initializer as Store>::HasInitialized::get().is_none());
379
380
		})
	}
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418

	#[test]
	fn scheduled_cleanup_performed() {
		let a = ParaId::from(1312);
		let b = ParaId::from(228);
		let c = ParaId::from(123);

		let mock_genesis = crate::paras::ParaGenesisArgs {
			parachain: true,
			genesis_head: Default::default(),
			validation_code: Default::default(),
		};

		new_test_ext(
			MockGenesisConfig {
				configuration: crate::configuration::GenesisConfig {
					config: crate::configuration::HostConfiguration {
						max_downward_message_size: 1024,
						..Default::default()
					},
				},
				paras: crate::paras::GenesisConfig {
					paras: vec![
						(a, mock_genesis.clone()),
						(b, mock_genesis.clone()),
						(c, mock_genesis.clone()),
					],
					..Default::default()
				},
				..Default::default()
			}
		).execute_with(|| {

			// enqueue downward messages to A, B and C.
			assert_ok!(Dmp::queue_downward_message(&Configuration::config(), a, vec![1, 2, 3]));
			assert_ok!(Dmp::queue_downward_message(&Configuration::config(), b, vec![4, 5, 6]));
			assert_ok!(Dmp::queue_downward_message(&Configuration::config(), c, vec![7, 8, 9]));

419
420
			assert_ok!(Paras::schedule_para_cleanup(a));
			assert_ok!(Paras::schedule_para_cleanup(b));
421

422
423
			// Apply session 2 in the future
			Initializer::apply_new_session(2, vec![], vec![]);
424
425
426
427
428
429

			assert!(Dmp::dmq_contents(a).is_empty());
			assert!(Dmp::dmq_contents(b).is_empty());
			assert!(!Dmp::dmq_contents(c).is_empty());
		});
	}
430
}