lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

tasks.rs (4988B)


      1 //! One bounded mechanical task owner; command semantics stay in execution.
      2 use futures::{future::poll_fn, task::AtomicWaker};
      3 use radroots_execution::{
      4     Code, Error, OperationContext, RetryClass,
      5     session::{HostFuture, tasks::TaskHost},
      6 };
      7 use radroots_signing::host::Shared;
      8 use std::{collections::VecDeque, sync::Mutex, task::Poll};
      9 
     10 const CAPACITY: usize = 32;
     11 fn unavailable() -> Error {
     12     Error::new(
     13         Code::CapabilityUnavailable,
     14         OperationContext::proposed(None),
     15         RetryClass::Never,
     16         None,
     17     )
     18     .unwrap_or_else(|_| unreachable!("valid constant task error"))
     19 }
     20 #[derive(Default)]
     21 struct State {
     22     started: bool,
     23     // Every stop/close path sets this irreversible admission flag first.
     24     quiesced: bool,
     25     stopping: bool,
     26     closed: bool,
     27     active: bool,
     28     queue: VecDeque<HostFuture<'static, ()>>,
     29 }
     30 #[derive(Default)]
     31 struct Inner {
     32     state: Mutex<State>,
     33     actor: AtomicWaker,
     34     drained: AtomicWaker,
     35     closed: AtomicWaker,
     36 }
     37 #[derive(Default)]
     38 pub(crate) struct OwnedTasks {
     39     inner: Shared<Inner>,
     40 }
     41 impl OwnedTasks {
     42     pub(crate) fn start(&self, spawn: impl FnOnce(HostFuture<'static, ()>)) -> crate::Result<()> {
     43         {
     44             let mut state = self.inner.state.lock().map_err(|_| unavailable())?;
     45             if state.quiesced {
     46                 return Err(unavailable());
     47             }
     48             if state.started {
     49                 return Ok(());
     50             }
     51             state.started = true;
     52         }
     53         let inner = self.inner.clone();
     54         spawn(Box::pin(async move {
     55             loop {
     56                 let next: crate::Result<Option<HostFuture<'static, ()>>> = poll_fn(|cx| {
     57                     inner.actor.register(cx.waker());
     58                     let mut state = inner.state.lock().map_err(|_| unavailable())?;
     59                     if let Some(task) = state.queue.pop_front() {
     60                         state.active = true;
     61                         Poll::Ready(Ok(Some(task)))
     62                     } else if state.stopping {
     63                         state.closed = true;
     64                         Poll::Ready(Ok(None))
     65                     } else {
     66                         Poll::Pending
     67                     }
     68                 })
     69                 .await;
     70                 match next {
     71                     Ok(Some(task)) => {
     72                         task.await;
     73                         let Ok(mut state) = inner.state.lock() else {
     74                             break;
     75                         };
     76                         state.active = false;
     77                         drop(state);
     78                         inner.drained.wake();
     79                     }
     80                     Ok(None) | Err(_) => break,
     81                 }
     82             }
     83             inner.closed.wake();
     84             inner.drained.wake();
     85         }));
     86         Ok(())
     87     }
     88     pub(crate) fn quiesce(&self) -> crate::Result<()> {
     89         self.inner.state.lock().map_err(|_| unavailable())?.quiesced = true;
     90         Ok(())
     91     }
     92     pub(crate) async fn drain(&self) -> crate::Result<()> {
     93         poll_fn(|cx| {
     94             self.inner.drained.register(cx.waker());
     95             let idle = {
     96                 let state = self.inner.state.lock().map_err(|_| unavailable())?;
     97                 !state.active && state.queue.is_empty()
     98             };
     99             if idle {
    100                 self.inner.drained.take();
    101                 Poll::Ready(Ok(()))
    102             } else {
    103                 Poll::Pending
    104             }
    105         })
    106         .await
    107     }
    108     pub(crate) async fn close(&self) -> crate::Result<()> {
    109         {
    110             let mut state = self.inner.state.lock().map_err(|_| unavailable())?;
    111             state.quiesced = true;
    112             state.stopping = true;
    113             if !state.started {
    114                 state.closed = true;
    115             }
    116         }
    117         self.inner.actor.wake();
    118         poll_fn(|cx| {
    119             self.inner.closed.register(cx.waker());
    120             let closed = self.inner.state.lock().map_err(|_| unavailable())?.closed;
    121             if closed {
    122                 self.inner.closed.take();
    123                 Poll::Ready(Ok(()))
    124             } else {
    125                 Poll::Pending
    126             }
    127         })
    128         .await
    129     }
    130 }
    131 impl TaskHost for OwnedTasks {
    132     fn submit(&self, task: HostFuture<'static, ()>) -> crate::Result<()> {
    133         {
    134             let mut state = self.inner.state.lock().map_err(|_| unavailable())?;
    135             if !state.started
    136                 || state.quiesced
    137                 || state.queue.len() + usize::from(state.active) >= CAPACITY
    138             {
    139                 return Err(unavailable());
    140             }
    141             state.queue.push_back(task);
    142         }
    143         self.inner.actor.wake();
    144         Ok(())
    145     }
    146 }
    147 impl Drop for OwnedTasks {
    148     fn drop(&mut self) {
    149         if let Ok(mut state) = self.inner.state.lock() {
    150             state.quiesced = true;
    151             state.stopping = true;
    152         }
    153         self.inner.actor.wake();
    154     }
    155 }
    156 
    157 #[cfg(test)]
    158 #[path = "tasks_tests.rs"]
    159 mod tests;