Caching store: keep the ranges read of large objects, and their sizes 30d5fac7560d

/// Where a caching store keeps the ranges it read of objects too large to

/// keep whole, and those objects' sizes: apart from every object key.

const RANGES: &str = "cached-range";

const SIZES: &str = "cached-size";

    }

    /// An object's size: kept on disk once the remote has said it (objects

    /// never change), so it is asked once. `None` when there is no object.

    fn size_of(&self, key: &str) -> Result<Option<u64>> {

        let skey = format!("{SIZES}/{key}");

        if let Some(n) = self

            .cache

            .get(&skey)

            .ok()

            .and_then(|b| String::from_utf8(b).ok())

            .and_then(|t| t.parse().ok())

        {

            return Ok(Some(n));

        }

        let size = self.remote.stat(key)?.map(|e| e.size);

        if let Some(n) = size {

            self.keep(&skey, n.to_string().as_bytes())?;

        }

        Ok(size)

        // A large object's ranges are kept as they are read (packs never

        // change, oxygenhub#234): a server opens the store again for every

        // request, so only what is on disk carries over.

        let rkey = format!("{RANGES}/{key}/{}-{}", range.start, range.end);

        if let Ok(bytes) = self.cache.get(&rkey) {

            self.touch(&rkey);

            return Ok(bytes);

        }

        // range and the range kept. Its size is kept too, so the remote is

        // asked it once.

        match self.size_of(key)? {

            Some(size) if self.cacheable(size) => {

            }

            Some(_) => {

                let bytes = self.remote.get_range(key, range)?;

                self.keep(&rkey, &bytes)?;

                Ok(bytes)

        // Its kept ranges and size go with it.

        let mut extra = self.cache.list(&format!("{RANGES}/{key}/"))?;

        extra.extend(self.cache.stat(&format!("{SIZES}/{key}"))?);

        for e in extra {

            self.cache.delete(&e.key)?;

            let mut used = self.used.lock().unwrap_or_else(|p| p.into_inner());

            if let Some(u) = used.as_mut() {

                *u = u.saturating_sub(e.size);

            }

        }

    /// A remote that answers nothing: what is read through it was cached.

    struct Unreachable;

    impl Store for Unreachable {

        fn describe(&self) -> String {

            "unreachable".into()

        }

        fn has(&self, _: &str) -> Result<bool> {

            Err(Error::Backend("asked the remote".into()))

        }

        fn get(&self, _: &str) -> Result<Vec<u8>> {

            Err(Error::Backend("asked the remote".into()))

        }

        fn get_range(&self, _: &str, _: Range<u64>) -> Result<Vec<u8>> {

            Err(Error::Backend("asked the remote".into()))

        }

        fn put_new(&self, _: &str, _: &[u8]) -> Result<()> {

            Err(Error::Backend("asked the remote".into()))

        }

        fn list(&self, _: &str) -> Result<Vec<Entry>> {

            Err(Error::Backend("asked the remote".into()))

        }

        fn delete(&self, _: &str) -> Result<()> {

            Err(Error::Backend("asked the remote".into()))

        }

        fn stat(&self, _: &str) -> Result<Option<Entry>> {

            Err(Error::Backend("asked the remote".into()))

        }

        fn read_ref(&self, _: &str) -> Result<Option<(Vec<u8>, Version)>> {

            Err(Error::Backend("asked the remote".into()))

        }

        fn write_ref(&self, _: &str, _: &[u8], _: Option<&Version>) -> Result<Version> {

            Err(Error::Backend("asked the remote".into()))

        }

    }

        // Its ranges are kept as read, and its size, so a store opened

        // again (a server's next request) asks the remote nothing.

        let again =

            CachingStore::open(Arc::new(Unreachable), dir.path().join("cache"), 8000).unwrap();

        assert_eq!(again.get_range("pack-big", 10..20).unwrap(), vec![7u8; 10]);

        // Deleting it takes its ranges and size too.

        store.delete("pack-big").unwrap();

        assert!(

            store.cache.list("cached-range/").unwrap().is_empty()

                && store.cache.list("cached-size/").unwrap().is_empty()

        );