git.delta.rocks / unique-network / refs/commits / 67ae8db02ffa

1// 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, RawOrigin,82	},83	ensure,84	traits::{85		schedule::{self, DispatchTime},86		EnsureOrigin, Get, IsType, OriginTrait,87		PalletInfoAccess, PrivilegeCmp, StorageVersion,88        PreimageProvider, PreimageRecipient, ConstU32,89	},90	weights::Weight,91};9293use frame_system::{self as system};94use scale_info::TypeInfo;95use sp_io::hashing::blake2_256;96use sp_runtime::{97	traits::{BadOrigin, One, Saturating, Zero, Hash},98	BoundedVec, RuntimeDebug,99};100use sp_std::{borrow::Borrow, cmp::Ordering, marker::PhantomData, prelude::*};101pub use weights::WeightInfo;102103pub use pallet::*;104105/// Just a simple index for naming period tasks.106pub type PeriodicIndex = u32;107/// The location of a scheduled task that can be used to remove it.108pub type TaskAddress<BlockNumber> = (BlockNumber, u32);109110pub type EncodedCall = BoundedVec<u8, ConstU32<128>>;111112#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]113#[scale_info(skip_type_params(T))]114pub enum ScheduledCall<T: Config> {115    Inline(EncodedCall),116    PreimageLookup {117        hash: T::Hash,118        unbounded_len: u32,119    },120}121122impl<T: Config> ScheduledCall<T> {123	pub fn new(call: <T as Config>::Call) -> Result<Self, DispatchError> {124		let encoded = call.encode();125		let len = encoded.len();126127		match EncodedCall::try_from(encoded.clone()) {128			Ok(bounded) => Ok(Self::Inline(bounded)),129			Err(_) => {130				let hash = <T as system::Config>::Hashing::hash_of(&encoded);131				<T as Config>::Preimages::note_preimage(encoded.try_into().map_err(|_| <Error<T>>::TooBigScheduledCall)?);132133				Ok(Self::PreimageLookup { hash, unbounded_len: len as u32 })134			}135		}136	}137138	/// The maximum length of the lookup that is needed to peek `Self`.139	pub fn lookup_len(&self) -> Option<u32> {140		match self {141			Self::Inline(..) => None,142			Self::PreimageLookup { unbounded_len, .. } => Some(*unbounded_len),143		}144	}145146	fn decode(mut data: &[u8]) -> Result<<T as Config>::Call, DispatchError> {147		<T as Config>::Call::decode(&mut data)148				.map_err(|_| <Error<T>>::ScheduledCallCorrupted.into())149	}150}151152pub trait SchedulerPreimages<T: Config>: PreimageRecipient<T::Hash> {153    fn drop(call: &ScheduledCall<T>);154155	fn peek(call: &ScheduledCall<T>) -> Result<(<T as pallet::Config>::Call, Option<u32>), DispatchError>;156}157158impl<T: Config, PP: PreimageRecipient<T::Hash>> SchedulerPreimages<T> for PP {159    fn drop(call: &ScheduledCall<T>) {160        match call {161            ScheduledCall::Inline(_) => {},162            ScheduledCall::PreimageLookup { hash, .. } => Self::unrequest_preimage(hash),163        }164    }165166	fn peek(call: &ScheduledCall<T>) -> Result<(<T as pallet::Config>::Call, Option<u32>), DispatchError> {167		match call {168			ScheduledCall::Inline(data) => Ok((ScheduledCall::<T>::decode(data)?, None)),169			ScheduledCall::PreimageLookup { hash, unbounded_len } => {170				let (preimage, len) = Self::get_preimage(hash)171					.ok_or(<Error<T>>::PreimageNotFound)172					.map(|preimage| (preimage, *unbounded_len))?;173174				Ok((ScheduledCall::<T>::decode(preimage.as_slice())?, Some(len)))175			},176		}177	}178}179180pub type TaskName = [u8; 32];181182/// Information regarding an item to be executed in the future.183#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]184#[derive(Clone, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]185pub struct Scheduled<Name, Call, BlockNumber, PalletsOrigin, AccountId> {186	/// The unique identity for this task, if there is one.187	maybe_id: Option<Name>,188189    /// This task's priority.190	priority: schedule::Priority,191192    /// The call to be dispatched.193	call: Call,194195    /// If the call is periodic, then this points to the information concerning that.196	maybe_periodic: Option<schedule::Period<BlockNumber>>,197198    /// The origin with which to dispatch the call.199	origin: PalletsOrigin,200	_phantom: PhantomData<AccountId>,201}202203pub type ScheduledOf<T> = Scheduled<204	TaskName,205	ScheduledCall<T>,206	<T as frame_system::Config>::BlockNumber,207	<T as Config>::PalletsOrigin,208	<T as frame_system::Config>::AccountId,209>;210211struct WeightCounter {212	used: Weight,213	limit: Weight,214}215216impl WeightCounter {217	fn check_accrue(&mut self, w: Weight) -> bool {218		let test = self.used.saturating_add(w);219		if test > self.limit {220			false221		} else {222			self.used = test;223			true224		}225	}226227	fn can_accrue(&mut self, w: Weight) -> bool {228		self.used.saturating_add(w) <= self.limit229	}230}231232pub(crate) trait MarginalWeightInfo: WeightInfo {233	fn service_task(maybe_lookup_len: Option<usize>, named: bool, periodic: bool) -> Weight {234		let base = Self::service_task_base();235		let mut total = match maybe_lookup_len {236			None => base,237			Some(l) => Self::service_task_fetched(l as u32),238		};239		if named {240			total.saturating_accrue(Self::service_task_named().saturating_sub(base));241		}242		if periodic {243			total.saturating_accrue(Self::service_task_periodic().saturating_sub(base));244		}245		total246	}247}248249impl<T: WeightInfo> MarginalWeightInfo for T {}250251#[frame_support::pallet]252pub mod pallet {253	use super::*;254	use frame_support::{dispatch::PostDispatchInfo, pallet_prelude::*};255	use system::pallet_prelude::*;256257	/// The current storage version.258	const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);259260    #[pallet::pallet]261	#[pallet::generate_store(pub(super) trait Store)]262	#[pallet::storage_version(STORAGE_VERSION)]263	pub struct Pallet<T>(_);264265	#[pallet::config]266	pub trait Config: frame_system::Config {267        type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;268269        /// The aggregated origin which the dispatch will take.270		type Origin: OriginTrait<PalletsOrigin = Self::PalletsOrigin>271            + From<Self::PalletsOrigin>272            + IsType<<Self as system::Config>::Origin>273			+ Clone;274275        /// The caller origin, overarching type of all pallets origins.276        type PalletsOrigin: From<system::RawOrigin<Self::AccountId>>277            + Codec278            + Clone279            + Eq280            + TypeInfo281            + MaxEncodedLen;282283        /// The aggregated call type.284        type Call: Parameter285            + Dispatchable<286                Origin = <Self as Config>::Origin,287                PostInfo = PostDispatchInfo,288            > + GetDispatchInfo289            + From<system::Call<Self>>;290291        /// The maximum weight that may be scheduled per block for any dispatchables.292        #[pallet::constant]293        type MaximumWeight: Get<Weight>;294295        /// Required origin to schedule or cancel calls.296        type ScheduleOrigin: EnsureOrigin<<Self as system::Config>::Origin>;297298        /// Compare the privileges of origins.299        ///300        /// This will be used when canceling a task, to ensure that the origin that tries301        /// to cancel has greater or equal privileges as the origin that created the scheduled task.302        ///303        /// For simplicity the [`EqualPrivilegeOnly`](frame_support::traits::EqualPrivilegeOnly) can304        /// be used. This will only check if two given origins are equal.305        type OriginPrivilegeCmp: PrivilegeCmp<Self::PalletsOrigin>;306307        /// The maximum number of scheduled calls in the queue for a single block.308        #[pallet::constant]309        type MaxScheduledPerBlock: Get<u32>;310311        /// Weight information for extrinsics in this pallet.312        type WeightInfo: WeightInfo;313314        /// The preimage provider with which we look up call hashes to get the call.315		type Preimages: SchedulerPreimages<Self>;316    }317318    #[pallet::storage]319	pub type IncompleteSince<T: Config> = StorageValue<_, T::BlockNumber>;320321    /// Items to be executed, indexed by the block number that they should be executed on.322	#[pallet::storage]323	pub type Agenda<T: Config> = StorageMap<324		_,325		Twox64Concat,326		T::BlockNumber,327		BoundedVec<Option<ScheduledOf<T>>, T::MaxScheduledPerBlock>,328		ValueQuery,329	>;330331    /// Lookup from a name to the block number and index of the task.332	#[pallet::storage]333	pub(crate) type Lookup<T: Config> =334		StorageMap<_, Twox64Concat, TaskName, TaskAddress<T::BlockNumber>>;335336    /// Events type.337	#[pallet::event]338	#[pallet::generate_deposit(pub(super) fn deposit_event)]339	pub enum Event<T: Config> {340		/// Scheduled some task.341		Scheduled { when: T::BlockNumber, index: u32 },342		/// Canceled some task.343		Canceled { when: T::BlockNumber, index: u32 },344		/// Dispatched some task.345		Dispatched {346			task: TaskAddress<T::BlockNumber>,347			id: Option<[u8; 32]>,348			result: DispatchResult,349		},350		/// The call for the provided hash was not found so the task has been aborted.351		CallUnavailable { task: TaskAddress<T::BlockNumber>, id: Option<[u8; 32]> },352		/// The given task was unable to be renewed since the agenda is full at that block.353		PeriodicFailed { task: TaskAddress<T::BlockNumber>, id: Option<[u8; 32]> },354		/// The given task can never be executed since it is overweight.355		PermanentlyOverweight { task: TaskAddress<T::BlockNumber>, id: Option<[u8; 32]> },356	}357358    #[pallet::error]359	pub enum Error<T> {360		/// Failed to schedule a call361		FailedToSchedule,362        /// There is no place for a new task in the agenda363        AgendaIsExhausted,364		/// Scheduled call is corrupted365		ScheduledCallCorrupted,366		/// Scheduled call preimage is not found367		PreimageNotFound,368		/// Scheduled call is too big369		TooBigScheduledCall,370		/// Cannot find the scheduled call.371		NotFound,372		/// Given target block number is in the past.373		TargetBlockNumberInPast,374		/// Reschedule failed because it does not change scheduled time.375		RescheduleNoChange,376		/// Attempt to use a non-named function on a named task.377		Named,378	}379380    #[pallet::hooks]381	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {382		/// Execute the scheduled calls383		fn on_initialize(now: T::BlockNumber) -> Weight {384			let mut weight_counter =385				WeightCounter { used: Weight::zero(), limit: T::MaximumWeight::get() };386			Self::service_agendas(&mut weight_counter, now, u32::max_value());387			weight_counter.used388		}389	}390391    #[pallet::call]392	impl<T: Config> Pallet<T> {393        /// Anonymously schedule a task.394		#[pallet::weight(<T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get()))]395		pub fn schedule(396			origin: OriginFor<T>,397			when: T::BlockNumber,398			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,399			priority: schedule::Priority,400			call: Box<<T as Config>::Call>,401		) -> DispatchResult {402			T::ScheduleOrigin::ensure_origin(origin.clone())?;403			let origin = <T as Config>::Origin::from(origin);404			Self::do_schedule(405				DispatchTime::At(when),406				maybe_periodic,407				priority,408				origin.caller().clone(),409				<ScheduledCall<T>>::new(*call)?,410			)?;411			Ok(())412		}413414		/// Cancel an anonymously scheduled task.415		#[pallet::weight(<T as Config>::WeightInfo::cancel(T::MaxScheduledPerBlock::get()))]416		pub fn cancel(origin: OriginFor<T>, when: T::BlockNumber, index: u32) -> DispatchResult {417			T::ScheduleOrigin::ensure_origin(origin.clone())?;418			let origin = <T as Config>::Origin::from(origin);419			Self::do_cancel(Some(origin.caller().clone()), (when, index))?;420			Ok(())421		}422423		/// Schedule a named task.424		#[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]425		pub fn schedule_named(426			origin: OriginFor<T>,427			id: TaskName,428			when: T::BlockNumber,429			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,430			priority: schedule::Priority,431			call: Box<<T as Config>::Call>,432		) -> DispatchResult {433			T::ScheduleOrigin::ensure_origin(origin.clone())?;434			let origin = <T as Config>::Origin::from(origin);435			Self::do_schedule_named(436				id,437				DispatchTime::At(when),438				maybe_periodic,439				priority,440				origin.caller().clone(),441				<ScheduledCall<T>>::new(*call)?,442			)?;443			Ok(())444		}445446		/// Cancel a named scheduled task.447		#[pallet::weight(<T as Config>::WeightInfo::cancel_named(T::MaxScheduledPerBlock::get()))]448		pub fn cancel_named(origin: OriginFor<T>, id: TaskName) -> DispatchResult {449			T::ScheduleOrigin::ensure_origin(origin.clone())?;450			let origin = <T as Config>::Origin::from(origin);451			Self::do_cancel_named(Some(origin.caller().clone()), id)?;452			Ok(())453		}454455		/// Anonymously schedule a task after a delay.456		///457		/// # <weight>458		/// Same as [`schedule`].459		/// # </weight>460		#[pallet::weight(<T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get()))]461		pub fn schedule_after(462			origin: OriginFor<T>,463			after: T::BlockNumber,464			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,465			priority: schedule::Priority,466			call: Box<<T as Config>::Call>,467		) -> DispatchResult {468			T::ScheduleOrigin::ensure_origin(origin.clone())?;469			let origin = <T as Config>::Origin::from(origin);470			Self::do_schedule(471				DispatchTime::After(after),472				maybe_periodic,473				priority,474				origin.caller().clone(),475				<ScheduledCall<T>>::new(*call)?,476			)?;477			Ok(())478		}479480		/// Schedule a named task after a delay.481		///482		/// # <weight>483		/// Same as [`schedule_named`](Self::schedule_named).484		/// # </weight>485		#[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]486		pub fn schedule_named_after(487			origin: OriginFor<T>,488			id: TaskName,489			after: T::BlockNumber,490			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,491			priority: schedule::Priority,492			call: Box<<T as Config>::Call>,493		) -> DispatchResult {494			T::ScheduleOrigin::ensure_origin(origin.clone())?;495			let origin = <T as Config>::Origin::from(origin);496			Self::do_schedule_named(497				id,498				DispatchTime::After(after),499				maybe_periodic,500				priority,501				origin.caller().clone(),502				<ScheduledCall<T>>::new(*call)?,503			)?;504			Ok(())505		}506    }507}508509impl<T: Config> Pallet<T> {510    fn resolve_time(when: DispatchTime<T::BlockNumber>) -> Result<T::BlockNumber, DispatchError> {511		let now = frame_system::Pallet::<T>::block_number();512513		let when = match when {514			DispatchTime::At(x) => x,515			// The current block has already completed it's scheduled tasks, so516			// Schedule the task at lest one block after this current block.517			DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one()),518		};519520		if when <= now {521			return Err(Error::<T>::TargetBlockNumberInPast.into())522		}523524		Ok(when)525	}526527    fn place_task(528		when: T::BlockNumber,529		what: ScheduledOf<T>,530	) -> Result<TaskAddress<T::BlockNumber>, (DispatchError, ScheduledOf<T>)> {531		let maybe_name = what.maybe_id;532		let index = Self::push_to_agenda(when, what)?;533		let address = (when, index);534		if let Some(name) = maybe_name {535			Lookup::<T>::insert(name, address)536		}537		Self::deposit_event(Event::Scheduled { when: address.0, index: address.1 });538		Ok(address)539	}540541    fn push_to_agenda(542		when: T::BlockNumber,543		what: ScheduledOf<T>,544	) -> Result<u32, (DispatchError, ScheduledOf<T>)> {545		let mut agenda = Agenda::<T>::get(when);546		let index = if (agenda.len() as u32) < T::MaxScheduledPerBlock::get() {547			// will always succeed due to the above check.548			let _ = agenda.try_push(Some(what));549			agenda.len() as u32 - 1550		} else {551			if let Some(hole_index) = agenda.iter().position(|i| i.is_none()) {552				agenda[hole_index] = Some(what);553				hole_index as u32554			} else {555				return Err((<Error<T>>::AgendaIsExhausted.into(), what))556			}557		};558		Agenda::<T>::insert(when, agenda);559		Ok(index)560	}561562    fn do_schedule(563		when: DispatchTime<T::BlockNumber>,564		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,565		priority: schedule::Priority,566		origin: T::PalletsOrigin,567		call: ScheduledCall<T>,568	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {569		let when = Self::resolve_time(when)?;570571		// sanitize maybe_periodic572		let maybe_periodic = maybe_periodic573			.filter(|p| p.1 > 1 && !p.0.is_zero())574			// Remove one from the number of repetitions since we will schedule one now.575			.map(|(p, c)| (p, c - 1));576		let task = Scheduled {577			maybe_id: None,578			priority,579			call,580			maybe_periodic,581			origin,582			_phantom: PhantomData,583		};584		Self::place_task(when, task).map_err(|x| x.0)585	}586587    fn do_cancel(588		origin: Option<T::PalletsOrigin>,589		(when, index): TaskAddress<T::BlockNumber>,590	) -> Result<(), DispatchError> {591		let scheduled = Agenda::<T>::try_mutate(when, |agenda| {592			agenda.get_mut(index as usize).map_or(593				Ok(None),594				|s| -> Result<Option<Scheduled<_, _, _, _, _>>, DispatchError> {595					if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {596						if matches!(597							T::OriginPrivilegeCmp::cmp_privilege(o, &s.origin),598							Some(Ordering::Less) | None599						) {600							return Err(BadOrigin.into())601						}602					};603					Ok(s.take())604				},605			)606		})?;607		if let Some(s) = scheduled {608            T::Preimages::drop(&s.call);609610			if let Some(id) = s.maybe_id {611				Lookup::<T>::remove(id);612			}613			Self::deposit_event(Event::Canceled { when, index });614			Ok(())615		} else {616			return Err(Error::<T>::NotFound.into())617		}618	}619620    fn do_schedule_named(621		id: TaskName,622		when: DispatchTime<T::BlockNumber>,623		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,624		priority: schedule::Priority,625		origin: T::PalletsOrigin,626		call: ScheduledCall<T>,627	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {628		// ensure id it is unique629		if Lookup::<T>::contains_key(&id) {630			return Err(Error::<T>::FailedToSchedule.into())631		}632633		let when = Self::resolve_time(when)?;634635		// sanitize maybe_periodic636		let maybe_periodic = maybe_periodic637			.filter(|p| p.1 > 1 && !p.0.is_zero())638			// Remove one from the number of repetitions since we will schedule one now.639			.map(|(p, c)| (p, c - 1));640641		let task = Scheduled {642			maybe_id: Some(id),643			priority,644			call,645			maybe_periodic,646			origin,647			_phantom: Default::default(),648		};649		Self::place_task(when, task).map_err(|x| x.0)650	}651652    fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: TaskName) -> DispatchResult {653		Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {654			if let Some((when, index)) = lookup.take() {655				let i = index as usize;656				Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {657					if let Some(s) = agenda.get_mut(i) {658						if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {659							if matches!(660								T::OriginPrivilegeCmp::cmp_privilege(o, &s.origin),661								Some(Ordering::Less) | None662							) {663								return Err(BadOrigin.into())664							}665							T::Preimages::drop(&s.call);666						}667						*s = None;668					}669					Ok(())670				})?;671				Self::deposit_event(Event::Canceled { when, index });672				Ok(())673			} else {674				return Err(Error::<T>::NotFound.into())675			}676		})677	}678}679680enum ServiceTaskError {681	/// Could not be executed due to missing preimage.682	Unavailable,683	/// Could not be executed due to weight limitations.684	Overweight,685}686use ServiceTaskError::*;687688impl<T: Config> Pallet<T> {689	/// Service up to `max` agendas queue starting from earliest incompletely executed agenda.690	fn service_agendas(weight: &mut WeightCounter, now: T::BlockNumber, max: u32) {691		if !weight.check_accrue(T::WeightInfo::service_agendas_base()) {692			return693		}694695		let mut incomplete_since = now + One::one();696		let mut when = IncompleteSince::<T>::take().unwrap_or(now);697		let mut executed = 0;698699		let max_items = T::MaxScheduledPerBlock::get();700		let mut count_down = max;701		let service_agenda_base_weight = T::WeightInfo::service_agenda_base(max_items);702		while count_down > 0 && when <= now && weight.can_accrue(service_agenda_base_weight) {703			if !Self::service_agenda(weight, &mut executed, now, when, u32::max_value()) {704				incomplete_since = incomplete_since.min(when);705			}706			when.saturating_inc();707			count_down.saturating_dec();708		}709		incomplete_since = incomplete_since.min(when);710		if incomplete_since <= now {711			IncompleteSince::<T>::put(incomplete_since);712		}713	}714715	/// Returns `true` if the agenda was fully completed, `false` if it should be revisited at a716	/// later block.717	fn service_agenda(718		weight: &mut WeightCounter,719		executed: &mut u32,720		now: T::BlockNumber,721		when: T::BlockNumber,722		max: u32,723	) -> bool {724		let mut agenda = Agenda::<T>::get(when);725		let mut ordered = agenda726			.iter()727			.enumerate()728			.filter_map(|(index, maybe_item)| {729				maybe_item.as_ref().map(|item| (index as u32, item.priority))730			})731			.collect::<Vec<_>>();732		ordered.sort_by_key(|k| k.1);733		let within_limit =734			weight.check_accrue(T::WeightInfo::service_agenda_base(ordered.len() as u32));735		debug_assert!(within_limit, "weight limit should have been checked in advance");736737		// Items which we know can be executed and have postponed for execution in a later block.738		let mut postponed = (ordered.len() as u32).saturating_sub(max);739		// Items which we don't know can ever be executed.740		let mut dropped = 0;741742		for (agenda_index, _) in ordered.into_iter().take(max as usize) {743			let task = match agenda[agenda_index as usize].take() {744				None => continue,745				Some(t) => t,746			};747			let base_weight = T::WeightInfo::service_task(748				task.call.lookup_len().map(|x| x as usize),749				task.maybe_id.is_some(),750				task.maybe_periodic.is_some(),751			);752			if !weight.can_accrue(base_weight) {753				postponed += 1;754				break755			}756			let result = Self::service_task(weight, now, when, agenda_index, *executed == 0, task);757			agenda[agenda_index as usize] = match result {758				Err((Unavailable, slot)) => {759					dropped += 1;760					slot761				},762				Err((Overweight, slot)) => {763					postponed += 1;764					slot765				},766				Ok(()) => {767					*executed += 1;768					None769				},770			};771		}772		if postponed > 0 || dropped > 0 {773			Agenda::<T>::insert(when, agenda);774		} else {775			Agenda::<T>::remove(when);776		}777		postponed == 0778	}779780	/// Service (i.e. execute) the given task, being careful not to overflow the `weight` counter.781	///782	/// This involves:783	/// - removing and potentially replacing the `Lookup` entry for the task.784	/// - realizing the task's call which can include a preimage lookup.785	/// - Rescheduling the task for execution in a later agenda if periodic.786	fn service_task(787		weight: &mut WeightCounter,788		now: T::BlockNumber,789		when: T::BlockNumber,790		agenda_index: u32,791		is_first: bool,792		mut task: ScheduledOf<T>,793	) -> Result<(), (ServiceTaskError, Option<ScheduledOf<T>>)> {794		if let Some(ref id) = task.maybe_id {795			Lookup::<T>::remove(id);796		}797798		let (call, lookup_len) = match T::Preimages::peek(&task.call) {799			Ok(c) => c,800			Err(_) => return Err((Unavailable, Some(task))),801		};802803		weight.check_accrue(T::WeightInfo::service_task(804			lookup_len.map(|x| x as usize),805			task.maybe_id.is_some(),806			task.maybe_periodic.is_some(),807		));808809		match Self::execute_dispatch(weight, task.origin.clone(), call) {810			Err(Unavailable) => {811				debug_assert!(false, "Checked to exist with `peek`");812				Self::deposit_event(Event::CallUnavailable {813					task: (when, agenda_index),814					id: task.maybe_id,815				});816				Err((Unavailable, Some(task)))817			},818			Err(Overweight) if is_first => {819				T::Preimages::drop(&task.call);820				Self::deposit_event(Event::PermanentlyOverweight {821					task: (when, agenda_index),822					id: task.maybe_id,823				});824				Err((Unavailable, Some(task)))825			},826			Err(Overweight) => Err((Overweight, Some(task))),827			Ok(result) => {828				Self::deposit_event(Event::Dispatched {829					task: (when, agenda_index),830					id: task.maybe_id,831					result,832				});833				if let &Some((period, count)) = &task.maybe_periodic {834					if count > 1 {835						task.maybe_periodic = Some((period, count - 1));836					} else {837						task.maybe_periodic = None;838					}839					let wake = now.saturating_add(period);840					match Self::place_task(wake, task) {841						Ok(_) => {},842						Err((_, task)) => {843							// TODO: Leave task in storage somewhere for it to be rescheduled844							// manually.845							T::Preimages::drop(&task.call);846							Self::deposit_event(Event::PeriodicFailed {847								task: (when, agenda_index),848								id: task.maybe_id,849							});850						},851					}852				} else {853					T::Preimages::drop(&task.call);854				}855				Ok(())856			},857		}858	}859860	/// Make a dispatch to the given `call` from the given `origin`, ensuring that the `weight`861	/// counter does not exceed its limit and that it is counted accurately (e.g. accounted using862	/// post info if available).863	///864	/// NOTE: Only the weight for this function will be counted (origin lookup, dispatch and the865	/// call itself).866	fn execute_dispatch(867		weight: &mut WeightCounter,868		origin: T::PalletsOrigin,869		call: <T as Config>::Call,870	) -> Result<DispatchResult, ServiceTaskError> {871		let dispatch_origin: <T as Config>::Origin = origin.into();872		let base_weight = match dispatch_origin.clone().as_signed() {873			Some(_) => T::WeightInfo::execute_dispatch_signed(),874			_ => T::WeightInfo::execute_dispatch_unsigned(),875		};876		let call_weight = call.get_dispatch_info().weight;877		// We only allow a scheduled call if it cannot push the weight past the limit.878		let max_weight = base_weight.saturating_add(call_weight);879880		if !weight.can_accrue(max_weight) {881			return Err(Overweight)882		}883884		let (maybe_actual_call_weight, result) = match call.dispatch(dispatch_origin) {885			Ok(post_info) => (post_info.actual_weight, Ok(())),886			Err(error_and_info) =>887				(error_and_info.post_info.actual_weight, Err(error_and_info.error)),888		};889		let call_weight = maybe_actual_call_weight.unwrap_or(call_weight);890		weight.check_accrue(base_weight);891		weight.check_accrue(call_weight);892		Ok(result)893	}894}