it works

vfs/cache/cache.go

@@ -0,0 +1,151 @@
+package cache
+
+import (
+	"fmt"
+	"s1d3sw1ped/SteamCache2/vfs"
+	"s1d3sw1ped/SteamCache2/vfs/cachestate"
+	"s1d3sw1ped/SteamCache2/vfs/vfserror"
+)
+
+// Ensure CacheFS implements VFS.
+var _ vfs.VFS = (*CacheFS)(nil)
+
+// CacheFS is a virtual file system that caches files in memory and on disk.
+type CacheFS struct {
+	fast vfs.VFS
+	slow vfs.VFS
+
+	cacheHandler CacheHandler
+}
+
+type CacheHandler func(*vfs.FileInfo, cachestate.CacheState) bool
+
+// New creates a new CacheFS. fast is used for caching, and slow is used for storage. fast should obviously be faster than slow.
+func New(fast, slow vfs.VFS, cacheHandler CacheHandler) *CacheFS {
+	if slow == nil {
+		panic("slow is nil")
+	}
+
+	if fast == slow {
+		panic("fast and slow are the same")
+	}
+
+	return &CacheFS{
+		fast: fast,
+		slow: slow,
+
+		cacheHandler: cacheHandler,
+	}
+}
+
+// cacheState returns the state of the file at key.
+func (c *CacheFS) cacheState(key string) cachestate.CacheState {
+	if c.fast != nil {
+		if _, err := c.fast.Stat(key); err == nil {
+			return cachestate.CacheStateHit
+		}
+	}
+
+	if _, err := c.slow.Stat(key); err == nil {
+		return cachestate.CacheStateMiss
+	}
+
+	return cachestate.CacheStateNotFound
+}
+
+func (c *CacheFS) Name() string {
+	return fmt.Sprintf("CacheFS(%s, %s)", c.fast.Name(), c.slow.Name())
+}
+
+// Size returns the total size of the cache.
+func (c *CacheFS) Size() int64 {
+	return c.slow.Size()
+}
+
+// Set sets the file at key to src. If the file is already in the cache, it is replaced.
+func (c *CacheFS) Set(key string, src []byte) error {
+	state := c.cacheState(key)
+
+	switch state {
+	case cachestate.CacheStateHit:
+		if c.fast != nil {
+			c.fast.Delete(key)
+		}
+		return c.slow.Set(key, src)
+	case cachestate.CacheStateMiss, cachestate.CacheStateNotFound:
+		return c.slow.Set(key, src)
+	}
+
+	panic(vfserror.ErrUnreachable)
+}
+
+// Delete deletes the file at key from the cache.
+func (c *CacheFS) Delete(key string) error {
+	if c.fast != nil {
+		c.fast.Delete(key)
+	}
+	return c.slow.Delete(key)
+}
+
+// Get returns the file at key. If the file is not in the cache, it is fetched from the storage.
+func (c *CacheFS) Get(key string) ([]byte, error) {
+	src, _, err := c.GetS(key)
+	return src, err
+}
+
+// GetS returns the file at key. If the file is not in the cache, it is fetched from the storage. It also returns the cache state.
+func (c *CacheFS) GetS(key string) ([]byte, cachestate.CacheState, error) {
+	state := c.cacheState(key)
+
+	switch state {
+	case cachestate.CacheStateHit:
+		// if c.fast == nil then cacheState cannot be CacheStateHit so we can safely ignore the check
+		src, err := c.fast.Get(key)
+		return src, state, err
+	case cachestate.CacheStateMiss:
+		src, err := c.slow.Get(key)
+		if err != nil {
+			return nil, state, err
+		}
+
+		sstat, _ := c.slow.Stat(key)
+		if sstat != nil && c.fast != nil { // file found in slow storage and fast storage is available
+			// We are accessing the file from the slow storage, and the file has been accessed less then a minute ago so it popular, so we should update the fast storage with the latest file.
+			if c.cacheHandler != nil && c.cacheHandler(sstat, state) {
+				if err := c.fast.Set(key, src); err != nil {
+					return nil, state, err
+				}
+			}
+		}
+
+		return src, state, nil
+	case cachestate.CacheStateNotFound:
+		return nil, state, vfserror.ErrNotFound
+	}
+
+	panic(vfserror.ErrUnreachable)
+}
+
+// Stat returns information about the file at key.
+// Warning: This will return information about the file in the fastest storage its in.
+func (c *CacheFS) Stat(key string) (*vfs.FileInfo, error) {
+	state := c.cacheState(key)
+
+	switch state {
+	case cachestate.CacheStateHit:
+		// if c.fast == nil then cacheState cannot be CacheStateHit so we can safely ignore the check
+		return c.fast.Stat(key)
+	case cachestate.CacheStateMiss:
+		return c.slow.Stat(key)
+	case cachestate.CacheStateNotFound:
+		return nil, vfserror.ErrNotFound
+	}
+
+	panic(vfserror.ErrUnreachable)
+}
+
+// StatAll returns information about all files in the cache.
+// Warning: This only returns information about the files in the slow storage.
+func (c *CacheFS) StatAll() []*vfs.FileInfo {
+	return c.slow.StatAll()
+}

