1use crate::authorization::Policy;
4use crate::authorization::PolicyError;
5use crate::connection::HostSql;
6use panic_as_error::locks::lock_unpoisoned;
7use std::sync::{Condvar, Mutex};
8
9pub(super) struct ReadPool<P: Policy> {
10 readers: Vec<Mutex<HostSql<P>>>,
11 idle_readers: Mutex<Vec<usize>>,
12 reader_ready: Condvar,
13 #[cfg(any(test, feature = "test-utils"))]
14 waiting: Mutex<Option<tokio::sync::oneshot::Sender<()>>>,
15}
16
17impl<P: Policy> ReadPool<P> {
18 #[cfg(any(test, feature = "test-utils"))]
20 pub(super) fn each(&self, mut visit: impl FnMut(&mut HostSql<P>)) {
21 for reader in &self.readers {
22 super::with_locked(reader, |reader| visit(reader));
23 }
24 }
25
26 pub(super) fn new(readers: Vec<Mutex<HostSql<P>>>) -> Self {
27 Self {
28 idle_readers: Mutex::new((0..readers.len()).collect()),
29 readers,
30 reader_ready: Condvar::new(),
31 #[cfg(any(test, feature = "test-utils"))]
32 waiting: Mutex::new(None),
33 }
34 }
35
36 pub(super) fn close(self) -> Vec<PolicyError<P>> {
37 let mut failures = Vec::new();
38 for reader in self.readers {
39 if let Err(error) = panic_as_error::locks::into_unpoisoned(reader).close() {
40 failures.push(error);
41 }
42 }
43 failures
44 }
45
46 pub(super) fn acquire_reader(&self) -> Reader<'_, P> {
47 let mut idle = lock_unpoisoned(&self.idle_readers);
48 loop {
49 if let Some(index) = idle.pop() {
50 return Reader { pool: self, index };
51 }
52 #[cfg(any(test, feature = "test-utils"))]
53 if let Some(waiting) = lock_unpoisoned(&self.waiting).take() {
54 waiting.send(()).unwrap();
55 }
56 idle = panic_as_error::locks::wait_unpoisoned(&self.reader_ready, idle);
57 }
58 }
59}
60
61pub struct Reader<'a, P: Policy> {
65 pool: &'a ReadPool<P>,
66 index: usize,
67}
68
69impl<P: Policy> Reader<'_, P> {
70 pub fn host<R>(&self, read: impl FnOnce(&HostSql<P>) -> R) -> R {
72 super::with_locked(&self.pool.readers[self.index], |reader| read(reader))
73 }
74}
75
76impl<P: Policy> Drop for Reader<'_, P> {
77 fn drop(&mut self) {
78 lock_unpoisoned(&self.pool.idle_readers).push(self.index);
79 self.pool.reader_ready.notify_one();
80 }
81}
82
83#[cfg(any(test, feature = "test-utils"))]
84impl<P: Policy> ReadPool<P> {
85 pub(super) fn observe_next_wait(&self) -> tokio::sync::oneshot::Receiver<()> {
88 let (sender, receiver) = tokio::sync::oneshot::channel();
89 assert!(lock_unpoisoned(&self.waiting).replace(sender).is_none());
90 receiver
91 }
92}