diff --git a/polkadot/runtime/common/src/paras_sudo_wrapper.rs b/polkadot/runtime/common/src/paras_sudo_wrapper.rs index d165123b42..80f64bf171 100644 --- a/polkadot/runtime/common/src/paras_sudo_wrapper.rs +++ b/polkadot/runtime/common/src/paras_sudo_wrapper.rs @@ -22,14 +22,14 @@ use frame_support::{ weights::DispatchClass, }; use frame_system::ensure_root; -use runtime_parachains::paras::{ - self, - ParaGenesisArgs, +use runtime_parachains::{ + router, + paras::{self, ParaGenesisArgs}, }; use primitives::v1::Id as ParaId; /// The module's configuration trait. -pub trait Trait: paras::Trait { } +pub trait Trait: paras::Trait + router::Trait { } decl_error! { pub enum Error for Module { } @@ -57,6 +57,7 @@ decl_module! { pub fn sudo_schedule_para_cleanup(origin, id: ParaId) -> DispatchResult { ensure_root(origin)?; paras::Module::::schedule_para_cleanup(id); + router::Module::::schedule_para_cleanup(id); Ok(()) } } diff --git a/polkadot/runtime/parachains/src/initializer.rs b/polkadot/runtime/parachains/src/initializer.rs index 11481e7ffd..8e2e88ff59 100644 --- a/polkadot/runtime/parachains/src/initializer.rs +++ b/polkadot/runtime/parachains/src/initializer.rs @@ -27,7 +27,10 @@ use frame_support::{ }; use sp_runtime::traits::One; use codec::{Encode, Decode}; -use crate::{configuration::{self, HostConfiguration}, paras, scheduler, inclusion}; +use crate::{ + configuration::{self, HostConfiguration}, + paras, router, scheduler, inclusion, +}; /// Information about a session change that has just occurred. #[derive(Default, Clone)] @@ -55,7 +58,12 @@ struct BufferedSessionChange { } pub trait Trait: - frame_system::Trait + configuration::Trait + paras::Trait + scheduler::Trait + inclusion::Trait + frame_system::Trait + + configuration::Trait + + paras::Trait + + scheduler::Trait + + inclusion::Trait + + router::Trait { /// A randomness beacon. type Randomness: Randomness; @@ -114,10 +122,12 @@ decl_module! { // - Scheduler // - Inclusion // - Validity + // - Router let total_weight = configuration::Module::::initializer_initialize(now) + paras::Module::::initializer_initialize(now) + scheduler::Module::::initializer_initialize(now) + - inclusion::Module::::initializer_initialize(now); + inclusion::Module::::initializer_initialize(now) + + router::Module::::initializer_initialize(now); HasInitialized::set(Some(())); @@ -127,6 +137,7 @@ decl_module! { fn on_finalize() { // reverse initialization order. + router::Module::::initializer_finalize(); inclusion::Module::::initializer_finalize(); scheduler::Module::::initializer_finalize(); paras::Module::::initializer_finalize(); @@ -170,6 +181,7 @@ impl Module { paras::Module::::initializer_on_new_session(¬ification); scheduler::Module::::initializer_on_new_session(¬ification); inclusion::Module::::initializer_on_new_session(¬ification); + router::Module::::initializer_on_new_session(¬ification); } /// Should be called when a new session occurs. Buffers the session notification to be applied diff --git a/polkadot/runtime/parachains/src/lib.rs b/polkadot/runtime/parachains/src/lib.rs index b707c3e39e..382e6a645d 100644 --- a/polkadot/runtime/parachains/src/lib.rs +++ b/polkadot/runtime/parachains/src/lib.rs @@ -20,7 +20,6 @@ //! particular the `Initializer` module, as it is responsible for initializing the state //! of the other modules. - #![cfg_attr(not(feature = "std"), no_std)] use sp_std::result; @@ -33,6 +32,7 @@ pub mod inclusion; pub mod inclusion_inherent; pub mod initializer; pub mod paras; +pub mod router; pub mod scheduler; pub mod validity; diff --git a/polkadot/runtime/parachains/src/mock.rs b/polkadot/runtime/parachains/src/mock.rs index 7001b1c1df..59e494091e 100644 --- a/polkadot/runtime/parachains/src/mock.rs +++ b/polkadot/runtime/parachains/src/mock.rs @@ -103,6 +103,8 @@ impl crate::configuration::Trait for Test { } impl crate::paras::Trait for Test { } +impl crate::router::Trait for Test { } + impl crate::scheduler::Trait for Test { } impl crate::inclusion::Trait for Test { @@ -120,6 +122,11 @@ pub type Configuration = crate::configuration::Module; /// Mocked paras. pub type Paras = crate::paras::Module; +/// Mocked router. +// TODO: Will be used in the follow ups. +#[allow(dead_code)] +pub type Router = crate::router::Module; + /// Mocked scheduler. pub type Scheduler = crate::scheduler::Module; diff --git a/polkadot/runtime/parachains/src/router.rs b/polkadot/runtime/parachains/src/router.rs new file mode 100644 index 0000000000..e066bbbafc --- /dev/null +++ b/polkadot/runtime/parachains/src/router.rs @@ -0,0 +1,80 @@ +// 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 . + +//! The router module is responsible for handling messaging. +//! +//! The core of the messaging is checking and processing messages sent out by the candidates, +//! routing the messages at their destinations and informing the parachains about the incoming +//! messages. + +use crate::{configuration, initializer}; +use sp_std::prelude::*; +use frame_support::{decl_error, decl_module, decl_storage, weights::Weight}; +use primitives::v1::{Id as ParaId}; + +pub trait Trait: frame_system::Trait + configuration::Trait {} + +decl_storage! { + trait Store for Module as Router { + /// Paras that are to be cleaned up at the end of the session. + /// The entries are sorted ascending by the para id. + OutgoingParas: Vec; + } +} + +decl_error! { + pub enum Error for Module { } +} + +decl_module! { + /// The router module. + pub struct Module for enum Call where origin: ::Origin { + type Error = Error; + } +} + +impl Module { + /// Block initialization logic, called by initializer. + pub(crate) fn initializer_initialize(_now: T::BlockNumber) -> Weight { + 0 + } + + /// Block finalization logic, called by initializer. + pub(crate) fn initializer_finalize() {} + + /// Called by the initializer to note that a new session has started. + pub(crate) fn initializer_on_new_session( + _notification: &initializer::SessionChangeNotification, + ) { + let outgoing = OutgoingParas::take(); + for _outgoing_para in outgoing { + + } + } + + /// Schedule a para to be cleaned up at the start of the next session. + pub fn schedule_para_cleanup(id: ParaId) { + OutgoingParas::mutate(|v| { + if let Err(i) = v.binary_search(&id) { + v.insert(i, id); + } + }); + } +} + +#[cfg(test)] +mod tests { +} diff --git a/polkadot/runtime/rococo-v1/src/lib.rs b/polkadot/runtime/rococo-v1/src/lib.rs index 05fb261784..656f888ece 100644 --- a/polkadot/runtime/rococo-v1/src/lib.rs +++ b/polkadot/runtime/rococo-v1/src/lib.rs @@ -68,6 +68,7 @@ use runtime_parachains::inclusion as parachains_inclusion; use runtime_parachains::inclusion_inherent as parachains_inclusion_inherent; use runtime_parachains::initializer as parachains_initializer; use runtime_parachains::paras as parachains_paras; +use runtime_parachains::router as parachains_router; use runtime_parachains::scheduler as parachains_scheduler; pub use pallet_balances::Call as BalancesCall; @@ -371,6 +372,7 @@ construct_runtime! { Scheduler: parachains_scheduler::{Module, Call, Storage}, Paras: parachains_paras::{Module, Call, Storage}, Initializer: parachains_initializer::{Module, Call, Storage}, + Router: parachains_router::{Module, Call, Storage}, ParasSudoWrapper: paras_sudo_wrapper::{Module, Call}, } @@ -721,6 +723,8 @@ impl parachains_inclusion::Trait for Runtime { impl parachains_paras::Trait for Runtime { } +impl parachains_router::Trait for Runtime { } + impl parachains_inclusion_inherent::Trait for Runtime { } impl parachains_scheduler::Trait for Runtime { }