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;