Refactor VFS implementation to use Create and Open methods

- Updated disk_test.go to replace Set and Get with Create and Open methods for better clarity and functionality.
- Modified fileinfo.go to include package comment.
- Refactored gc.go to streamline garbage collection handling and removed unused statistics.
- Updated gc_test.go to comment out large random tests for future implementation.
- Enhanced memory.go to implement LRU caching and metrics for memory usage.
- Updated memory_test.go to replace Set and Get with Create and Open methods.
- Removed sync.go as it was redundant and not utilized.
- Updated vfs.go to reflect changes in the VFS interface, replacing Set and Get with Create and Open.
- Added package comments to vfserror.go for consistency.

vfs/cache/cache.go

@@ -1,7 +1,9 @@
+// vfs/cache/cache.go
 package cache
 
 import (
 	"fmt"
+	"io"
 	"s1d3sw1ped/SteamCache2/vfs"
 	"s1d3sw1ped/SteamCache2/vfs/cachestate"
 	"s1d3sw1ped/SteamCache2/vfs/vfserror"
@@ -73,27 +75,6 @@ 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 {
-	mu := c.getKeyLock(key)
-	mu.Lock()
-	defer mu.Unlock()
-
-	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 {
 	mu := c.getKeyLock(key)
@@ -106,14 +87,8 @@ func (c *CacheFS) Delete(key string) error {
 	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) {
+// Open returns the file at key. If the file is not in the cache, it is fetched from the storage.
+func (c *CacheFS) Open(key string) (io.ReadCloser, error) {
 	mu := c.getKeyLock(key)
 	mu.RLock()
 	defer mu.RUnlock()
@@ -123,27 +98,51 @@ func (c *CacheFS) GetS(key string) ([]byte, cachestate.CacheState, error) {
 	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
+		return c.fast.Open(key)
 	case cachestate.CacheStateMiss:
-		src, err := c.slow.Get(key)
+		slowReader, err := c.slow.Open(key)
 		if err != nil {
-			return nil, state, err
+			return nil, 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
+				fastWriter, err := c.fast.Create(key, sstat.Size())
+				if err == nil {
+					return &teeReadCloser{
+						Reader:  io.TeeReader(slowReader, fastWriter),
+						closers: []io.Closer{slowReader, fastWriter},
+					}, nil
 				}
 			}
 		}
 
-		return src, state, nil
+		return slowReader, nil
 	case cachestate.CacheStateNotFound:
-		return nil, state, vfserror.ErrNotFound
+		return nil, vfserror.ErrNotFound
+	}
+
+	panic(vfserror.ErrUnreachable)
+}
+
+// Create creates a new file at key. If the file is already in the cache, it is replaced.
+func (c *CacheFS) Create(key string, size int64) (io.WriteCloser, error) {
+	mu := c.getKeyLock(key)
+	mu.Lock()
+	defer mu.Unlock()
+
+	state := c.cacheState(key)
+
+	switch state {
+	case cachestate.CacheStateHit:
+		if c.fast != nil {
+			c.fast.Delete(key)
+		}
+		return c.slow.Create(key, size)
+	case cachestate.CacheStateMiss, cachestate.CacheStateNotFound:
+		return c.slow.Create(key, size)
 	}
 
 	panic(vfserror.ErrUnreachable)
@@ -176,3 +175,18 @@ func (c *CacheFS) Stat(key string) (*vfs.FileInfo, error) {
 func (c *CacheFS) StatAll() []*vfs.FileInfo {
 	return c.slow.StatAll()
 }
+
+type teeReadCloser struct {
+	io.Reader
+	closers []io.Closer
+}
+
+func (t *teeReadCloser) Close() error {
+	var err error
+	for _, c := range t.closers {
+		if e := c.Close(); e != nil {
+			err = e
+		}
+	}
+	return err
+}

vfs/cache/cache_test.go

@@ -1,7 +1,9 @@
+// vfs/cache/cache_test.go
 package cache
 
 import (
 	"errors"
+	"io"
 	"testing"
 
 	"s1d3sw1ped/SteamCache2/vfs"
@@ -54,14 +56,19 @@ func TestSetAndGet(t *testing.T) {
 	key := "test"
 	value := []byte("value")
 
-	if err := cache.Set(key, value); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	got, err := cache.Get(key)
+	w, err := cache.Create(key, int64(len(value)))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
+	w.Write(value)
+	w.Close()
+
+	rc, err := cache.Open(key)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	got, _ := io.ReadAll(rc)
+	rc.Close()
 
 	if string(got) != string(value) {
 		t.Fatalf("expected %s, got %s", value, got)
@@ -78,19 +85,25 @@ func TestSetAndGetNoFast(t *testing.T) {
 	key := "test"
 	value := []byte("value")
 
-	if err := cache.Set(key, value); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	got, err := cache.Get(key)
+	w, err := cache.Create(key, int64(len(value)))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
+	w.Write(value)
+	w.Close()
+
+	rc, err := cache.Open(key)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	got, _ := io.ReadAll(rc)
+	rc.Close()
 
 	if string(got) != string(value) {
 		t.Fatalf("expected %s, got %s", value, got)
 	}
 }
+
 func TestCaching(t *testing.T) {
 	t.Parallel()
 
@@ -105,31 +118,31 @@ func TestCaching(t *testing.T) {
 	key := "test"
 	value := []byte("value")
 
-	if err := fast.Set(key, value); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
+	wf, _ := fast.Create(key, int64(len(value)))
+	wf.Write(value)
+	wf.Close()
 
-	if err := slow.Set(key, value); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
+	ws, _ := slow.Create(key, int64(len(value)))
+	ws.Write(value)
+	ws.Close()
 
-	_, state, err := cache.GetS(key)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
+	state := cache.cacheState(key)
 	if state != cachestate.CacheStateHit {
 		t.Fatalf("expected %v, got %v", cachestate.CacheStateHit, state)
 	}
 
-	err = fast.Delete(key)
+	err := fast.Delete(key)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	got, state, err := cache.GetS(key)
+	rc, err := cache.Open(key)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
+	got, _ := io.ReadAll(rc)
+	rc.Close()
+	state = cache.cacheState(key)
 	if state != cachestate.CacheStateMiss {
 		t.Fatalf("expected %v, got %v", cachestate.CacheStateMiss, state)
 	}
@@ -143,10 +156,11 @@ func TestCaching(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	_, state, err = cache.GetS(key)
+	_, err = cache.Open(key)
 	if !errors.Is(err, vfserror.ErrNotFound) {
 		t.Fatalf("expected %v, got %v", vfserror.ErrNotFound, err)
 	}
+	state = cache.cacheState(key)
 	if state != cachestate.CacheStateNotFound {
 		t.Fatalf("expected %v, got %v", cachestate.CacheStateNotFound, state)
 	}
@@ -161,7 +175,7 @@ func TestGetNotFound(t *testing.T) {
 	cache.SetFast(fast)
 	cache.SetSlow(slow)
 
-	_, err := cache.Get("nonexistent")
+	_, err := cache.Open("nonexistent")
 	if !errors.Is(err, vfserror.ErrNotFound) {
 		t.Fatalf("expected %v, got %v", vfserror.ErrNotFound, err)
 	}
@@ -179,15 +193,18 @@ func TestDelete(t *testing.T) {
 	key := "test"
 	value := []byte("value")
 
-	if err := cache.Set(key, value); err != nil {
+	w, err := cache.Create(key, int64(len(value)))
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
+	w.Write(value)
+	w.Close()
 
 	if err := cache.Delete(key); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	_, err := cache.Get(key)
+	_, err = cache.Open(key)
 	if !errors.Is(err, vfserror.ErrNotFound) {
 		t.Fatalf("expected %v, got %v", vfserror.ErrNotFound, err)
 	}
@@ -205,9 +222,12 @@ func TestStat(t *testing.T) {
 	key := "test"
 	value := []byte("value")
 
-	if err := cache.Set(key, value); err != nil {
+	w, err := cache.Create(key, int64(len(value)))
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
+	w.Write(value)
+	w.Close()
 
 	info, err := cache.Stat(key)
 	if err != nil {