vfs/cache/cache_test.go

@@ -0,0 +1,189 @@
+package cache
+
+import (
+	"errors"
+	"testing"
+
+	"s1d3sw1ped/SteamCache2/vfs"
+	"s1d3sw1ped/SteamCache2/vfs/cachestate"
+	"s1d3sw1ped/SteamCache2/vfs/memory"
+	"s1d3sw1ped/SteamCache2/vfs/vfserror"
+)
+
+func testMemory() vfs.VFS {
+	return memory.New(1024)
+}
+
+func TestNew(t *testing.T) {
+	fast := testMemory()
+	slow := testMemory()
+
+	cache := New(fast, slow, nil)
+	if cache == nil {
+		t.Fatal("expected cache to be non-nil")
+	}
+}
+
+func TestNewPanics(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Fatal("expected panic but did not get one")
+		}
+	}()
+
+	New(nil, nil, nil)
+}
+
+func TestSetAndGet(t *testing.T) {
+	fast := testMemory()
+	slow := testMemory()
+	cache := New(fast, slow, nil)
+
+	key := "test"
+	value := []byte("value")
+
+	if err := cache.Set(key, value); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	got, err := cache.Get(key)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(got) != string(value) {
+		t.Fatalf("expected %s, got %s", value, got)
+	}
+}
+
+func TestSetAndGetNoFast(t *testing.T) {
+	slow := testMemory()
+	cache := New(nil, slow, nil)
+
+	key := "test"
+	value := []byte("value")
+
+	if err := cache.Set(key, value); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	got, err := cache.Get(key)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(got) != string(value) {
+		t.Fatalf("expected %s, got %s", value, got)
+	}
+}
+func TestCaching(t *testing.T) {
+	fast := testMemory()
+	slow := testMemory()
+	cache := New(fast, slow, func(fi *vfs.FileInfo, cs cachestate.CacheState) bool {
+		return true
+	})
+
+	key := "test"
+	value := []byte("value")
+
+	if err := fast.Set(key, value); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if err := slow.Set(key, value); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	_, state, err := cache.GetS(key)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if state != cachestate.CacheStateHit {
+		t.Fatalf("expected %v, got %v", cachestate.CacheStateHit, state)
+	}
+
+	err = fast.Delete(key)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	got, state, err := cache.GetS(key)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if state != cachestate.CacheStateMiss {
+		t.Fatalf("expected %v, got %v", cachestate.CacheStateMiss, state)
+	}
+
+	if string(got) != string(value) {
+		t.Fatalf("expected %s, got %s", value, got)
+	}
+
+	err = cache.Delete(key)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	_, state, err = cache.GetS(key)
+	if !errors.Is(err, vfserror.ErrNotFound) {
+		t.Fatalf("expected %v, got %v", vfserror.ErrNotFound, err)
+	}
+	if state != cachestate.CacheStateNotFound {
+		t.Fatalf("expected %v, got %v", cachestate.CacheStateNotFound, state)
+	}
+}
+
+func TestGetNotFound(t *testing.T) {
+	fast := testMemory()
+	slow := testMemory()
+	cache := New(fast, slow, nil)
+
+	_, err := cache.Get("nonexistent")
+	if !errors.Is(err, vfserror.ErrNotFound) {
+		t.Fatalf("expected %v, got %v", vfserror.ErrNotFound, err)
+	}
+}
+
+func TestDelete(t *testing.T) {
+	fast := testMemory()
+	slow := testMemory()
+	cache := New(fast, slow, nil)
+
+	key := "test"
+	value := []byte("value")
+
+	if err := cache.Set(key, value); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if err := cache.Delete(key); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	_, err := cache.Get(key)
+	if !errors.Is(err, vfserror.ErrNotFound) {
+		t.Fatalf("expected %v, got %v", vfserror.ErrNotFound, err)
+	}
+}
+
+func TestStat(t *testing.T) {
+	fast := testMemory()
+	slow := testMemory()
+	cache := New(fast, slow, nil)
+
+	key := "test"
+	value := []byte("value")
+
+	if err := cache.Set(key, value); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	info, err := cache.Stat(key)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if info == nil {
+		t.Fatal("expected file info to be non-nil")
+	}
+}