initializer.rs 11.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
23
// 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::*;
use frame_support::weights::Weight;
asynchronous rob's avatar
asynchronous rob committed
24
use primitives::v1::ValidatorId;
25
use frame_support::{
26
	decl_storage, decl_module, decl_error, traits::{OneSessionHandler, Randomness},
27
};
28
use parity_scale_codec::{Encode, Decode};
29
30
use crate::{
	configuration::{self, HostConfiguration},
31
	paras, scheduler, inclusion, session_info, dmp, ump, hrmp,
32
};
asynchronous rob's avatar
asynchronous rob committed
33
34

/// Information about a session change that has just occurred.
35
#[derive(Clone)]
asynchronous rob's avatar
asynchronous rob committed
36
37
38
39
40
41
42
43
44
45
46
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
47
48
	/// New session index.
	pub session_index: sp_staking::SessionIndex,
asynchronous rob's avatar
asynchronous rob committed
49
}
50

51
52
53
54
55
56
57
58
59
60
61
62
63
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(),
		}
	}
}

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

71
72
73
74
75
76
77
78
79
80
pub trait Config:
	frame_system::Config
	+ configuration::Config
	+ paras::Config
	+ scheduler::Config
	+ inclusion::Config
	+ session_info::Config
	+ dmp::Config
	+ ump::Config
	+ hrmp::Config
asynchronous rob's avatar
asynchronous rob committed
81
{
asynchronous rob's avatar
asynchronous rob committed
82
83
84
	/// A randomness beacon.
	type Randomness: Randomness<Self::Hash>;
}
85
86

decl_storage! {
87
	trait Store for Module<T: Config> as Initializer {
88
89
90
91
92
93
94
95
96
		/// 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.
		HasInitialized: Option<()>;
97
98
		/// Buffered session changes along with the block number at which they should be applied.
		///
99
100
		/// Typically this will be empty or one element long. Apart from that this item never hits
		/// the storage.
101
102
103
		///
		/// However this is a `Vec` regardless to handle various edge cases that may occur at runtime
		/// upgrade boundaries or if governance intervenes.
104
		BufferedSessionChanges: Vec<BufferedSessionChange>;
105
106
107
108
	}
}

decl_error! {
109
	pub enum Error for Module<T: Config> { }
110
111
112
113
}

decl_module! {
	/// The initializer module.
114
	pub struct Module<T: Config> for enum Call where origin: <T as frame_system::Config>::Origin {
115
116
117
118
119
120
121
122
		type Error = Error<T>;

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

			HasInitialized::set(Some(()));

			total_weight
		}

		fn on_finalize() {
asynchronous rob's avatar
asynchronous rob committed
143
			// reverse initialization order.
144
145
146
			hrmp::Module::<T>::initializer_finalize();
			ump::Module::<T>::initializer_finalize();
			dmp::Module::<T>::initializer_finalize();
147
			session_info::Module::<T>::initializer_finalize();
asynchronous rob's avatar
asynchronous rob committed
148
			inclusion::Module::<T>::initializer_finalize();
asynchronous rob's avatar
asynchronous rob committed
149
			scheduler::Module::<T>::initializer_finalize();
150
151
			paras::Module::<T>::initializer_finalize();
			configuration::Module::<T>::initializer_finalize();
152
153
154
155
156
157
158
159
160
161
162
163
164
165

			// 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,
			}) = BufferedSessionChanges::take().pop()
			{
				Self::apply_new_session(session_index, validators, queued);
			}

166
167
168
169
170
			HasInitialized::take();
		}
	}
}

