package blobovniczatree import ( "fmt" "sync" utilSync "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/sync" "github.com/hashicorp/golang-lru/v2/simplelru" ) // dbCache caches sharedDB instances that are NOT open for Put. // // Uses dbManager for opening/closing sharedDB instances. // Stores a reference to an cached sharedDB, so dbManager does not close it. type dbCache struct { cacheGuard *sync.RWMutex cache simplelru.LRUCache[string, *sharedDB] pathLock *utilSync.KeyLocker[string] // the order of locks is important: pathLock first, cacheGuard second closed bool nonCached map[string]struct{} dbManager *dbManager } func newDBCache(size int, dbManager *dbManager) *dbCache { cache, err := simplelru.NewLRU[string, *sharedDB](size, func(_ string, evictedDB *sharedDB) { evictedDB.Close() }) if err != nil { // occurs only if the size is not positive panic(fmt.Errorf("could not create LRU cache of size %d: %w", size, err)) } return &dbCache{ cacheGuard: &sync.RWMutex{}, cache: cache, dbManager: dbManager, pathLock: utilSync.NewKeyLocker[string](), nonCached: make(map[string]struct{}), } } func (c *dbCache) Open() { c.cacheGuard.Lock() defer c.cacheGuard.Unlock() c.closed = false } func (c *dbCache) Close() { c.cacheGuard.Lock() defer c.cacheGuard.Unlock() c.cache.Purge() c.closed = true } func (c *dbCache) GetOrCreate(path string) *sharedDB { value := c.getExisted(path) if value != nil { return value } return c.create(path) } func (c *dbCache) EvictAndMarkNonCached(path string) { c.pathLock.Lock(path) defer c.pathLock.Unlock(path) c.cacheGuard.Lock() defer c.cacheGuard.Unlock() c.cache.Remove(path) c.nonCached[path] = struct{}{} } func (c *dbCache) RemoveFromNonCached(path string) { c.pathLock.Lock(path) defer c.pathLock.Unlock(path) c.cacheGuard.Lock() defer c.cacheGuard.Unlock() delete(c.nonCached, path) } func (c *dbCache) getExisted(path string) *sharedDB { c.cacheGuard.Lock() defer c.cacheGuard.Unlock() if value, ok := c.cache.Get(path); ok { return value } return nil } func (c *dbCache) create(path string) *sharedDB { c.pathLock.Lock(path) defer c.pathLock.Unlock(path) value := c.getExisted(path) if value != nil { return value } value = c.dbManager.GetByPath(path) _, err := value.Open() // open db to hold reference, closed by evictedDB.Close() or if cache closed if err != nil { return value } if added := c.put(path, value); !added { value.Close() } return value } func (c *dbCache) put(path string, db *sharedDB) bool { c.cacheGuard.Lock() defer c.cacheGuard.Unlock() _, isNonCached := c.nonCached[path] if !isNonCached && !c.closed { c.cache.Add(path, db) return true } return false }