Skip to main content

sqlive/
read_pool.rs

1//! Reader reservations keep committed reads independent of the writer.
2
3use 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    /// Run `visit` on each reader in turn, under its own lock.
19    #[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
61/// One of a database's readers, reserved for its caller until it drops.
62/// Dropping it wakes a caller waiting for a reader, even when a call on it
63/// panics.
64pub struct Reader<'a, P: Policy> {
65    pool: &'a ReadPool<P>,
66    index: usize,
67}
68
69impl<P: Policy> Reader<'_, P> {
70    /// Run `read` on the reader.
71    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    /// Return a receiver that gets a message when the next caller waits for
86    /// a reader.
87    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}