171
impl<T: Config> Module<T> {
172
	fn apply_new_session(
asynchronous rob's avatar
asynchronous rob committed
173
		session_index: sp_staking::SessionIndex,
174
175
176
		validators: Vec<ValidatorId>,
		queued: Vec<ValidatorId>,
	) {
asynchronous rob's avatar
asynchronous rob committed
177
178
179
180
181
182
183
184
185
186
187
188
		let prev_config = <configuration::Module<T>>::config();

		let random_seed = {
			let mut buf = [0u8; 32];
			let random_hash = T::Randomness::random(&b"paras"[..]);
			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.
189
		configuration::Module::<T>::initializer_on_new_session(&validators, &queued);
asynchronous rob's avatar
asynchronous rob committed
190
191
192
193
194
195
196
197
198

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

		let notification = SessionChangeNotification {
			validators,
			queued,
			prev_config,
			new_config,
			random_seed,
asynchronous rob's avatar
asynchronous rob committed
199
			session_index,
asynchronous rob's avatar
asynchronous rob committed
200
201
		};

202
		let outgoing_paras = paras::Module::<T>::initializer_on_new_session(&notification);
asynchronous rob's avatar
asynchronous rob committed
203
		scheduler::Module::<T>::initializer_on_new_session(&notification);
asynchronous rob's avatar
asynchronous rob committed
204
		inclusion::Module::<T>::initializer_on_new_session(&notification);
205
		session_info::Module::<T>::initializer_on_new_session(&notification);
206
207
208
		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);
209
	}
210
211

	/// Should be called when a new session occurs. Buffers the session notification to be applied
212
	/// at the end of the block. If `queued` is `None`, the `validators` are considered queued.
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
	fn on_new_session<'a, I: 'a>(
		_changed: bool,
		session_index: sp_staking::SessionIndex,
		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()
		};

228
		BufferedSessionChanges::mutate(|v| v.push(BufferedSessionChange {
229
230
231
232
233
			validators,
			queued,
			session_index,
		}));
	}
234
235
}

236
impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Module<T> {
237
238
239
	type Public = ValidatorId;
}

240
impl<T: pallet_session::Config + Config> OneSessionHandler<T::AccountId> for Module<T> {
241
242
243
244
245
246
247
248
249
250
251
	type Key = ValidatorId;

	fn on_genesis_session<'a, I: 'a>(_validators: I)
		where I: Iterator<Item=(&'a T::AccountId, Self::Key)>
	{

	}

	fn on_new_session<'a, I: 'a>(changed: bool, validators: I, queued: I)
		where I: Iterator<Item=(&'a T::AccountId, Self::Key)>
	{
252
		let session_index = <pallet_session::Module<T>>::current_index();
asynchronous rob's avatar
asynchronous rob committed
253
		<Module<T>>::on_new_session(changed, session_index, validators, Some(queued));
254
255
256
257
258
259
260
261
	}

	fn on_disabled(_i: usize) { }
}

#[cfg(test)]
mod tests {
	use super::*;
262
263
264
265
266
	use primitives::v1::{Id as ParaId};
	use crate::mock::{
		new_test_ext,
		Initializer, System, Dmp, Paras, Configuration, MockGenesisConfig,
	};
267

268
269
270
271
	use frame_support::{
		assert_ok,
		traits::{OnFinalize, OnInitialize},
	};
272
273

	#[test]
274
275
276
277
278
279
280
281
282
283
284
285
	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);

286
			let v = <BufferedSessionChanges>::get();
287
288
289
290
291
			assert_eq!(v.len(), 1);
		});
	}

	#[test]
292
	fn session_change_applied_on_finalize() {
293
294
		new_test_ext(Default::default()).execute_with(|| {
			Initializer::on_initialize(1);
asynchronous rob's avatar
asynchronous rob committed
295
296
297
298
299
300
			Initializer::on_new_session(
				false,
				1,
				Vec::new().into_iter(),
				Some(Vec::new().into_iter()),
			);
301

302
			Initializer::on_finalize(1);
303

304
			assert!(<BufferedSessionChanges>::get().is_empty());
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
		});
	}

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

			assert!(HasInitialized::get().is_some());
		})
	}

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

			assert!(HasInitialized::get().is_none());
		})
	}
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373

	#[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]));

			Paras::schedule_para_cleanup(a);
			Paras::schedule_para_cleanup(b);

			Initializer::apply_new_session(1, vec![], vec![]);

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