difftreelog
fix clippy warnings
in: master
1 file changed
pallets/scheduler-v2/src/lib.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617// Original license:18// This file is part of Substrate.1920// Copyright (C) 2017-2022 Parity Technologies (UK) Ltd.21// SPDX-License-Identifier: Apache-2.02223// Licensed under the Apache License, Version 2.0 (the "License");24// you may not use this file except in compliance with the License.25// You may obtain a copy of the License at26//27// http://www.apache.org/licenses/LICENSE-2.028//29// Unless required by applicable law or agreed to in writing, software30// distributed under the License is distributed on an "AS IS" BASIS,31// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.32// See the License for the specific language governing permissions and33// limitations under the License.3435//! # Scheduler36//! A Pallet for scheduling dispatches.37//!38//! - [`Config`]39//! - [`Call`]40//! - [`Pallet`]41//!42//! ## Overview43//!44//! This Pallet exposes capabilities for scheduling dispatches to occur at a45//! specified block number or at a specified period. These scheduled dispatches46//! may be named or anonymous and may be canceled.47//!48//! **NOTE:** The scheduled calls will be dispatched with the default filter49//! for the origin: namely `frame_system::Config::BaseCallFilter` for all origin50//! except root which will get no filter. And not the filter contained in origin51//! use to call `fn schedule`.52//!53//! If a call is scheduled using proxy or whatever mecanism which adds filter,54//! then those filter will not be used when dispatching the schedule call.55//!56//! ## Interface57//!58//! ### Dispatchable Functions59//!60//! * `schedule` - schedule a dispatch, which may be periodic, to occur at a specified block and61//! with a specified priority.62//! * `cancel` - cancel a scheduled dispatch, specified by block number and index.63//! * `schedule_named` - augments the `schedule` interface with an additional `Vec<u8>` parameter64//! that can be used for identification.65//! * `cancel_named` - the named complement to the cancel function.6667// Ensure we're `no_std` when compiling for Wasm.68#![cfg_attr(not(feature = "std"), no_std)]6970#[cfg(feature = "runtime-benchmarks")]71mod benchmarking;72#[cfg(test)]73mod mock;74#[cfg(test)]75mod tests;76pub mod weights;7778use codec::{Codec, Decode, Encode, MaxEncodedLen};79use frame_support::{80 dispatch::{81 DispatchError, DispatchResult, Dispatchable, GetDispatchInfo, Parameter, PostDispatchInfo,82 },83 traits::{84 schedule::{self, DispatchTime, LOWEST_PRIORITY},85 EnsureOrigin, Get, IsType, OriginTrait, PrivilegeCmp, StorageVersion, PreimageRecipient,86 ConstU32, UnfilteredDispatchable,87 },88 weights::Weight,89 unsigned::TransactionValidityError,90};9192use frame_system::{self as system};93use scale_info::TypeInfo;94use sp_runtime::{95 traits::{BadOrigin, One, Saturating, Zero, Hash},96 BoundedVec, RuntimeDebug, DispatchErrorWithPostInfo,97};98use sp_core::H160;99use sp_std::{cmp::Ordering, marker::PhantomData, prelude::*};100pub use weights::WeightInfo;101102pub use pallet::*;103104/// Just a simple index for naming period tasks.105pub type PeriodicIndex = u32;106/// The location of a scheduled task that can be used to remove it.107pub type TaskAddress<BlockNumber> = (BlockNumber, u32);108109pub type EncodedCall = BoundedVec<u8, ConstU32<128>>;110111#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]112#[scale_info(skip_type_params(T))]113pub enum ScheduledCall<T: Config> {114 Inline(EncodedCall),115 PreimageLookup { hash: T::Hash, unbounded_len: u32 },116}117118impl<T: Config> ScheduledCall<T> {119 pub fn new(call: <T as Config>::RuntimeCall) -> Result<Self, DispatchError> {120 let encoded = call.encode();121 let len = encoded.len();122123 match EncodedCall::try_from(encoded.clone()) {124 Ok(bounded) => Ok(Self::Inline(bounded)),125 Err(_) => {126 let hash = <T as system::Config>::Hashing::hash_of(&encoded);127 <T as Config>::Preimages::note_preimage(128 encoded129 .try_into()130 .map_err(|_| <Error<T>>::TooBigScheduledCall)?,131 );132133 Ok(Self::PreimageLookup {134 hash,135 unbounded_len: len as u32,136 })137 }138 }139 }140141 /// The maximum length of the lookup that is needed to peek `Self`.142 pub fn lookup_len(&self) -> Option<u32> {143 match self {144 Self::Inline(..) => None,145 Self::PreimageLookup { unbounded_len, .. } => Some(*unbounded_len),146 }147 }148149 /// Returns whether the image will require a lookup to be peeked.150 pub fn lookup_needed(&self) -> bool {151 match self {152 Self::Inline(_) => false,153 Self::PreimageLookup { .. } => true,154 }155 }156157 fn decode(mut data: &[u8]) -> Result<<T as Config>::RuntimeCall, DispatchError> {158 <T as Config>::RuntimeCall::decode(&mut data)159 .map_err(|_| <Error<T>>::ScheduledCallCorrupted.into())160 }161}162163pub trait SchedulerPreimages<T: Config>: PreimageRecipient<T::Hash> {164 fn drop(call: &ScheduledCall<T>);165166 fn peek(167 call: &ScheduledCall<T>,168 ) -> Result<(<T as pallet::Config>::RuntimeCall, Option<u32>), DispatchError>;169170 /// Convert the given scheduled `call` value back into its original instance. If successful,171 /// `drop` any data backing it. This will not break the realisability of independently172 /// created instances of `ScheduledCall` which happen to have identical data.173 fn realize(174 call: &ScheduledCall<T>,175 ) -> Result<(<T as pallet::Config>::RuntimeCall, Option<u32>), DispatchError>;176}177178impl<T: Config, PP: PreimageRecipient<T::Hash>> SchedulerPreimages<T> for PP {179 fn drop(call: &ScheduledCall<T>) {180 match call {181 ScheduledCall::Inline(_) => {}182 ScheduledCall::PreimageLookup { hash, .. } => Self::unrequest_preimage(hash),183 }184 }185186 fn peek(187 call: &ScheduledCall<T>,188 ) -> Result<(<T as pallet::Config>::RuntimeCall, Option<u32>), DispatchError> {189 match call {190 ScheduledCall::Inline(data) => Ok((ScheduledCall::<T>::decode(data)?, None)),191 ScheduledCall::PreimageLookup {192 hash,193 unbounded_len,194 } => {195 let (preimage, len) = Self::get_preimage(hash)196 .ok_or(<Error<T>>::PreimageNotFound)197 .map(|preimage| (preimage, *unbounded_len))?;198199 Ok((ScheduledCall::<T>::decode(preimage.as_slice())?, Some(len)))200 }201 }202 }203204 fn realize(205 call: &ScheduledCall<T>,206 ) -> Result<(<T as pallet::Config>::RuntimeCall, Option<u32>), DispatchError> {207 let r = Self::peek(call)?;208 Self::drop(call);209 Ok(r)210 }211}212213pub enum ScheduledEnsureOriginSuccess<AccountId> {214 Root,215 Signed(AccountId),216}217218pub type TaskName = [u8; 32];219220/// Information regarding an item to be executed in the future.221#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]222#[derive(Clone, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]223pub struct Scheduled<Name, Call, BlockNumber, PalletsOrigin, AccountId> {224 /// The unique identity for this task, if there is one.225 maybe_id: Option<Name>,226227 /// This task's priority.228 priority: schedule::Priority,229230 /// The call to be dispatched.231 call: Call,232233 /// If the call is periodic, then this points to the information concerning that.234 maybe_periodic: Option<schedule::Period<BlockNumber>>,235236 /// The origin with which to dispatch the call.237 origin: PalletsOrigin,238 _phantom: PhantomData<AccountId>,239}240241pub type ScheduledOf<T> = Scheduled<242 TaskName,243 ScheduledCall<T>,244 <T as frame_system::Config>::BlockNumber,245 <T as Config>::PalletsOrigin,246 <T as frame_system::Config>::AccountId,247>;248249#[derive(Encode, Decode, MaxEncodedLen, TypeInfo)]250#[scale_info(skip_type_params(T))]251pub struct BlockAgenda<T: Config> {252 agenda: BoundedVec<Option<ScheduledOf<T>>, T::MaxScheduledPerBlock>,253 free_places: u32,254}255256impl<T: Config> BlockAgenda<T> {257 fn try_push(&mut self, scheduled: ScheduledOf<T>) -> Result<u32, ScheduledOf<T>> {258 if self.free_places == 0 {259 return Err(scheduled);260 }261262 self.free_places = self.free_places.saturating_sub(1);263264 if (self.agenda.len() as u32) < T::MaxScheduledPerBlock::get() {265 // will always succeed due to the above check.266 let _ = self.agenda.try_push(Some(scheduled));267 Ok((self.agenda.len() - 1) as u32)268 } else {269 match self.agenda.iter().position(|i| i.is_none()) {270 Some(hole_index) => {271 self.agenda[hole_index] = Some(scheduled);272 Ok(hole_index as u32)273 }274 None => unreachable!("free_places was greater than 0; qed"),275 }276 }277 }278279 fn set_slot(&mut self, index: u32, slot: Option<ScheduledOf<T>>) {280 self.agenda[index as usize] = slot;281 }282283 fn iter(&self) -> impl Iterator<Item = &'_ Option<ScheduledOf<T>>> + '_ {284 self.agenda.iter()285 }286287 fn get(&self, index: u32) -> Option<&ScheduledOf<T>> {288 match self.agenda.get(index as usize) {289 Some(Some(scheduled)) => Some(scheduled),290 _ => None,291 }292 }293294 fn get_mut(&mut self, index: u32) -> Option<&mut ScheduledOf<T>> {295 match self.agenda.get_mut(index as usize) {296 Some(Some(scheduled)) => Some(scheduled),297 _ => None,298 }299 }300301 fn take(&mut self, index: u32) -> Option<ScheduledOf<T>> {302 let removed = self.agenda.get_mut(index as usize)?.take();303304 if removed.is_some() {305 self.free_places = self.free_places.saturating_add(1);306 }307308 removed309 }310}311312impl<T: Config> Default for BlockAgenda<T> {313 fn default() -> Self {314 let agenda = Default::default();315 let free_places = T::MaxScheduledPerBlock::get();316317 Self {318 agenda,319 free_places,320 }321 }322}323324struct WeightCounter {325 used: Weight,326 limit: Weight,327}328329impl WeightCounter {330 fn check_accrue(&mut self, w: Weight) -> bool {331 let test = self.used.saturating_add(w);332 if test.any_gt(self.limit) {333 false334 } else {335 self.used = test;336 true337 }338 }339340 fn can_accrue(&mut self, w: Weight) -> bool {341 self.used.saturating_add(w).all_lte(self.limit)342 }343}344345pub(crate) trait MarginalWeightInfo: WeightInfo {346 fn service_task(maybe_lookup_len: Option<usize>, named: bool, periodic: bool) -> Weight {347 let base = Self::service_task_base();348 let mut total = match maybe_lookup_len {349 None => base,350 Some(l) => Self::service_task_fetched(l as u32),351 };352 if named {353 total.saturating_accrue(Self::service_task_named().saturating_sub(base));354 }355 if periodic {356 total.saturating_accrue(Self::service_task_periodic().saturating_sub(base));357 }358 total359 }360}361362impl<T: WeightInfo> MarginalWeightInfo for T {}363364#[frame_support::pallet]365pub mod pallet {366 use super::*;367 use frame_support::{dispatch::PostDispatchInfo, pallet_prelude::*};368 use system::pallet_prelude::*;369370 /// The current storage version.371 const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);372373 #[pallet::pallet]374 #[pallet::generate_store(pub(super) trait Store)]375 #[pallet::storage_version(STORAGE_VERSION)]376 pub struct Pallet<T>(_);377378 #[pallet::config]379 pub trait Config: frame_system::Config {380 type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;381382 /// The aggregated origin which the dispatch will take.383 type RuntimeOrigin: OriginTrait<PalletsOrigin = Self::PalletsOrigin>384 + From<Self::PalletsOrigin>385 + IsType<<Self as system::Config>::RuntimeOrigin>386 + Clone;387388 /// The caller origin, overarching type of all pallets origins.389 type PalletsOrigin: From<system::RawOrigin<Self::AccountId>>390 + Codec391 + Clone392 + Eq393 + TypeInfo394 + MaxEncodedLen;395396 /// The aggregated call type.397 type RuntimeCall: Parameter398 + Dispatchable<399 RuntimeOrigin = <Self as Config>::RuntimeOrigin,400 PostInfo = PostDispatchInfo,401 > + UnfilteredDispatchable<RuntimeOrigin = <Self as system::Config>::RuntimeOrigin>402 + GetDispatchInfo403 + From<system::Call<Self>>;404405 /// The maximum weight that may be scheduled per block for any dispatchables.406 #[pallet::constant]407 type MaximumWeight: Get<Weight>;408409 /// Required origin to schedule or cancel calls.410 type ScheduleOrigin: EnsureOrigin<411 <Self as system::Config>::RuntimeOrigin,412 Success = ScheduledEnsureOriginSuccess<Self::AccountId>,413 >;414415 /// Compare the privileges of origins.416 ///417 /// This will be used when canceling a task, to ensure that the origin that tries418 /// to cancel has greater or equal privileges as the origin that created the scheduled task.419 ///420 /// For simplicity the [`EqualPrivilegeOnly`](frame_support::traits::EqualPrivilegeOnly) can421 /// be used. This will only check if two given origins are equal.422 type OriginPrivilegeCmp: PrivilegeCmp<Self::PalletsOrigin>;423424 /// The maximum number of scheduled calls in the queue for a single block.425 #[pallet::constant]426 type MaxScheduledPerBlock: Get<u32>;427428 /// Weight information for extrinsics in this pallet.429 type WeightInfo: WeightInfo;430431 /// The preimage provider with which we look up call hashes to get the call.432 type Preimages: SchedulerPreimages<Self>;433434 /// The helper type used for custom transaction fee logic.435 type CallExecutor: DispatchCall<Self, H160>;436437 /// Required origin to set/change calls' priority.438 type PrioritySetOrigin: EnsureOrigin<<Self as system::Config>::RuntimeOrigin>;439 }440441 #[pallet::storage]442 pub type IncompleteSince<T: Config> = StorageValue<_, T::BlockNumber>;443444 /// Items to be executed, indexed by the block number that they should be executed on.445 #[pallet::storage]446 pub type Agenda<T: Config> =447 StorageMap<_, Twox64Concat, T::BlockNumber, BlockAgenda<T>, ValueQuery>;448449 /// Lookup from a name to the block number and index of the task.450 #[pallet::storage]451 pub(crate) type Lookup<T: Config> =452 StorageMap<_, Twox64Concat, TaskName, TaskAddress<T::BlockNumber>>;453454 /// Events type.455 #[pallet::event]456 #[pallet::generate_deposit(pub(super) fn deposit_event)]457 pub enum Event<T: Config> {458 /// Scheduled some task.459 Scheduled { when: T::BlockNumber, index: u32 },460 /// Canceled some task.461 Canceled { when: T::BlockNumber, index: u32 },462 /// Dispatched some task.463 Dispatched {464 task: TaskAddress<T::BlockNumber>,465 id: Option<[u8; 32]>,466 result: DispatchResult,467 },468 /// Scheduled task's priority has changed469 PriorityChanged {470 when: T::BlockNumber,471 index: u32,472 priority: schedule::Priority,473 },474 /// The call for the provided hash was not found so the task has been aborted.475 CallUnavailable {476 task: TaskAddress<T::BlockNumber>,477 id: Option<[u8; 32]>,478 },479 /// The given task can never be executed since it is overweight.480 PermanentlyOverweight {481 task: TaskAddress<T::BlockNumber>,482 id: Option<[u8; 32]>,483 },484 }485486 #[pallet::error]487 pub enum Error<T> {488 /// Failed to schedule a call489 FailedToSchedule,490 /// There is no place for a new task in the agenda491 AgendaIsExhausted,492 /// Scheduled call is corrupted493 ScheduledCallCorrupted,494 /// Scheduled call preimage is not found495 PreimageNotFound,496 /// Scheduled call is too big497 TooBigScheduledCall,498 /// Cannot find the scheduled call.499 NotFound,500 /// Given target block number is in the past.501 TargetBlockNumberInPast,502 /// Attempt to use a non-named function on a named task.503 Named,504 }505506 #[pallet::hooks]507 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {508 /// Execute the scheduled calls509 fn on_initialize(now: T::BlockNumber) -> Weight {510 let mut weight_counter = WeightCounter {511 used: Weight::zero(),512 limit: T::MaximumWeight::get(),513 };514 Self::service_agendas(&mut weight_counter, now, u32::max_value());515 weight_counter.used516 }517 }518519 #[pallet::call]520 impl<T: Config> Pallet<T> {521 /// Anonymously schedule a task.522 #[pallet::weight(<T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get()))]523 pub fn schedule(524 origin: OriginFor<T>,525 when: T::BlockNumber,526 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,527 priority: Option<schedule::Priority>,528 call: Box<<T as Config>::RuntimeCall>,529 ) -> DispatchResult {530 T::ScheduleOrigin::ensure_origin(origin.clone())?;531532 if priority.is_some() {533 T::PrioritySetOrigin::ensure_origin(origin.clone())?;534 }535536 let origin = <T as Config>::RuntimeOrigin::from(origin);537 Self::do_schedule(538 DispatchTime::At(when),539 maybe_periodic,540 priority.unwrap_or(LOWEST_PRIORITY),541 origin.caller().clone(),542 <ScheduledCall<T>>::new(*call)?,543 )?;544 Ok(())545 }546547 /// Cancel an anonymously scheduled task.548 #[pallet::weight(<T as Config>::WeightInfo::cancel(T::MaxScheduledPerBlock::get()))]549 pub fn cancel(origin: OriginFor<T>, when: T::BlockNumber, index: u32) -> DispatchResult {550 T::ScheduleOrigin::ensure_origin(origin.clone())?;551 let origin = <T as Config>::RuntimeOrigin::from(origin);552 Self::do_cancel(Some(origin.caller().clone()), (when, index))?;553 Ok(())554 }555556 /// Schedule a named task.557 #[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]558 pub fn schedule_named(559 origin: OriginFor<T>,560 id: TaskName,561 when: T::BlockNumber,562 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,563 priority: Option<schedule::Priority>,564 call: Box<<T as Config>::RuntimeCall>,565 ) -> DispatchResult {566 T::ScheduleOrigin::ensure_origin(origin.clone())?;567568 if priority.is_some() {569 T::PrioritySetOrigin::ensure_origin(origin.clone())?;570 }571572 let origin = <T as Config>::RuntimeOrigin::from(origin);573 Self::do_schedule_named(574 id,575 DispatchTime::At(when),576 maybe_periodic,577 priority.unwrap_or(LOWEST_PRIORITY),578 origin.caller().clone(),579 <ScheduledCall<T>>::new(*call)?,580 )?;581 Ok(())582 }583584 /// Cancel a named scheduled task.585 #[pallet::weight(<T as Config>::WeightInfo::cancel_named(T::MaxScheduledPerBlock::get()))]586 pub fn cancel_named(origin: OriginFor<T>, id: TaskName) -> DispatchResult {587 T::ScheduleOrigin::ensure_origin(origin.clone())?;588 let origin = <T as Config>::RuntimeOrigin::from(origin);589 Self::do_cancel_named(Some(origin.caller().clone()), id)?;590 Ok(())591 }592593 /// Anonymously schedule a task after a delay.594 ///595 /// # <weight>596 /// Same as [`schedule`].597 /// # </weight>598 #[pallet::weight(<T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get()))]599 pub fn schedule_after(600 origin: OriginFor<T>,601 after: T::BlockNumber,602 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,603 priority: Option<schedule::Priority>,604 call: Box<<T as Config>::RuntimeCall>,605 ) -> DispatchResult {606 T::ScheduleOrigin::ensure_origin(origin.clone())?;607608 if priority.is_some() {609 T::PrioritySetOrigin::ensure_origin(origin.clone())?;610 }611612 let origin = <T as Config>::RuntimeOrigin::from(origin);613 Self::do_schedule(614 DispatchTime::After(after),615 maybe_periodic,616 priority.unwrap_or(LOWEST_PRIORITY),617 origin.caller().clone(),618 <ScheduledCall<T>>::new(*call)?,619 )?;620 Ok(())621 }622623 /// Schedule a named task after a delay.624 ///625 /// # <weight>626 /// Same as [`schedule_named`](Self::schedule_named).627 /// # </weight>628 #[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]629 pub fn schedule_named_after(630 origin: OriginFor<T>,631 id: TaskName,632 after: T::BlockNumber,633 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,634 priority: Option<schedule::Priority>,635 call: Box<<T as Config>::RuntimeCall>,636 ) -> DispatchResult {637 T::ScheduleOrigin::ensure_origin(origin.clone())?;638639 if priority.is_some() {640 T::PrioritySetOrigin::ensure_origin(origin.clone())?;641 }642643 let origin = <T as Config>::RuntimeOrigin::from(origin);644 Self::do_schedule_named(645 id,646 DispatchTime::After(after),647 maybe_periodic,648 priority.unwrap_or(LOWEST_PRIORITY),649 origin.caller().clone(),650 <ScheduledCall<T>>::new(*call)?,651 )?;652 Ok(())653 }654655 #[pallet::weight(<T as Config>::WeightInfo::change_named_priority(T::MaxScheduledPerBlock::get()))]656 pub fn change_named_priority(657 origin: OriginFor<T>,658 id: TaskName,659 priority: schedule::Priority,660 ) -> DispatchResult {661 T::PrioritySetOrigin::ensure_origin(origin.clone())?;662 let origin = <T as Config>::RuntimeOrigin::from(origin);663 Self::do_change_named_priority(origin.caller().clone(), id, priority)664 }665 }666}667668impl<T: Config> Pallet<T> {669 fn resolve_time(when: DispatchTime<T::BlockNumber>) -> Result<T::BlockNumber, DispatchError> {670 let now = frame_system::Pallet::<T>::block_number();671672 let when = match when {673 DispatchTime::At(x) => x,674 // The current block has already completed it's scheduled tasks, so675 // Schedule the task at lest one block after this current block.676 DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one()),677 };678679 if when <= now {680 return Err(Error::<T>::TargetBlockNumberInPast.into());681 }682683 Ok(when)684 }685686 fn mandatory_place_task(when: T::BlockNumber, what: ScheduledOf<T>) {687 Self::place_task(when, what, true).expect("mandatory place task always succeeds; qed");688 }689690 fn try_place_task(691 when: T::BlockNumber,692 what: ScheduledOf<T>,693 ) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {694 Self::place_task(when, what, false)695 }696697 fn place_task(698 mut when: T::BlockNumber,699 what: ScheduledOf<T>,700 is_mandatory: bool,701 ) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {702 let maybe_name = what.maybe_id;703 let index = Self::push_to_agenda(&mut when, what, is_mandatory)?;704 let address = (when, index);705 if let Some(name) = maybe_name {706 Lookup::<T>::insert(name, address)707 }708 Self::deposit_event(Event::Scheduled {709 when: address.0,710 index: address.1,711 });712 Ok(address)713 }714715 fn push_to_agenda(716 when: &mut T::BlockNumber,717 mut what: ScheduledOf<T>,718 is_mandatory: bool,719 ) -> Result<u32, DispatchError> {720 let mut agenda;721722 let index = loop {723 agenda = Agenda::<T>::get(*when);724725 match agenda.try_push(what) {726 Ok(index) => break index,727 Err(returned_what) if is_mandatory => {728 what = returned_what;729 when.saturating_inc();730 }731 Err(_) => return Err(<Error<T>>::AgendaIsExhausted.into()),732 }733 };734735 Agenda::<T>::insert(when, agenda);736 Ok(index)737 }738739 fn do_schedule(740 when: DispatchTime<T::BlockNumber>,741 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,742 priority: schedule::Priority,743 origin: T::PalletsOrigin,744 call: ScheduledCall<T>,745 ) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {746 let when = Self::resolve_time(when)?;747748 // sanitize maybe_periodic749 let maybe_periodic = maybe_periodic750 .filter(|p| p.1 > 1 && !p.0.is_zero())751 // Remove one from the number of repetitions since we will schedule one now.752 .map(|(p, c)| (p, c - 1));753 let task = Scheduled {754 maybe_id: None,755 priority,756 call,757 maybe_periodic,758 origin,759 _phantom: PhantomData,760 };761 Self::try_place_task(when, task)762 }763764 fn do_cancel(765 origin: Option<T::PalletsOrigin>,766 (when, index): TaskAddress<T::BlockNumber>,767 ) -> Result<(), DispatchError> {768 let scheduled = Agenda::<T>::try_mutate(769 when,770 |agenda| -> Result<Option<Scheduled<_, _, _, _, _>>, DispatchError> {771 let scheduled = match agenda.get(index) {772 Some(scheduled) => scheduled,773 None => return Ok(None),774 };775776 if let Some(ref o) = origin {777 if matches!(778 T::OriginPrivilegeCmp::cmp_privilege(o, &scheduled.origin),779 Some(Ordering::Less) | None780 ) {781 return Err(BadOrigin.into());782 }783 }784785 Ok(agenda.take(index))786 },787 )?;788 if let Some(s) = scheduled {789 T::Preimages::drop(&s.call);790791 if let Some(id) = s.maybe_id {792 Lookup::<T>::remove(id);793 }794 Self::deposit_event(Event::Canceled { when, index });795 Ok(())796 } else {797 return Err(Error::<T>::NotFound.into());798 }799 }800801 fn do_schedule_named(802 id: TaskName,803 when: DispatchTime<T::BlockNumber>,804 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,805 priority: schedule::Priority,806 origin: T::PalletsOrigin,807 call: ScheduledCall<T>,808 ) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {809 // ensure id it is unique810 if Lookup::<T>::contains_key(&id) {811 return Err(Error::<T>::FailedToSchedule.into());812 }813814 let when = Self::resolve_time(when)?;815816 // sanitize maybe_periodic817 let maybe_periodic = maybe_periodic818 .filter(|p| p.1 > 1 && !p.0.is_zero())819 // Remove one from the number of repetitions since we will schedule one now.820 .map(|(p, c)| (p, c - 1));821822 let task = Scheduled {823 maybe_id: Some(id),824 priority,825 call,826 maybe_periodic,827 origin,828 _phantom: Default::default(),829 };830 Self::try_place_task(when, task)831 }832833 fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: TaskName) -> DispatchResult {834 Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {835 if let Some((when, index)) = lookup.take() {836 Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {837 let scheduled = match agenda.get(index) {838 Some(scheduled) => scheduled,839 None => return Ok(()),840 };841842 if let Some(ref o) = origin {843 if matches!(844 T::OriginPrivilegeCmp::cmp_privilege(o, &scheduled.origin),845 Some(Ordering::Less) | None846 ) {847 return Err(BadOrigin.into());848 }849 T::Preimages::drop(&scheduled.call);850 }851852 agenda.take(index);853854 Ok(())855 })?;856 Self::deposit_event(Event::Canceled { when, index });857 Ok(())858 } else {859 return Err(Error::<T>::NotFound.into());860 }861 })862 }863864 fn do_change_named_priority(865 origin: T::PalletsOrigin,866 id: TaskName,867 priority: schedule::Priority,868 ) -> DispatchResult {869 match Lookup::<T>::get(id) {870 Some((when, index)) => Agenda::<T>::try_mutate(when, |agenda| {871 let scheduled = match agenda.get_mut(index) {872 Some(scheduled) => scheduled,873 None => return Ok(()),874 };875876 if matches!(877 T::OriginPrivilegeCmp::cmp_privilege(&origin, &scheduled.origin),878 Some(Ordering::Less) | None879 ) {880 return Err(BadOrigin.into());881 }882883 scheduled.priority = priority;884 Self::deposit_event(Event::PriorityChanged {885 when,886 index,887 priority,888 });889890 Ok(())891 }),892 None => Err(Error::<T>::NotFound.into()),893 }894 }895}896897enum ServiceTaskError {898 /// Could not be executed due to missing preimage.899 Unavailable,900 /// Could not be executed due to weight limitations.901 Overweight,902}903use ServiceTaskError::*;904905/// A Scheduler-Runtime interface for finer payment handling.906pub trait DispatchCall<T: frame_system::Config + Config, SelfContainedSignedInfo> {907 /// Resolve the call dispatch, including any post-dispatch operations.908 fn dispatch_call(909 signer: Option<T::AccountId>,910 function: <T as Config>::RuntimeCall,911 ) -> Result<912 Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,913 TransactionValidityError,914 >;915}916917impl<T: Config> Pallet<T> {918 /// Service up to `max` agendas queue starting from earliest incompletely executed agenda.919 fn service_agendas(weight: &mut WeightCounter, now: T::BlockNumber, max: u32) {920 if !weight.check_accrue(T::WeightInfo::service_agendas_base()) {921 return;922 }923924 let mut incomplete_since = now + One::one();925 let mut when = IncompleteSince::<T>::take().unwrap_or(now);926 let mut executed = 0;927928 let max_items = T::MaxScheduledPerBlock::get();929 let mut count_down = max;930 let service_agenda_base_weight = T::WeightInfo::service_agenda_base(max_items);931 while count_down > 0 && when <= now && weight.can_accrue(service_agenda_base_weight) {932 if !Self::service_agenda(weight, &mut executed, now, when, u32::max_value()) {933 incomplete_since = incomplete_since.min(when);934 }935 when.saturating_inc();936 count_down.saturating_dec();937 }938 incomplete_since = incomplete_since.min(when);939 if incomplete_since <= now {940 IncompleteSince::<T>::put(incomplete_since);941 }942 }943944 /// Returns `true` if the agenda was fully completed, `false` if it should be revisited at a945 /// later block.946 fn service_agenda(947 weight: &mut WeightCounter,948 executed: &mut u32,949 now: T::BlockNumber,950 when: T::BlockNumber,951 max: u32,952 ) -> bool {953 let mut agenda = Agenda::<T>::get(when);954 let mut ordered = agenda955 .iter()956 .enumerate()957 .filter_map(|(index, maybe_item)| {958 maybe_item959 .as_ref()960 .map(|item| (index as u32, item.priority))961 })962 .collect::<Vec<_>>();963 ordered.sort_by_key(|k| k.1);964 let within_limit =965 weight.check_accrue(T::WeightInfo::service_agenda_base(ordered.len() as u32));966 debug_assert!(967 within_limit,968 "weight limit should have been checked in advance"969 );970971 // Items which we know can be executed and have postponed for execution in a later block.972 let mut postponed = (ordered.len() as u32).saturating_sub(max);973 // Items which we don't know can ever be executed.974 let mut dropped = 0;975976 for (agenda_index, _) in ordered.into_iter().take(max as usize) {977 let task = match agenda.take(agenda_index).take() {978 None => continue,979 Some(t) => t,980 };981 let base_weight = T::WeightInfo::service_task(982 task.call.lookup_len().map(|x| x as usize),983 task.maybe_id.is_some(),984 task.maybe_periodic.is_some(),985 );986 if !weight.can_accrue(base_weight) {987 postponed += 1;988 break;989 }990 let result = Self::service_task(weight, now, when, agenda_index, *executed == 0, task);991 match result {992 Err((Unavailable, slot)) => {993 dropped += 1;994 agenda.set_slot(agenda_index, slot);995 }996 Err((Overweight, slot)) => {997 postponed += 1;998 agenda.set_slot(agenda_index, slot);999 }1000 Ok(()) => {1001 *executed += 1;1002 }1003 };1004 }1005 if postponed > 0 || dropped > 0 {1006 Agenda::<T>::insert(when, agenda);1007 } else {1008 Agenda::<T>::remove(when);1009 }1010 postponed == 01011 }10121013 /// Service (i.e. execute) the given task, being careful not to overflow the `weight` counter.1014 ///1015 /// This involves:1016 /// - removing and potentially replacing the `Lookup` entry for the task.1017 /// - realizing the task's call which can include a preimage lookup.1018 /// - Rescheduling the task for execution in a later agenda if periodic.1019 fn service_task(1020 weight: &mut WeightCounter,1021 now: T::BlockNumber,1022 when: T::BlockNumber,1023 agenda_index: u32,1024 is_first: bool,1025 mut task: ScheduledOf<T>,1026 ) -> Result<(), (ServiceTaskError, Option<ScheduledOf<T>>)> {1027 let (call, lookup_len) = match T::Preimages::peek(&task.call) {1028 Ok(c) => c,1029 Err(_) => {1030 if let Some(ref id) = task.maybe_id {1031 Lookup::<T>::remove(id);1032 }10331034 return Err((Unavailable, Some(task)));1035 }1036 };10371038 weight.check_accrue(T::WeightInfo::service_task(1039 lookup_len.map(|x| x as usize),1040 task.maybe_id.is_some(),1041 task.maybe_periodic.is_some(),1042 ));10431044 match Self::execute_dispatch(weight, task.origin.clone(), call) {1045 Err(Unavailable) => {1046 debug_assert!(false, "Checked to exist with `peek`");10471048 if let Some(ref id) = task.maybe_id {1049 Lookup::<T>::remove(id);1050 }10511052 Self::deposit_event(Event::CallUnavailable {1053 task: (when, agenda_index),1054 id: task.maybe_id,1055 });1056 Err((Unavailable, Some(task)))1057 }1058 Err(Overweight) if is_first && !Self::is_runtime_upgraded() => {1059 T::Preimages::drop(&task.call);10601061 if let Some(ref id) = task.maybe_id {1062 Lookup::<T>::remove(id);1063 }10641065 Self::deposit_event(Event::PermanentlyOverweight {1066 task: (when, agenda_index),1067 id: task.maybe_id,1068 });1069 Err((Unavailable, Some(task)))1070 }1071 Err(Overweight) => {1072 // Preserve Lookup -- the task will be postponed.1073 Err((Overweight, Some(task)))1074 }1075 Ok(result) => {1076 Self::deposit_event(Event::Dispatched {1077 task: (when, agenda_index),1078 id: task.maybe_id,1079 result,1080 });10811082 let is_canceled = task1083 .maybe_id1084 .as_ref()1085 .map(|id| !Lookup::<T>::contains_key(id))1086 .unwrap_or(false);10871088 match &task.maybe_periodic {1089 &Some((period, count)) if !is_canceled => {1090 if count > 1 {1091 task.maybe_periodic = Some((period, count - 1));1092 } else {1093 task.maybe_periodic = None;1094 }1095 let wake = now.saturating_add(period);1096 Self::mandatory_place_task(wake, task);1097 }1098 _ => {1099 if let Some(ref id) = task.maybe_id {1100 Lookup::<T>::remove(id);1101 }11021103 T::Preimages::drop(&task.call)1104 }1105 }1106 Ok(())1107 }1108 }1109 }11101111 fn is_runtime_upgraded() -> bool {1112 let last = system::LastRuntimeUpgrade::<T>::get();1113 let current = T::Version::get();11141115 last.map(|v| v.was_upgraded(¤t)).unwrap_or(true)1116 }11171118 /// Make a dispatch to the given `call` from the given `origin`, ensuring that the `weight`1119 /// counter does not exceed its limit and that it is counted accurately (e.g. accounted using1120 /// post info if available).1121 ///1122 /// NOTE: Only the weight for this function will be counted (origin lookup, dispatch and the1123 /// call itself).1124 fn execute_dispatch(1125 weight: &mut WeightCounter,1126 origin: T::PalletsOrigin,1127 call: <T as Config>::RuntimeCall,1128 ) -> Result<DispatchResult, ServiceTaskError> {1129 let dispatch_origin: <T as Config>::RuntimeOrigin = origin.into();1130 let base_weight = match dispatch_origin.clone().as_signed() {1131 Some(_) => T::WeightInfo::execute_dispatch_signed(),1132 _ => T::WeightInfo::execute_dispatch_unsigned(),1133 };1134 let call_weight = call.get_dispatch_info().weight;1135 // We only allow a scheduled call if it cannot push the weight past the limit.1136 let max_weight = base_weight.saturating_add(call_weight);11371138 if !weight.can_accrue(max_weight) {1139 return Err(Overweight);1140 }11411142 let ensured_origin = T::ScheduleOrigin::ensure_origin(dispatch_origin.into());11431144 let r = match ensured_origin {1145 Ok(ScheduledEnsureOriginSuccess::Root) => {1146 Ok(call.dispatch_bypass_filter(frame_system::RawOrigin::Root.into()))1147 }1148 Ok(ScheduledEnsureOriginSuccess::Signed(sender)) => {1149 // Execute transaction via chain default pipeline1150 // That means dispatch will be processed like any user's extrinsic e.g. transaction fees will be taken1151 T::CallExecutor::dispatch_call(Some(sender), call.clone())1152 }1153 Err(e) => Ok(Err(e.into())),1154 };11551156 let (maybe_actual_call_weight, result) = match r {1157 Ok(result) => match result {1158 Ok(post_info) => (post_info.actual_weight, Ok(())),1159 Err(error_and_info) => (1160 error_and_info.post_info.actual_weight,1161 Err(error_and_info.error),1162 ),1163 },1164 Err(_) => {1165 log::error!(1166 target: "runtime::scheduler",1167 "Warning: Scheduler has failed to execute a post-dispatch transaction. \1168 This block might have become invalid.");1169 (None, Err(DispatchError::CannotLookup))1170 }1171 };1172 let call_weight = maybe_actual_call_weight.unwrap_or(call_weight);1173 weight.check_accrue(base_weight);1174 weight.check_accrue(call_weight);1175 Ok(result)1176 }1177}