gcache 0.0.1

A cache group to accurate remote data access
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use std::path::{Path, PathBuf};

use bytes::Bytes;
use tokio::io::{self, AsyncRead, AsyncReadExt, AsyncSeekExt, AsyncWriteExt, SeekFrom};

use super::CacheStore;

pub struct FileStore {
    base: PathBuf,
}

impl FileStore {
    pub fn new(base: impl AsRef<Path>) -> Self {
        Self {
            base: base.as_ref().to_owned(),
        }
    }
}

impl CacheStore<Path> for FileStore {
    type Err = io::Error;
    type Reader = impl Send + AsyncRead;
    async fn fill<R>(&self, k: &Path, v: &mut R) -> Result<(), Self::Err>
    where
        R: AsyncRead + Unpin + Send,
    {
        let target = self.base.join(k);
        let mut file = tokio::fs::OpenOptions::new()
            .write(true)
            .truncate(true)
            .create(true)
            .open(target)
            .await?;
        io::copy(v, &mut file).await?;
        Ok(())
    }

    async fn get_reader<Q: ?Sized + Sync + AsRef<Path>>(
        &self,
        k: &Q,
        offset: u64,
        limit: u64,
    ) -> Result<Option<Self::Reader>, Self::Err> {
        let target = self.base.join(k);
        let file = tokio::fs::OpenOptions::new().read(true).open(target).await;
        match file {
            Ok(mut f) => {
                f.seek(SeekFrom::Start(offset)).await?;
                Ok(Some(f.take(limit)))
            }
            Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(None),
            e => e.map(|_| None),
        }
    }

    async fn evict<Q: ?Sized + Sync + AsRef<Path>>(&self, k: &Q) -> Result<(), Self::Err> {
        let target = self.base.join(k);
        tokio::fs::remove_file(target).await
    }
}

#[cfg(test)]
mod test {
    use tokio::{fs, io};

    use super::FileStore;
    use crate::CacheStore;

    #[tokio::test]
    async fn test_get() -> Result<(), io::Error> {
        let base = ".";
        let source = FileStore::new(base);
        let mut entries = fs::read_dir(base).await?;
        while let Some(e) = entries.next_entry().await? {
            if e.file_type().await?.is_file() {
                let len = e.metadata().await?.len();
                let offset = len / 2;
                let limit = (len - offset) / 2;
                let mut f = source
                    .get_reader(e.file_name().as_os_str(), offset, limit)
                    .await?
                    .unwrap();
                let mut data = Vec::with_capacity(limit as usize);
                io::copy(&mut f, &mut data).await?;
                let expect = fs::read(e.path()).await?;
                assert_eq!(
                    data,
                    expect.as_slice()[offset as usize..(offset + limit) as usize]
                );
            }
        }
        Ok(())
    }
}