blockworx_store/storage/

erased.rs

//! A storage whose kind is known only at run time.
//!
//! [`Storage`] answers futures of its own making, which is what keeps a
//! ready one free of an allocation per read — and what stops it being a
//! trait object. The editor's document handle holds one container without
//! caring where its bytes are, so it holds an [`Any`]: the same trait, one
//! box deep.

use core::future::Future;
use core::pin::Pin;
use std::path::Path;

use super::{Entry, Name, Residency, Storage};
use crate::lock::Claim;
use crate::record::WallTime;

type Answer<'a, T> = Pin<Box<dyn Future<Output = T> + 'a>>;

trait Erased {
    fn name(&self) -> Name;
    fn names(&self, at: &Entry) -> String;
    fn residency(&self) -> Residency;
    fn disk_path(&self) -> Option<&Path>;
    fn read<'a>(&'a self, at: &'a Entry) -> Answer<'a, std::io::Result<Option<Vec<u8>>>>;
    fn exists<'a>(&'a self, at: &'a Entry) -> Answer<'a, std::io::Result<bool>>;
    fn write<'a>(&'a self, at: &'a Entry, bytes: &'a [u8]) -> Answer<'a, std::io::Result<()>>;
    fn append<'a>(&'a self, at: &'a Entry, bytes: &'a [u8]) -> Answer<'a, std::io::Result<()>>;
    fn truncate<'a>(&'a self, at: &'a Entry, len: u64) -> Answer<'a, std::io::Result<()>>;
    fn list<'a>(&'a self, dir: &'a Entry) -> Answer<'a, std::io::Result<Vec<String>>>;
    fn remove<'a>(&'a self, at: &'a Entry) -> Answer<'a, std::io::Result<()>>;
    fn create_dir<'a>(&'a self, dir: &'a Entry) -> Answer<'a, std::io::Result<()>>;
    fn rename<'a>(&'a mut self, to: &'a Name) -> Answer<'a, std::io::Result<()>>;
    fn discard(&self) -> Answer<'_, std::io::Result<()>>;
    fn claim(&self, now: WallTime) -> Answer<'_, std::io::Result<Claim>>;
    fn release(&self);
}

impl<S: Storage> Erased for S {
    fn name(&self) -> Name {
        Storage::name(self)
    }
    fn names(&self, at: &Entry) -> String {
        Storage::names(self, at)
    }
    fn residency(&self) -> Residency {
        Storage::residency(self)
    }
    fn disk_path(&self) -> Option<&Path> {
        Storage::disk_path(self)
    }
    fn read<'a>(&'a self, at: &'a Entry) -> Answer<'a, std::io::Result<Option<Vec<u8>>>> {
        Box::pin(Storage::read(self, at))
    }
    fn exists<'a>(&'a self, at: &'a Entry) -> Answer<'a, std::io::Result<bool>> {
        Box::pin(Storage::exists(self, at))
    }
    fn write<'a>(&'a self, at: &'a Entry, bytes: &'a [u8]) -> Answer<'a, std::io::Result<()>> {
        Box::pin(Storage::write(self, at, bytes))
    }
    fn append<'a>(&'a self, at: &'a Entry, bytes: &'a [u8]) -> Answer<'a, std::io::Result<()>> {
        Box::pin(Storage::append(self, at, bytes))
    }
    fn truncate<'a>(&'a self, at: &'a Entry, len: u64) -> Answer<'a, std::io::Result<()>> {
        Box::pin(Storage::truncate(self, at, len))
    }
    fn list<'a>(&'a self, dir: &'a Entry) -> Answer<'a, std::io::Result<Vec<String>>> {
        Box::pin(Storage::list(self, dir))
    }
    fn remove<'a>(&'a self, at: &'a Entry) -> Answer<'a, std::io::Result<()>> {
        Box::pin(Storage::remove(self, at))
    }
    fn create_dir<'a>(&'a self, dir: &'a Entry) -> Answer<'a, std::io::Result<()>> {
        Box::pin(Storage::create_dir(self, dir))
    }
    fn rename<'a>(&'a mut self, to: &'a Name) -> Answer<'a, std::io::Result<()>> {
        Box::pin(Storage::rename(self, to))
    }
    fn discard(&self) -> Answer<'_, std::io::Result<()>> {
        Box::pin(Storage::discard(self))
    }
    fn claim(&self, now: WallTime) -> Answer<'_, std::io::Result<Claim>> {
        Box::pin(Storage::claim(self, now))
    }
    fn release(&self) {
        Storage::release(self);
    }
}

