pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-05-06 02:08:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Allow specify schedule dispatch origin (#6387)

Browse Source 
* allow specify schedule dispatch origin

* fix tests

* use caller origin for scheduled

* fix tests

* line width

* check origin for cancel

* line width

* fix some issues for benchmarking

* fix doc test

* another way to constraint origin

* fix build issues

* fix cancel

* line width

* fix benchmarks

* bump version

* enable runtime upgrade

* add migration code and test

* Update frame/scheduler/src/lib.rs

Co-authored-by: Gavin Wood <github@gavwood.com>

* expose migration method

* add notes

* bump version

* remove on_runtime_upgrade

* fix test

Co-authored-by: Gavin Wood <github@gavwood.com>
This commit is contained in:
Xiliang Chen
2020-07-03 01:05:15 +12:00
committed by GitHub
parent 540ae1c161
commit e1d0f84c67
16 changed files with 510 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/scheduler/src/benchmarking.rs
+1
View File
@@ -44,6 +44,7 @@ fn fill_schedule<T: Trait> (when: T::BlockNumber, n: u32) -> Result<(), &'static
Some((T::BlockNumber::one(), 100)),
// HARD_DEADLINE priority means it gets executed no matter what
0,
frame_system::RawOrigin::Root.into(),
call.clone().into(),
)?;
}
substrate/frame/scheduler/src/lib.rs
+432 -114
View File
@@ -28,6 +28,14 @@
//! specified block number or at a specified period. These scheduled dispatches
//! may be named or anonymous and may be canceled.
//!
//! **NOTE:** The scheduled calls will be dispatched with the default filter
//! for the origin: namely `frame_system::Trait::BaseCallFilter` for all origin
//! except root which will get no filter. And not the filter contained in origin
//! use to call `fn schedule`.
//!
//! If a call is scheduled using proxy or whatever mecanism which adds filter,
//! then those filter will not be used when dispatching the schedule call.
//!
//! ## Interface
//!
//! ### Dispatchable Functions
@@ -45,16 +53,16 @@
mod benchmarking;
use sp_std::prelude::*;
use codec::{Encode, Decode};
use sp_runtime::{RuntimeDebug, traits::{Zero, One}};
use sp_std::{prelude::*, marker::PhantomData, borrow::Borrow};
use codec::{Encode, Decode, Codec};
use sp_runtime::{RuntimeDebug, traits::{Zero, One, BadOrigin}};
use frame_support::{
decl_module, decl_storage, decl_event, decl_error,
decl_module, decl_storage, decl_event, decl_error, IterableStorageMap,
dispatch::{Dispatchable, DispatchError, DispatchResult, Parameter},
traits::{Get, schedule},
traits::{Get, schedule, OriginTrait, EnsureOrigin, IsType},
weights::{GetDispatchInfo, Weight},
};
use frame_system::{self as system, ensure_root};
use frame_system::{self as system};
/// Our pallet's configuration trait. All our types and constants go in here. If the
/// pallet is dependent on specific other pallets, then their configuration traits
@@ -66,7 +74,11 @@ pub trait Trait: system::Trait {
type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
/// The aggregated origin which the dispatch will take.
type Origin: From<system::RawOrigin<Self::AccountId>>;
type Origin: OriginTrait<PalletsOrigin =
Self::PalletsOrigin> + From<Self::PalletsOrigin> + IsType<<Self as system::Trait>::Origin>;
/// The caller origin, overarching type of all pallets origins.
type PalletsOrigin: From<system::RawOrigin<Self::AccountId>> + Codec + Clone + Eq;
/// The aggregated call type.
type Call: Parameter + Dispatchable<Origin=<Self as Trait>::Origin> + GetDispatchInfo + From<system::Call<Self>>;
@@ -74,6 +86,9 @@ pub trait Trait: system::Trait {
/// The maximum weight that may be scheduled per block for any dispatchables of less priority
/// than `schedule::HARD_DEADLINE`.
type MaximumWeight: Get<Weight>;
/// Required origin to schedule or cancel calls.
type ScheduleOrigin: EnsureOrigin<<Self as system::Trait>::Origin>;
}
/// Just a simple index for naming period tasks.
@@ -81,9 +96,19 @@ pub type PeriodicIndex = u32;
/// The location of a scheduled task that can be used to remove it.
pub type TaskAddress<BlockNumber> = (BlockNumber, u32);
/// Information regarding an item to be executed in the future.
#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]
#[derive(Clone, RuntimeDebug, Encode, Decode)]
pub struct Scheduled<Call, BlockNumber> {
struct ScheduledV1<Call, BlockNumber> {
maybe_id: Option<Vec<u8>>,
priority: schedule::Priority,
call: Call,
maybe_periodic: Option<schedule::Period<BlockNumber>>,
}
/// Information regarding an item to be executed in the future.
#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]
#[derive(Clone, RuntimeDebug, Encode, Decode)]
pub struct ScheduledV2<Call, BlockNumber, PalletsOrigin, AccountId> {
/// The unique identity for this task, if there is one.
maybe_id: Option<Vec<u8>>,
/// This task's priority.
@@ -92,16 +117,42 @@ pub struct Scheduled<Call, BlockNumber> {
call: Call,
/// If the call is periodic, then this points to the information concerning that.
maybe_periodic: Option<schedule::Period<BlockNumber>>,
/// The origin to dispatch the call.
origin: PalletsOrigin,
_phantom: PhantomData<AccountId>,
}
/// The current version of Scheduled struct.
pub type Scheduled<Call, BlockNumber, PalletsOrigin, AccountId> = ScheduledV2<Call, BlockNumber, PalletsOrigin, AccountId>;
// A value placed in storage that represents the current version of the Scheduler storage.
// This value is used by the `on_runtime_upgrade` logic to determine whether we run
// storage migration logic.
#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug)]
enum Releases {
V1,
V2,
}
impl Default for Releases {
fn default() -> Self {
Releases::V1
}
}
decl_storage! {
trait Store for Module<T: Trait> as Scheduler {
/// Items to be executed, indexed by the block number that they should be executed on.
pub Agenda: map hasher(twox_64_concat) T::BlockNumber
=> Vec<Option<Scheduled<<T as Trait>::Call, T::BlockNumber>>>;
=> Vec<Option<Scheduled<<T as Trait>::Call, T::BlockNumber, T::PalletsOrigin, T::AccountId>>>;
/// Lookup from identity to the block number and index of the task.
Lookup: map hasher(twox_64_concat) Vec<u8> => Option<TaskAddress<T::BlockNumber>>;
/// Storage version of the pallet.
///
/// New networks start with last version.
StorageVersion build(|_| Releases::V2): Releases;
}
}
@@ -127,6 +178,7 @@ decl_error! {
decl_module! {
/// Scheduler module declaration.
pub struct Module<T: Trait> for enum Call where origin: <T as system::Trait>::Origin {
type Error = Error<T>;
fn deposit_event() = default;
/// Anonymously schedule a task.
@@ -146,8 +198,9 @@ decl_module! {
priority: schedule::Priority,
call: Box<<T as Trait>::Call>,
) {
ensure_root(origin)?;
Self::do_schedule(when, maybe_periodic, priority, *call)?;
T::ScheduleOrigin::ensure_origin(origin.clone())?;
let origin = <T as Trait>::Origin::from(origin);
Self::do_schedule(when, maybe_periodic, priority, origin.caller().clone(), *call)?;
}
/// Cancel an anonymously scheduled task.
@@ -162,8 +215,9 @@ decl_module! {
/// # </weight>
#[weight = 100_000_000 + T::DbWeight::get().reads_writes(1, 2)]
fn cancel(origin, when: T::BlockNumber, index: u32) {
ensure_root(origin)?;
Self::do_cancel((when, index))?;
T::ScheduleOrigin::ensure_origin(origin.clone())?;
let origin = <T as Trait>::Origin::from(origin);
Self::do_cancel(Some(origin.caller().clone()), (when, index))?;
}
/// Schedule a named task.
@@ -184,8 +238,9 @@ decl_module! {
priority: schedule::Priority,
call: Box<<T as Trait>::Call>,
) {
ensure_root(origin)?;
Self::do_schedule_named(id, when, maybe_periodic, priority, *call)?;
T::ScheduleOrigin::ensure_origin(origin.clone())?;
let origin = <T as Trait>::Origin::from(origin);
Self::do_schedule_named(id, when, maybe_periodic, priority, origin.caller().clone(), *call)?;
}
/// Cancel a named scheduled task.
@@ -200,8 +255,9 @@ decl_module! {
/// # </weight>
#[weight = 100_000_000 + T::DbWeight::get().reads_writes(2, 2)]
fn cancel_named(origin, id: Vec<u8>) {
ensure_root(origin)?;
Self::do_cancel_named(id)?;
T::ScheduleOrigin::ensure_origin(origin.clone())?;
let origin = <T as Trait>::Origin::from(origin);
Self::do_cancel_named(Some(origin.caller().clone()), id)?;
}
/// Execute the scheduled calls
@@ -249,7 +305,7 @@ decl_module! {
// - It does not push the weight past the limit.
// - It is the first item in the schedule
if s.priority <= schedule::HARD_DEADLINE || cumulative_weight <= limit || order == 0 {
let r = s.call.clone().dispatch(system::RawOrigin::Root.into());
let r = s.call.clone().dispatch(s.origin.clone().into());
let maybe_id = s.maybe_id.clone();
if let &Some((period, count)) = &s.maybe_periodic {
if count > 1 {
@@ -291,10 +347,39 @@ decl_module! {
}
impl<T: Trait> Module<T> {
/// Migrate storage format from V1 to V2.
/// Return true if migration is performed.
pub fn migrate_v1_to_t2() -> bool {
if StorageVersion::get() == Releases::V1 {
StorageVersion::put(Releases::V2);
Agenda::<T>::translate::<
Vec<Option<ScheduledV1<<T as Trait>::Call, T::BlockNumber>>>, _
>(|_, agenda| Some(
agenda
.into_iter()
.map(|schedule| schedule.map(|schedule| ScheduledV2 {
maybe_id: schedule.maybe_id,
priority: schedule.priority,
call: schedule.call,
maybe_periodic: schedule.maybe_periodic,
origin: system::RawOrigin::Root.into(),
_phantom: Default::default(),
}))
.collect::<Vec<_>>()
));
true
} else {
false
}
}
fn do_schedule(
when: T::BlockNumber,
maybe_periodic: Option<schedule::Period<T::BlockNumber>>,
priority: schedule::Priority,
origin: T::PalletsOrigin,
call: <T as Trait>::Call
) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {
if when <= frame_system::Module::<T>::block_number() {
@@ -306,7 +391,9 @@ impl<T: Trait> Module<T> {
.filter(|p| p.1 > 1 && !p.0.is_zero())
// Remove one from the number of repetitions since we will schedule one now.
.map(|(p, c)| (p, c - 1));
let s = Some(Scheduled { maybe_id: None, priority, call, maybe_periodic });
let s = Some(Scheduled {
maybe_id: None, priority, call, maybe_periodic, origin, _phantom: PhantomData::<T::AccountId>::default(),
});
Agenda::<T>::append(when, s);
let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;
Self::deposit_event(RawEvent::Scheduled(when, index));
@@ -314,8 +401,25 @@ impl<T: Trait> Module<T> {
Ok((when, index))
}
fn do_cancel((when, index): TaskAddress<T::BlockNumber>) -> Result<(), DispatchError> {
if let Some(s) = Agenda::<T>::mutate(when, |agenda| agenda.get_mut(index as usize).and_then(Option::take)) {
fn do_cancel(
origin: Option<T::PalletsOrigin>,
(when, index): TaskAddress<T::BlockNumber>
) -> Result<(), DispatchError> {
let scheduled = Agenda::<T>::try_mutate(
when,
|agenda| {
agenda.get_mut(index as usize)
.map_or(Ok(None), |s| -> Result<Option<Scheduled<_, _, _, _>>, DispatchError> {
if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {
if *o != s.origin {
return Err(BadOrigin.into());
}
};
Ok(s.take())
})
},
)?;
if let Some(s) = scheduled {
if let Some(id) = s.maybe_id {
Lookup::<T>::remove(id);
}
@@ -331,6 +435,7 @@ impl<T: Trait> Module<T> {
when: T::BlockNumber,
maybe_periodic: Option<schedule::Period<T::BlockNumber>>,
priority: schedule::Priority,
origin: T::PalletsOrigin,
call: <T as Trait>::Call,
) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {
// ensure id it is unique
@@ -348,7 +453,9 @@ impl<T: Trait> Module<T> {
// Remove one from the number of repetitions since we will schedule one now.
.map(|(p, c)| (p, c - 1));
let s = Scheduled { maybe_id: Some(id.clone()), priority, call, maybe_periodic };
let s = Scheduled {
maybe_id: Some(id.clone()), priority, call, maybe_periodic, origin, _phantom: Default::default()
};
Agenda::<T>::append(when, Some(s));
let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;
let address = (when, index);
@@ -358,36 +465,49 @@ impl<T: Trait> Module<T> {
Ok(address)
}
fn do_cancel_named(id: Vec<u8>) -> Result<(), DispatchError> {
if let Some((when, index)) = Lookup::<T>::take(id) {
let i = index as usize;
Agenda::<T>::mutate(when, |agenda| if let Some(s) = agenda.get_mut(i) { *s = None });
Self::deposit_event(RawEvent::Canceled(when, index));
Ok(())
} else {
Err(Error::<T>::FailedToCancel)?
}
fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: Vec<u8>) -> DispatchResult {
Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {
if let Some((when, index)) = lookup.take() {
let i = index as usize;
Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {
if let Some(s) = agenda.get_mut(i) {
if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {
if *o != s.origin {
return Err(BadOrigin.into());
}
}
*s = None;
}
Ok(())
})?;
Self::deposit_event(RawEvent::Canceled(when, index));
Ok(())
} else {
Err(Error::<T>::FailedToCancel)?
}
})
}
}
impl<T: Trait> schedule::Anon<T::BlockNumber, <T as Trait>::Call> for Module<T> {
impl<T: Trait> schedule::Anon<T::BlockNumber, <T as Trait>::Call, T::PalletsOrigin> for Module<T> {
type Address = TaskAddress<T::BlockNumber>;
fn schedule(
when: T::BlockNumber,
maybe_periodic: Option<schedule::Period<T::BlockNumber>>,
priority: schedule::Priority,
origin: T::PalletsOrigin,
call: <T as Trait>::Call
) -> Result<Self::Address, DispatchError> {
Self::do_schedule(when, maybe_periodic, priority, call)
Self::do_schedule(when, maybe_periodic, priority, origin, call)
}
fn cancel((when, index): Self::Address) -> Result<(), ()> {
Self::do_cancel((when, index)).map_err(|_| ())
Self::do_cancel(None, (when, index)).map_err(|_| ())
}
}
impl<T: Trait> schedule::Named<T::BlockNumber, <T as Trait>::Call> for Module<T> {
impl<T: Trait> schedule::Named<T::BlockNumber, <T as Trait>::Call, T::PalletsOrigin> for Module<T> {
type Address = TaskAddress<T::BlockNumber>;
fn schedule_named(
@@ -395,13 +515,14 @@ impl<T: Trait> schedule::Named<T::BlockNumber, <T as Trait>::Call> for Module<T>
when: T::BlockNumber,
maybe_periodic: Option<schedule::Period<T::BlockNumber>>,
priority: schedule::Priority,
origin: T::PalletsOrigin,
call: <T as Trait>::Call,
) -> Result<Self::Address, ()> {
Self::do_schedule_named(id, when, maybe_periodic, priority, call).map_err(|_| ())
Self::do_schedule_named(id, when, maybe_periodic, priority, origin, call).map_err(|_| ())
}
fn cancel_named(id: Vec<u8>) -> Result<(), ()> {
Self::do_cancel_named(id).map_err(|_| ())
Self::do_cancel_named(None, id).map_err(|_| ())
}
}
@@ -410,8 +531,10 @@ mod tests {
use super::*;
use frame_support::{
impl_outer_event, impl_outer_origin, impl_outer_dispatch, parameter_types, assert_ok,
assert_err, traits::{OnInitialize, OnFinalize, Filter}, weights::constants::RocksDbWeight,
impl_outer_event, impl_outer_origin, impl_outer_dispatch, parameter_types, assert_ok, ord_parameter_types,
assert_noop, assert_err, Hashable,
traits::{OnInitialize, OnFinalize, Filter},
weights::constants::RocksDbWeight,
};
use sp_core::H256;
// The testing primitives are very useful for avoiding having to work with signatures
@@ -421,41 +544,48 @@ mod tests {
testing::Header,
traits::{BlakeTwo256, IdentityLookup},
};
use frame_system::{EnsureOneOf, EnsureRoot, EnsureSignedBy};
use crate as scheduler;
mod logger {
use super::*;
use std::cell::RefCell;
use frame_system::ensure_root;
thread_local! {
static LOG: RefCell<Vec<u32>> = RefCell::new(Vec::new());
static LOG: RefCell<Vec<(OriginCaller, u32)>> = RefCell::new(Vec::new());
}
pub fn log() -> Vec<u32> {
pub fn log() -> Vec<(OriginCaller, u32)> {
LOG.with(|log| log.borrow().clone())
}
pub trait Trait: system::Trait {
type Event: From<Event> + Into<<Self as system::Trait>::Event>;
}
decl_storage! {
trait Store for Module<T: Trait> as Logger {
}
}
decl_event! {
pub enum Event {
Logged(u32, Weight),
}
}
decl_module! {
pub struct Module<T: Trait> for enum Call where origin: <T as system::Trait>::Origin {
pub struct Module<T: Trait> for enum Call
where
origin: <T as system::Trait>::Origin,
<T as system::Trait>::Origin: OriginTrait<PalletsOrigin = OriginCaller>
{
fn deposit_event() = default;
#[weight = *weight]
fn log(origin, i: u32, weight: Weight) {
ensure_root(origin)?;
Self::deposit_event(Event::Logged(i, weight));
LOG.with(|log| {
log.borrow_mut().push(i);
log.borrow_mut().push((origin.caller().clone(), i));
})
}
#[weight = *weight]
fn log_without_filter(origin, i: u32, weight: Weight) {
Self::deposit_event(Event::Logged(i, weight));
LOG.with(|log| {
log.borrow_mut().push((origin.caller().clone(), i));
})
}
}
@@ -485,7 +615,7 @@ mod tests {
pub struct BaseFilter;
impl Filter<Call> for BaseFilter {
fn filter(call: &Call) -> bool {
!matches!(call, Call::Logger(_))
!matches!(call, Call::Logger(logger::Call::log(_, _)))
}
}
@@ -532,11 +662,17 @@ mod tests {
parameter_types! {
pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) * MaximumBlockWeight::get();
}
ord_parameter_types! {
pub const One: u64 = 1;
}
impl Trait for Test {
type Event = ();
type Origin = Origin;
type PalletsOrigin = OriginCaller;
type Call = Call;
type MaximumWeight = MaximumSchedulerWeight;
type ScheduleOrigin = EnsureOneOf<u64, EnsureRoot<u64>, EnsureSignedBy<One, u64>>;
}
type System = system::Module<Test>;
type Logger = logger::Module<Test>;
@@ -557,18 +693,22 @@ mod tests {
}
}
fn root() -> OriginCaller {
system::RawOrigin::Root.into()
}
#[test]
fn basic_scheduling_works() {
new_test_ext().execute_with(|| {
let call = Call::Logger(logger::Call::log(42, 1000));
assert!(!<Test as frame_system::Trait>::BaseCallFilter::filter(&call));
let _ = Scheduler::do_schedule(4, None, 127, call);
let _ = Scheduler::do_schedule(4, None, 127, root(), call);
run_to_block(3);
assert!(logger::log().is_empty());
run_to_block(4);
assert_eq!(logger::log(), vec![42u32]);
assert_eq!(logger::log(), vec![(root(), 42u32)]);
run_to_block(100);
assert_eq!(logger::log(), vec![42u32]);
assert_eq!(logger::log(), vec![(root(), 42u32)]);
});
}
@@ -576,21 +716,23 @@ mod tests {
fn periodic_scheduling_works() {
new_test_ext().execute_with(|| {
// at #4, every 3 blocks, 3 times.
let _ = Scheduler::do_schedule(4, Some((3, 3)), 127, Call::Logger(logger::Call::log(42, 1000)));
let _ = Scheduler::do_schedule(
4, Some((3, 3)), 127, root(), Call::Logger(logger::Call::log(42, 1000))
);
run_to_block(3);
assert!(logger::log().is_empty());
run_to_block(4);
assert_eq!(logger::log(), vec![42u32]);
assert_eq!(logger::log(), vec![(root(), 42u32)]);
run_to_block(6);
assert_eq!(logger::log(), vec![42u32]);
assert_eq!(logger::log(), vec![(root(), 42u32)]);
run_to_block(7);
assert_eq!(logger::log(), vec![42u32, 42u32]);
assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
run_to_block(9);
assert_eq!(logger::log(), vec![42u32, 42u32]);
assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
run_to_block(10);
assert_eq!(logger::log(), vec![42u32, 42u32, 42u32]);
assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);
run_to_block(100);
assert_eq!(logger::log(), vec![42u32, 42u32, 42u32]);
assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);
});
}
@@ -598,12 +740,16 @@ mod tests {
fn cancel_named_scheduling_works_with_normal_cancel() {
new_test_ext().execute_with(|| {
// at #4.
Scheduler::do_schedule_named(1u32.encode(), 4, None, 127, Call::Logger(logger::Call::log(69, 1000))).unwrap();
let i = Scheduler::do_schedule(4, None, 127, Call::Logger(logger::Call::log(42, 1000))).unwrap();
Scheduler::do_schedule_named(
1u32.encode(), 4, None, 127, root(), Call::Logger(logger::Call::log(69, 1000))
).unwrap();
let i = Scheduler::do_schedule(
4, None, 127, root(), Call::Logger(logger::Call::log(42, 1000))
).unwrap();
run_to_block(3);
assert!(logger::log().is_empty());
assert_ok!(Scheduler::do_cancel_named(1u32.encode()));
assert_ok!(Scheduler::do_cancel(i));
assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));
assert_ok!(Scheduler::do_cancel(None, i));
run_to_block(100);
assert!(logger::log().is_empty());
});
@@ -613,53 +759,71 @@ mod tests {
fn cancel_named_periodic_scheduling_works() {
new_test_ext().execute_with(|| {
// at #4, every 3 blocks, 3 times.
Scheduler::do_schedule_named(1u32.encode(), 4, Some((3, 3)), 127, Call::Logger(logger::Call::log(42, 1000))).unwrap();
Scheduler::do_schedule_named(
1u32.encode(), 4, Some((3, 3)), 127, root(), Call::Logger(logger::Call::log(42, 1000))
).unwrap();
// same id results in error.
assert!(Scheduler::do_schedule_named(1u32.encode(), 4, None, 127, Call::Logger(logger::Call::log(69, 1000))).is_err());
assert!(Scheduler::do_schedule_named(
1u32.encode(), 4, None, 127, root(), Call::Logger(logger::Call::log(69, 1000))
).is_err());
// different id is ok.
Scheduler::do_schedule_named(2u32.encode(), 8, None, 127, Call::Logger(logger::Call::log(69, 1000))).unwrap();
Scheduler::do_schedule_named(
2u32.encode(), 8, None, 127, root(), Call::Logger(logger::Call::log(69, 1000))
).unwrap();
run_to_block(3);
assert!(logger::log().is_empty());
run_to_block(4);
assert_eq!(logger::log(), vec![42u32]);
assert_eq!(logger::log(), vec![(root(), 42u32)]);
run_to_block(6);
assert_ok!(Scheduler::do_cancel_named(1u32.encode()));
assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));
run_to_block(100);
assert_eq!(logger::log(), vec![42u32, 69u32]);
assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
});
}
#[test]
fn scheduler_respects_weight_limits() {
new_test_ext().execute_with(|| {
let _ = Scheduler::do_schedule(4, None, 127, Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2)));
let _ = Scheduler::do_schedule(4, None, 127, Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2)));
let _ = Scheduler::do_schedule(
4, None, 127, root(), Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))
);
let _ = Scheduler::do_schedule(
4, None, 127, root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))
);
// 69 and 42 do not fit together
run_to_block(4);
assert_eq!(logger::log(), vec![42u32]);
assert_eq!(logger::log(), vec![(root(), 42u32)]);
run_to_block(5);
assert_eq!(logger::log(), vec![42u32, 69u32]);
assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
});
}
#[test]
fn scheduler_respects_hard_deadlines_more() {
new_test_ext().execute_with(|| {
let _ = Scheduler::do_schedule(4, None, 0, Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2)));
let _ = Scheduler::do_schedule(4, None, 0, Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2)));
let _ = Scheduler::do_schedule(
4, None, 0, root(), Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))
);
let _ = Scheduler::do_schedule(
4, None, 0, root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))
);
// With base weights, 69 and 42 should not fit together, but do because of hard deadlines
run_to_block(4);
assert_eq!(logger::log(), vec![42u32, 69u32]);
assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
});
}
#[test]
fn scheduler_respects_priority_ordering() {
new_test_ext().execute_with(|| {
let _ = Scheduler::do_schedule(4, None, 1, Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2)));
let _ = Scheduler::do_schedule(4, None, 0, Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2)));
let _ = Scheduler::do_schedule(
4, None, 1, root(), Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))
);
let _ = Scheduler::do_schedule(
4, None, 0, root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))
);
run_to_block(4);
assert_eq!(logger::log(), vec![69u32, 42u32]);
assert_eq!(logger::log(), vec![(root(), 69u32), (root(), 42u32)]);
});
}
@@ -667,30 +831,21 @@ mod tests {
fn scheduler_respects_priority_ordering_with_soft_deadlines() {
new_test_ext().execute_with(|| {
let _ = Scheduler::do_schedule(
4,
None,
255,
Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3)),
4, None, 255, root(), Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))
);
let _ = Scheduler::do_schedule(
4,
None,
127,
Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2)),
4, None, 127, root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))
);
let _ = Scheduler::do_schedule(
4,
None,
126,
Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2)),
4, None, 126, root(), Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2))
);
// 2600 does not fit with 69 or 42, but has higher priority, so will go through
run_to_block(4);
assert_eq!(logger::log(), vec![2600u32]);
assert_eq!(logger::log(), vec![(root(), 2600u32)]);
// 69 and 42 fit together
run_to_block(5);
assert_eq!(logger::log(), vec![2600u32, 69u32, 42u32]);
assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);
});
}
@@ -703,47 +858,45 @@ mod tests {
let periodic_multiplier = <Test as frame_system::Trait>::DbWeight::get().reads_writes(1, 1);
// Named
assert_ok!(Scheduler::do_schedule_named(1u32.encode(), 1, None, 255, Call::Logger(logger::Call::log(3, MaximumSchedulerWeight::get() / 3))));
assert_ok!(
Scheduler::do_schedule_named(
1u32.encode(), 1, None, 255, root(),
Call::Logger(logger::Call::log(3, MaximumSchedulerWeight::get() / 3))
)
);
// Anon Periodic
let _ = Scheduler::do_schedule(
1,
Some((1000, 3)),
128,
Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3)),
1, Some((1000, 3)), 128, root(), Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))
);
// Anon
let _ = Scheduler::do_schedule(
1,
None,
127,
Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2)),
1, None, 127, root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))
);
// Named Periodic
assert_ok!(Scheduler::do_schedule_named(
2u32.encode(),
1,
Some((1000, 3)),
126,
Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2)),
));
2u32.encode(), 1, Some((1000, 3)), 126, root(),
Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2)))
);
// Will include the named periodic only
let actual_weight = Scheduler::on_initialize(1);
let call_weight = MaximumSchedulerWeight::get() / 2;
assert_eq!(actual_weight, call_weight + base_weight + base_multiplier + named_multiplier + periodic_multiplier);
assert_eq!(logger::log(), vec![2600u32]);
assert_eq!(
actual_weight, call_weight + base_weight + base_multiplier + named_multiplier + periodic_multiplier
);
assert_eq!(logger::log(), vec![(root(), 2600u32)]);
// Will include anon and anon periodic
let actual_weight = Scheduler::on_initialize(2);
let call_weight = MaximumSchedulerWeight::get() / 2 + MaximumSchedulerWeight::get() / 3;
assert_eq!(actual_weight, call_weight + base_weight + base_multiplier * 2 + periodic_multiplier);
assert_eq!(logger::log(), vec![2600u32, 69u32, 42u32]);
assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);
// Will include named only
let actual_weight = Scheduler::on_initialize(3);
let call_weight = MaximumSchedulerWeight::get() / 3;
assert_eq!(actual_weight, call_weight + base_weight + base_multiplier + named_multiplier);
assert_eq!(logger::log(), vec![2600u32, 69u32, 42u32, 3u32]);
assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32), (root(), 3u32)]);
// Will contain none
let actual_weight = Scheduler::on_initialize(4);
@@ -794,4 +947,169 @@ mod tests {
);
});
}
#[test]
fn should_use_orign() {
new_test_ext().execute_with(|| {
let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));
let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));
assert_ok!(
Scheduler::schedule_named(system::RawOrigin::Signed(1).into(), 1u32.encode(), 4, None, 127, call)
);
assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2));
run_to_block(3);
// Scheduled calls are in the agenda.
assert_eq!(Agenda::<Test>::get(4).len(), 2);
assert!(logger::log().is_empty());
assert_ok!(Scheduler::cancel_named(system::RawOrigin::Signed(1).into(), 1u32.encode()));
assert_ok!(Scheduler::cancel(system::RawOrigin::Signed(1).into(), 4, 1));
// Scheduled calls are made NONE, so should not effect state
run_to_block(100);
assert!(logger::log().is_empty());
});
}
#[test]
fn should_check_orign() {
new_test_ext().execute_with(|| {
let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));
let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));
assert_noop!(
Scheduler::schedule_named(system::RawOrigin::Signed(2).into(), 1u32.encode(), 4, None, 127, call),
BadOrigin
);
assert_noop!(Scheduler::schedule(system::RawOrigin::Signed(2).into(), 4, None, 127, call2), BadOrigin);
});
}
#[test]
fn should_check_orign_for_cancel() {
new_test_ext().execute_with(|| {
let call = Box::new(Call::Logger(logger::Call::log_without_filter(69, 1000)));
let call2 = Box::new(Call::Logger(logger::Call::log_without_filter(42, 1000)));
assert_ok!(
Scheduler::schedule_named(system::RawOrigin::Signed(1).into(), 1u32.encode(), 4, None, 127, call)
);
assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2));
run_to_block(3);
// Scheduled calls are in the agenda.
assert_eq!(Agenda::<Test>::get(4).len(), 2);
assert!(logger::log().is_empty());
assert_noop!(Scheduler::cancel_named(system::RawOrigin::Signed(2).into(), 1u32.encode()), BadOrigin);
assert_noop!(Scheduler::cancel(system::RawOrigin::Signed(2).into(), 4, 1), BadOrigin);
assert_noop!(Scheduler::cancel_named(system::RawOrigin::Root.into(), 1u32.encode()), BadOrigin);
assert_noop!(Scheduler::cancel(system::RawOrigin::Root.into(), 4, 1), BadOrigin);
run_to_block(5);
assert_eq!(
logger::log(),
vec![(system::RawOrigin::Signed(1).into(), 69u32), (system::RawOrigin::Signed(1).into(), 42u32)]
);
});
}
#[test]
fn migration_to_v2_works() {
use substrate_test_utils::assert_eq_uvec;
new_test_ext().execute_with(|| {
for i in 0..3u64 {
let k = i.twox_64_concat();
let old = vec![
Some(ScheduledV1 {
maybe_id: None,
priority: i as u8 + 10,
call: Call::Logger(logger::Call::log(96, 100)),
maybe_periodic: None,
}),
None,
Some(ScheduledV1 {
maybe_id: Some(b"test".to_vec()),
priority: 123,
call: Call::Logger(logger::Call::log(69, 1000)),
maybe_periodic: Some((456u64, 10)),
}),
];
frame_support::migration::put_storage_value(
b"Scheduler",
b"Agenda",
&k,
old,
);
}
assert_eq!(StorageVersion::get(), Releases::V1);
assert!(Scheduler::migrate_v1_to_t2());
assert_eq_uvec!(Agenda::<Test>::iter().collect::<Vec<_>>(), vec![
(
0,
vec![
Some(ScheduledV2 {
maybe_id: None,
priority: 10,
call: Call::Logger(logger::Call::log(96, 100)),
maybe_periodic: None,
origin: root(),
_phantom: PhantomData::<u64>::default(),
}),
None,
Some(ScheduledV2 {
maybe_id: Some(b"test".to_vec()),
priority: 123,
call: Call::Logger(logger::Call::log(69, 1000)),
maybe_periodic: Some((456u64, 10)),
origin: root(),
_phantom: PhantomData::<u64>::default(),
}),
]),
(
1,
vec![
Some(ScheduledV2 {
maybe_id: None,
priority: 11,
call: Call::Logger(logger::Call::log(96, 100)),
maybe_periodic: None,
origin: root(),
_phantom: PhantomData::<u64>::default(),
}),
None,
Some(ScheduledV2 {
maybe_id: Some(b"test".to_vec()),
priority: 123,
call: Call::Logger(logger::Call::log(69, 1000)),
maybe_periodic: Some((456u64, 10)),
origin: root(),
_phantom: PhantomData::<u64>::default(),
}),
]
),
(
2,
vec![
Some(ScheduledV2 {
maybe_id: None,
priority: 12,
call: Call::Logger(logger::Call::log(96, 100)),
maybe_periodic: None,
origin: root(),
_phantom: PhantomData::<u64>::default(),
}),
None,
Some(ScheduledV2 {
maybe_id: Some(b"test".to_vec()),
priority: 123,
call: Call::Logger(logger::Call::log(69, 1000)),
maybe_periodic: Some((456u64, 10)),
origin: root(),
_phantom: PhantomData::<u64>::default(),
}),
]
)
]);
assert_eq!(StorageVersion::get(), Releases::V2);
});
}
}