lotus/storage/paths/localstorage_cached.go
2022-06-14 20:25:52 +02:00

132 lines
2.8 KiB
Go

package paths
import (
"sync"
"time"
lru "github.com/hashicorp/golang-lru"
"github.com/filecoin-project/lotus/storage/sealer/fsutil"
)
var StatTimeout = 5 * time.Second
var MaxDiskUsageDuration = time.Second
type cachedLocalStorage struct {
base LocalStorage
statLk sync.Mutex
stats *lru.Cache // path -> statEntry
pathDUs *lru.Cache // path -> *diskUsageEntry
}
func newCachedLocalStorage(ls LocalStorage) *cachedLocalStorage {
statCache, _ := lru.New(1024)
duCache, _ := lru.New(1024)
return &cachedLocalStorage{
base: ls,
stats: statCache,
pathDUs: duCache,
}
}
type statEntry struct {
stat fsutil.FsStat
time time.Time
}
type diskUsageEntry struct {
last diskUsageResult
usagePromise <-chan diskUsageResult
}
type diskUsageResult struct {
usage int64
time time.Time
}
func (c *cachedLocalStorage) GetStorage() (StorageConfig, error) {
return c.base.GetStorage()
}
func (c *cachedLocalStorage) SetStorage(f func(*StorageConfig)) error {
return c.base.SetStorage(f)
}
func (c *cachedLocalStorage) Stat(path string) (fsutil.FsStat, error) {
c.statLk.Lock()
defer c.statLk.Unlock()
if v, ok := c.stats.Get(path); ok && time.Now().Sub(v.(statEntry).time) < StatTimeout {
return v.(statEntry).stat, nil
}
// if we don't, get the stat
st, err := c.base.Stat(path)
if err == nil {
c.stats.Add(path, statEntry{
stat: st,
time: time.Now(),
})
}
return st, err
}
func (c *cachedLocalStorage) DiskUsage(path string) (int64, error) {
c.statLk.Lock()
defer c.statLk.Unlock()
var entry *diskUsageEntry
if v, ok := c.pathDUs.Get(path); ok {
entry = v.(*diskUsageEntry)
// if we have recent cached entry, use that
if time.Now().Sub(entry.last.time) < StatTimeout {
return entry.last.usage, nil
}
} else {
entry = new(diskUsageEntry)
c.pathDUs.Add(path, entry)
}
// start a new disk usage request; this can take a while so start a
// goroutine, and if it doesn't return quickly, return either the
// previous value, or zero - that's better than potentially blocking
// here for a long time.
if entry.usagePromise == nil {
resCh := make(chan diskUsageResult, 1)
go func() {
du, err := c.base.DiskUsage(path)
if err != nil {
log.Errorw("error getting disk usage", "path", path, "error", err)
}
resCh <- diskUsageResult{
usage: du,
time: time.Now(),
}
}()
entry.usagePromise = resCh
}
// wait for the disk usage result; if it doesn't come, fallback on
// previous usage
select {
case du := <-entry.usagePromise:
entry.usagePromise = nil
entry.last = du
case <-time.After(MaxDiskUsageDuration):
log.Warnw("getting usage is slow, falling back to previous usage",
"path", path,
"fallback", entry.last.usage,
"age", time.Now().Sub(entry.last.time))
}
return entry.last.usage, nil
}
var _ LocalStorage = &cachedLocalStorage{}