/// One container's bytes, wherever they are.
pub struct Any(Box<dyn Erased>);

impl Any {
    pub fn new(storage: impl Storage + 'static) -> Self {
        Self(Box::new(storage))
    }
}

impl std::fmt::Debug for Any {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "storage for {}", self.0.name())
    }
}

impl Storage for Any {
    fn name(&self) -> Name {
        self.0.name()
    }
    fn names(&self, at: &Entry) -> String {
        self.0.names(at)
    }
    fn residency(&self) -> Residency {
        self.0.residency()
    }
    fn disk_path(&self) -> Option<&Path> {
        self.0.disk_path()
    }
    fn read<'a>(
        &'a self,
        at: &'a Entry,
    ) -> impl Future<Output = std::io::Result<Option<Vec<u8>>>> + 'a {
        self.0.read(at)
    }
    fn exists<'a>(&'a self, at: &'a Entry) -> impl Future<Output = std::io::Result<bool>> + 'a {
        self.0.exists(at)
    }
    fn write<'a>(
        &'a self,
        at: &'a Entry,
        bytes: &'a [u8],
    ) -> impl Future<Output = std::io::Result<()>> + 'a {
        self.0.write(at, bytes)
    }
    fn append<'a>(
        &'a self,
        at: &'a Entry,
        bytes: &'a [u8],
    ) -> impl Future<Output = std::io::Result<()>> + 'a {
        self.0.append(at, bytes)
    }
    fn truncate<'a>(
        &'a self,
        at: &'a Entry,
        len: u64,
    ) -> impl Future<Output = std::io::Result<()>> + 'a {
        self.0.truncate(at, len)
    }
    fn list<'a>(
        &'a self,
        dir: &'a Entry,
    ) -> impl Future<Output = std::io::Result<Vec<String>>> + 'a {
        self.0.list(dir)
    }
    fn remove<'a>(&'a self, at: &'a Entry) -> impl Future<Output = std::io::Result<()>> + 'a {
        self.0.remove(at)
    }
    fn create_dir<'a>(&'a self, dir: &'a Entry) -> impl Future<Output = std::io::Result<()>> + 'a {
        self.0.create_dir(dir)
    }
    fn rename<'a>(&'a mut self, to: &'a Name) -> impl Future<Output = std::io::Result<()>> + 'a {
        self.0.rename(to)
    }
    fn discard(&self) -> impl Future<Output = std::io::Result<()>> + '_ {
        self.0.discard()
    }
    fn claim(&self, now: WallTime) -> impl Future<Output = std::io::Result<Claim>> + '_ {
        self.0.claim(now)
    }
    fn release(&self) {
        self.0.release();
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::container::LOCK;
    use crate::fixture::block_on;
    use crate::lock::Claim;
    use crate::record::WallTime;
    use crate::storage::{Memory, ready_now};

    /// The box is the only difference: what a storage answers through it
    /// is what it answers directly.
    #[test]
    fn a_boxed_storage_answers_as_the_one_inside_it() {
        let held = Any::new(Memory::new("doc.bwx"));
        let notes = Entry::fixed("notes.txt");
        ready_now(Storage::write(&held, &notes, b"kept")).expect("the write lands");

        assert_eq!(
            ready_now(Storage::read(&held, &notes)).expect("it reads back"),
            Some(b"kept".to_vec()),
        );
        assert_eq!(Storage::name(&held).to_string(), "doc.bwx");
        assert_eq!(Storage::residency(&held), Residency::Lazy);
        assert_eq!(Storage::disk_path(&held), None);
    }

    /// The lock travels through the box as the reads do: a storage whose
    /// host keeps its lock is not made to write a lock entry by being
    /// boxed, which is the one thing the editor's own handle would hide.
    #[test]
    fn a_boxed_storage_is_locked_the_way_the_one_inside_it_is() {
        let held = Any::new(Memory::deferred("doc.bwx"));
        assert!(matches!(
            block_on(Storage::claim(&held, WallTime::EPOCH)).expect("the claim"),
            Claim::Taken,
        ));
        assert_eq!(
            block_on(Storage::read(&held, &LOCK)).expect("the read answers"),
            None,
            "the box wrote a lock entry the storage inside it has no use for",
        );

        assert!(matches!(
            block_on(Storage::claim(&held, WallTime::EPOCH)).expect("the claim"),
            Claim::Held(_),
        ));
        Storage::release(&held);
        assert!(matches!(
            block_on(Storage::claim(&held, WallTime::EPOCH)).expect("the claim"),
            Claim::Taken,
        ));
    }
}