// Package readcache is een optionele, wegwerpbare cache voor afgeleide // paginadata (README, trees, laatste commits, ref-lijsten, tellingen). // De bron blijft altijd git: een fout in de cache betekent een miss. // // Indeling: /cache//{sha,refs}/. Alleen cache/ is van // deze package; Clear en LRU raken niets anders onder root aan. package readcache import ( "container/list" "crypto/sha256" "encoding/hex" "encoding/json" "errors" "io/fs" "os" "path/filepath" "strconv" "strings" "sync" "sync/atomic" ) // DefaultMax is de standaardgrootte: 512 MiB. const DefaultMax = 512 << 20 // Cache is veilig voor gelijktijdig gebruik. Een nil *Cache is uit. type Cache struct { dir string max int64 mu sync.Mutex lru *list.List // voorkant = recent items map[string]*list.Element size int64 hits, misses atomic.Int64 gens map[int64]uint64 allGen uint64 } type entry struct { rel string size int64 } // Open maakt /cache aan en leest de bestaande inhoud in. func Open(root string, max int64) (*Cache, error) { root = strings.TrimSpace(root) if root == "" { return nil, errors.New("readcache: geen pad") } if max <= 0 { max = DefaultMax } dir := filepath.Join(root, "cache") if err := os.MkdirAll(dir, 0o750); err != nil { return nil, err } c := &Cache{dir: dir, max: max, lru: list.New(), items: map[string]*list.Element{}, gens: map[int64]uint64{}} type found struct { rel string size int64 mod int64 } var all []found _ = filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error { if err != nil || d.IsDir() { return nil } if strings.HasPrefix(d.Name(), ".tmp-") { _ = os.Remove(p) return nil } info, err := d.Info() if err != nil { return nil } rel, _ := filepath.Rel(dir, p) all = append(all, found{rel, info.Size(), info.ModTime().UnixNano()}) return nil }) // oudste achteraan for i := 1; i < len(all); i++ { for j := i; j > 0 && all[j].mod > all[j-1].mod; j-- { all[j], all[j-1] = all[j-1], all[j] } } for _, f := range all { c.items[f.rel] = c.lru.PushBack(&entry{f.rel, f.size}) c.size += f.size } c.mu.Lock() c.evictLocked() c.mu.Unlock() return c, nil } // Dir is de cachemap zelf (/cache). func (c *Cache) Dir() string { if c == nil { return "" } return c.dir } func repoDir(repoID int64) string { return strconv.FormatInt(repoID, 10) } // rel geeft het pad voor een sleutel. refs=true hoort bij een ref-naam // en verdwijnt bij elke ref-wijziging; anders is de sleutel onveranderlijk. func rel(repoID int64, refs bool, key string) string { sum := sha256.Sum256([]byte(key)) ns := "sha" if refs { ns = "refs" } return filepath.Join(repoDir(repoID), ns, hex.EncodeToString(sum[:16])) } // GetJSON vult v uit de cache. false bij een miss of corrupte entry. func (c *Cache) GetJSON(repoID int64, refs bool, key string, v any) bool { if c == nil { return false } r := rel(repoID, refs, key) b, err := os.ReadFile(filepath.Join(c.dir, r)) if err != nil { c.misses.Add(1) return false } // eerste regel is de volledige sleutel, tegen hash-botsingen nl := strings.IndexByte(string(b), '\n') if nl < 0 || string(b[:nl]) != key || json.Unmarshal(b[nl+1:], v) != nil { c.misses.Add(1) c.remove(r) return false } c.hits.Add(1) c.mu.Lock() if el, ok := c.items[r]; ok { c.lru.MoveToFront(el) } c.mu.Unlock() return true } // Gen is de generatie van een repo. Lees die vóór git en geef hem aan // PutJSONAt: een ref-wijziging tussendoor maakt de schrijfactie ongeldig. func (c *Cache) Gen(repoID int64) uint64 { if c == nil { return 0 } c.mu.Lock() defer c.mu.Unlock() return c.gens[repoID] + c.allGen<<32 } // PutJSON schrijft atomisch. Fouten worden genegeerd. func (c *Cache) PutJSON(repoID int64, refs bool, key string, v any) { c.PutJSONAt(repoID, refs, key, v, c.Gen(repoID)) } // PutJSONAt schrijft alleen als de generatie nog gen is. func (c *Cache) PutJSONAt(repoID int64, refs bool, key string, v any, gen uint64) { if c == nil || strings.ContainsRune(key, '\n') { return } body, err := json.Marshal(v) if err != nil { return } data := append([]byte(key+"\n"), body...) if int64(len(data)) > c.max/4 { return } r := rel(repoID, refs, key) full := filepath.Join(c.dir, r) if err := os.MkdirAll(filepath.Dir(full), 0o750); err != nil { return } tmp, err := os.CreateTemp(filepath.Dir(full), ".tmp-*") if err != nil { return } _, werr := tmp.Write(data) cerr := tmp.Close() if werr != nil || cerr != nil || os.Rename(tmp.Name(), full) != nil { _ = os.Remove(tmp.Name()) return } c.mu.Lock() if c.gens[repoID]+c.allGen<<32 != gen { c.mu.Unlock() _ = os.Remove(full) return } if el, ok := c.items[r]; ok { c.size -= el.Value.(*entry).size c.lru.Remove(el) } c.items[r] = c.lru.PushFront(&entry{r, int64(len(data))}) c.size += int64(len(data)) c.evictLocked() c.mu.Unlock() } func (c *Cache) evictLocked() { for c.size > c.max { el := c.lru.Back() if el == nil { return } e := el.Value.(*entry) _ = os.Remove(filepath.Join(c.dir, e.rel)) c.lru.Remove(el) delete(c.items, e.rel) c.size -= e.size } } func (c *Cache) remove(r string) { _ = os.Remove(filepath.Join(c.dir, r)) c.mu.Lock() if el, ok := c.items[r]; ok { c.size -= el.Value.(*entry).size c.lru.Remove(el) delete(c.items, r) } c.mu.Unlock() } func (c *Cache) dropPrefix(repoID int64, prefix string) { c.mu.Lock() defer c.mu.Unlock() c.gens[repoID]++ _ = os.RemoveAll(filepath.Join(c.dir, prefix)) for r, el := range c.items { if r == prefix || strings.HasPrefix(r, prefix+string(filepath.Separator)) { c.size -= el.Value.(*entry).size c.lru.Remove(el) delete(c.items, r) } } } // DropRefs vergeet alles wat van een ref-naam afhangt. func (c *Cache) DropRefs(repoID int64) { if c != nil { c.dropPrefix(repoID, filepath.Join(repoDir(repoID), "refs")) } } // DropRepo vergeet alles van één repo (verwijderd, hernoemd, zichtbaarheid). func (c *Cache) DropRepo(repoID int64) { if c != nil { c.dropPrefix(repoID, repoDir(repoID)) } } // Clear leegt de hele cache/-map, en niets daarbuiten. func (c *Cache) Clear() { if c == nil { return } c.mu.Lock() defer c.mu.Unlock() ents, _ := os.ReadDir(c.dir) for _, e := range ents { _ = os.RemoveAll(filepath.Join(c.dir, e.Name())) } c.allGen++ c.lru.Init() c.items = map[string]*list.Element{} c.size = 0 } // Usage is de stand voor Beheer. type Usage struct { Dir string Bytes int64 Max int64 Entries int Hits int64 Misses int64 } // Usage geeft de huidige stand. func (c *Cache) Usage() Usage { if c == nil { return Usage{} } c.mu.Lock() defer c.mu.Unlock() return Usage{Dir: c.dir, Bytes: c.size, Max: c.max, Entries: len(c.items), Hits: c.hits.Load(), Misses: c.misses.Load()} }