coil-cache 0.1.1

Caching primitives for the Coil framework.
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::collections::{BTreeMap, BTreeSet};

use crate::{
    CacheEntry, CacheKey, CacheModelError, FillDecision, FillLease, InvalidationSet,
    RequestCoalescingMode,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub(crate) struct CacheRepository {
    entries: BTreeMap<CacheKey, CacheEntry>,
    tag_index: BTreeMap<crate::InvalidationTag, BTreeSet<CacheKey>>,
    inflight_fills: BTreeMap<CacheKey, String>,
}

impl CacheRepository {
    pub(crate) fn new() -> Self {
        Self::default()
    }

    pub(crate) fn insert(&mut self, entry: CacheEntry) {
        let key = entry.key.clone();
        if let Some(previous) = self.entries.insert(key.clone(), entry) {
            self.detach_tags(&key, &previous.tags);
        }
        let tags = self.entries.get(&key).map(|entry| entry.tags.clone());
        if let Some(tags) = tags {
            self.attach_tags(&key, &tags);
        }
    }

    pub(crate) fn lookup(&self, key: &CacheKey) -> Option<CacheEntry> {
        self.entries.get(key).cloned()
    }

    pub(crate) fn remove(&mut self, key: &CacheKey) -> Option<CacheEntry> {
        let removed = self.entries.remove(key);
        if let Some(entry) = &removed {
            self.detach_tags(key, &entry.tags);
        }
        removed
    }

    pub(crate) fn invalidate(&mut self, tags: &InvalidationSet) -> Vec<CacheKey> {
        if tags.is_empty() {
            return Vec::new();
        }

        let mut removed = BTreeSet::new();
        for tag in tags.iter() {
            if let Some(keys) = self.tag_index.get(tag) {
                removed.extend(keys.iter().cloned());
            }
        }

        let removed = removed.into_iter().collect::<Vec<_>>();
        for key in &removed {
            let _ = self.remove(key);
        }
        removed
    }

    pub(crate) fn begin_fill(
        &mut self,
        key: &CacheKey,
        mode: RequestCoalescingMode,
        holder: impl Into<String>,
    ) -> FillDecision {
        let holder = holder.into();
        if mode == RequestCoalescingMode::Disabled {
            return FillDecision::Uncoalesced;
        }

        if let Some(existing) = self.inflight_fills.get(key) {
            return FillDecision::Coalesced {
                key: key.clone(),
                holder: existing.clone(),
            };
        }

        self.inflight_fills.insert(key.clone(), holder.clone());
        FillDecision::Start(FillLease {
            key: key.clone(),
            holder,
        })
    }

    pub(crate) fn complete_fill(&mut self, lease: &FillLease) -> Result<(), CacheModelError> {
        match self.inflight_fills.remove(&lease.key) {
            Some(_) => Ok(()),
            None => Err(CacheModelError::UnknownInflightFill {
                key: lease.key.to_string(),
            }),
        }
    }

    fn attach_tags(&mut self, key: &CacheKey, tags: &InvalidationSet) {
        for tag in tags.iter() {
            self.tag_index
                .entry(tag.clone())
                .or_default()
                .insert(key.clone());
        }
    }

    fn detach_tags(&mut self, key: &CacheKey, tags: &InvalidationSet) {
        for tag in tags.iter() {
            if let Some(keys) = self.tag_index.get_mut(tag) {
                keys.remove(key);
                if keys.is_empty() {
                    self.tag_index.remove(tag);
                }
            }
        }
    }
}