Justin Harms
539f14e8ec
All checks were successful
PR Check / check-and-test (pull_request) Successful in 30s
119 lines
3.4 KiB
Go
119 lines
3.4 KiB
Go
// vfs/gc/gc.go
|
|
package gc
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"s1d3sw1ped/SteamCache2/steamcache/logger"
|
|
"s1d3sw1ped/SteamCache2/vfs"
|
|
"s1d3sw1ped/SteamCache2/vfs/cachestate"
|
|
"s1d3sw1ped/SteamCache2/vfs/disk"
|
|
"s1d3sw1ped/SteamCache2/vfs/memory"
|
|
"s1d3sw1ped/SteamCache2/vfs/vfserror"
|
|
"time"
|
|
)
|
|
|
|
// LRUGC deletes files in LRU order until enough space is reclaimed.
|
|
func LRUGC(vfss vfs.VFS, size uint) {
|
|
attempts := 0
|
|
deletions := 0
|
|
var reclaimed uint
|
|
|
|
for reclaimed < size {
|
|
if attempts > 10 {
|
|
logger.Logger.Debug().
|
|
Int("attempts", attempts).
|
|
Msg("GC: Too many attempts to reclaim space, giving up")
|
|
return
|
|
}
|
|
attempts++
|
|
switch fs := vfss.(type) {
|
|
case *disk.DiskFS:
|
|
fi := fs.LRU.Back()
|
|
if fi == nil {
|
|
break
|
|
}
|
|
sz := uint(fi.Size())
|
|
err := fs.Delete(fi.Name())
|
|
if err != nil {
|
|
continue
|
|
}
|
|
reclaimed += sz
|
|
deletions++
|
|
case *memory.MemoryFS:
|
|
fi := fs.LRU.Back()
|
|
if fi == nil {
|
|
break
|
|
}
|
|
sz := uint(fi.Size())
|
|
err := fs.Delete(fi.Name())
|
|
if err != nil {
|
|
continue
|
|
}
|
|
reclaimed += sz
|
|
deletions++
|
|
default:
|
|
// Fallback to old method if not supported
|
|
stats := vfss.StatAll()
|
|
if len(stats) == 0 {
|
|
break
|
|
}
|
|
fi := stats[0] // Assume sorted or pick first
|
|
sz := uint(fi.Size())
|
|
err := vfss.Delete(fi.Name())
|
|
if err != nil {
|
|
continue
|
|
}
|
|
reclaimed += sz
|
|
deletions++
|
|
}
|
|
}
|
|
}
|
|
|
|
func PromotionDecider(fi *vfs.FileInfo, cs cachestate.CacheState) bool {
|
|
return time.Since(fi.AccessTime()) < time.Second*60 // Put hot files in the fast vfs if equipped
|
|
}
|
|
|
|
// Ensure GCFS implements VFS.
|
|
var _ vfs.VFS = (*GCFS)(nil)
|
|
|
|
// GCFS is a virtual file system that calls a GC handler when the disk is full. The GC handler is responsible for freeing up space on the disk. The GCFS is a wrapper around another VFS.
|
|
type GCFS struct {
|
|
vfs.VFS
|
|
multiplier int
|
|
|
|
// protected by mu
|
|
gcHanderFunc GCHandlerFunc
|
|
}
|
|
|
|
// GCHandlerFunc is a function that is called when the disk is full and the GCFS needs to free up space. It is passed the VFS and the size of the file that needs to be written. Its up to the implementation to free up space. How much space is freed is also up to the implementation.
|
|
type GCHandlerFunc func(vfs vfs.VFS, size uint)
|
|
|
|
func New(vfs vfs.VFS, multiplier int, gcHandlerFunc GCHandlerFunc) *GCFS {
|
|
if multiplier <= 0 {
|
|
multiplier = 1 // if the multiplier is less than or equal to 0 set it to 1 will be slow but the user can set it to a higher value if they want
|
|
}
|
|
return &GCFS{
|
|
VFS: vfs,
|
|
multiplier: multiplier,
|
|
gcHanderFunc: gcHandlerFunc,
|
|
}
|
|
}
|
|
|
|
// Create overrides the Create method of the VFS interface. It tries to create the key, if it fails due to disk full error, it calls the GC handler and tries again. If it still fails it returns the error.
|
|
func (g *GCFS) Create(key string, size int64) (io.WriteCloser, error) {
|
|
w, err := g.VFS.Create(key, size) // try to create the key
|
|
|
|
// if it fails due to disk full error, call the GC handler and try again in a loop that will continue until it succeeds or the error is not disk full
|
|
if err == vfserror.ErrDiskFull && g.gcHanderFunc != nil { // if the error is disk full and there is a GC handler
|
|
g.gcHanderFunc(g.VFS, uint(size*int64(g.multiplier))) // call the GC handler
|
|
w, err = g.VFS.Create(key, size)
|
|
}
|
|
|
|
return w, err
|
|
}
|
|
|
|
func (g *GCFS) Name() string {
|
|
return fmt.Sprintf("GCFS(%s)", g.VFS.Name()) // wrap the name of the VFS with GCFS so we can see that its a GCFS
|
|
}
|