fix import loop, but had to make the file cache entry exported 😢

Emyrk · Emyrk · commit 038bb579696e · 2025-06-13T12:08:22.000-05:00
diff --git a/coderd/files/cache.go b/coderd/files/cache.go
@@ -22,20 +22,20 @@ import (
 // NewFromStore returns a file cache that will fetch files from the provided
 // database.
 func NewFromStore(store database.Store, registerer prometheus.Registerer, authz rbac.Authorizer) *Cache {
-	fetch := func(ctx context.Context, fileID uuid.UUID) (cacheEntryValue, error) {
+	fetch := func(ctx context.Context, fileID uuid.UUID) (CacheEntryValue, error) {
 		// Make sure the read does not fail due to authorization issues.
 		// Authz is checked on the Acquire call, so this is safe.
 		//nolint:gocritic
 		file, err := store.GetFileByID(dbauthz.AsFileReader(ctx), fileID)
 		if err != nil {
-			return cacheEntryValue{}, xerrors.Errorf("failed to read file from database: %w", err)
+			return CacheEntryValue{}, xerrors.Errorf("failed to read file from database: %w", err)
 		}
 
 		content := bytes.NewBuffer(file.Data)
-		return cacheEntryValue{
-			object: file.RBACObject(),
+		return CacheEntryValue{
+			Object: file.RBACObject(),
 			FS:     archivefs.FromTarReader(content),
-			size:   int64(content.Len()),
+			Size:   int64(content.Len()),
 		}, nil
 	}
 
@@ -126,19 +126,19 @@ type cacheMetrics struct {
 	totalCacheSize   prometheus.Counter
 }
 
-type cacheEntryValue struct {
-	object rbac.Object
+type CacheEntryValue struct {
+	Object rbac.Object
 	fs.FS
-	size int64
+	Size int64
 }
 
 type cacheEntry struct {
 	// refCount must only be accessed while the Cache lock is held.
 	refCount int
-	value    *lazy.ValueWithError[cacheEntryValue]
+	value    *lazy.ValueWithError[CacheEntryValue]
 }
 
-type fetcher func(context.Context, uuid.UUID) (cacheEntryValue, error)
+type fetcher func(context.Context, uuid.UUID) (CacheEntryValue, error)
 
 // Acquire will load the fs.FS for the given file. It guarantees that parallel
 // calls for the same fileID will only result in one fetch, and that parallel
@@ -162,27 +162,27 @@ func (c *Cache) Acquire(ctx context.Context, fileID uuid.UUID) (fs.FS, error) {
 		return nil, dbauthz.ErrNoActor
 	}
 	// Always check the caller can actually read the file.
-	if err := c.authz.Authorize(ctx, subject, policy.ActionRead, it.object); err != nil {
+	if err := c.authz.Authorize(ctx, subject, policy.ActionRead, it.Object); err != nil {
 		c.Release(fileID)
 		return nil, err
 	}
 
 	return it.FS, err
 }
 
-func (c *Cache) prepare(ctx context.Context, fileID uuid.UUID) *lazy.ValueWithError[cacheEntryValue] {
+func (c *Cache) prepare(ctx context.Context, fileID uuid.UUID) *lazy.ValueWithError[CacheEntryValue] {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
 	entry, ok := c.data[fileID]
 	if !ok {
-		value := lazy.NewWithError(func() (cacheEntryValue, error) {
+		value := lazy.NewWithError(func() (CacheEntryValue, error) {
 			val, err := c.fetcher(ctx, fileID)
 
 			// Always add to the cache size the bytes of the file loaded.
 			if err == nil {
-				c.currentCacheSize.Add(float64(val.size))
-				c.totalCacheSize.Add(float64(val.size))
+				c.currentCacheSize.Add(float64(val.Size))
+				c.totalCacheSize.Add(float64(val.Size))
 			}
 
 			return val, err
@@ -227,7 +227,7 @@ func (c *Cache) Release(fileID uuid.UUID) {
 
 	ev, err := entry.value.Load()
 	if err == nil {
-		c.currentCacheSize.Add(-1 * float64(ev.size))
+		c.currentCacheSize.Add(-1 * float64(ev.Size))
 	}
 
 	delete(c.data, fileID)
diff --git a/coderd/files/cache_internal_test.go b/coderd/files/cache_internal_test.go
@@ -1,4 +1,4 @@
-package files
+package files_test
 
 import (
 	"context"
@@ -15,6 +15,7 @@ import (
 	"github.com/coder/coder/v2/coderd/coderdtest"
 	"github.com/coder/coder/v2/coderd/coderdtest/promhelp"
 	"github.com/coder/coder/v2/coderd/database/dbauthz"
+	"github.com/coder/coder/v2/coderd/files"
 	"github.com/coder/coder/v2/testutil"
 )
 
@@ -31,12 +32,12 @@ func TestConcurrency(t *testing.T) {
 	emptyFS := afero.NewIOFS(afero.NewReadOnlyFs(afero.NewMemMapFs()))
 	var fetches atomic.Int64
 	reg := prometheus.NewRegistry()
-	c := New(func(_ context.Context, _ uuid.UUID) (cacheEntryValue, error) {
+	c := files.New(func(_ context.Context, _ uuid.UUID) (files.CacheEntryValue, error) {
 		fetches.Add(1)
 		// Wait long enough before returning to make sure that all of the goroutines
 		// will be waiting in line, ensuring that no one duplicated a fetch.
 		time.Sleep(testutil.IntervalMedium)
-		return cacheEntryValue{FS: emptyFS, size: fileSize}, nil
+		return files.CacheEntryValue{FS: emptyFS, Size: fileSize}, nil
 	}, reg, &coderdtest.FakeAuthorizer{})
 
 	batches := 1000
@@ -84,10 +85,10 @@ func TestRelease(t *testing.T) {
 	const fileSize = 10
 	emptyFS := afero.NewIOFS(afero.NewReadOnlyFs(afero.NewMemMapFs()))
 	reg := prometheus.NewRegistry()
-	c := New(func(_ context.Context, _ uuid.UUID) (cacheEntryValue, error) {
-		return cacheEntryValue{
+	c := files.New(func(_ context.Context, _ uuid.UUID) (files.CacheEntryValue, error) {
+		return files.CacheEntryValue{
 			FS:   emptyFS,
-			size: fileSize,
+			Size: fileSize,
 		}, nil
 	}, reg, &coderdtest.FakeAuthorizer{})
 
@@ -118,7 +119,7 @@ func TestRelease(t *testing.T) {
 	}
 
 	// Make sure cache is fully loaded
-	require.Equal(t, len(c.data), batches)
+	require.Equal(t, c.Count(), batches)
 
 	// Now release all of the references
 	for closedIdx, id := range ids {
@@ -142,7 +143,7 @@ func TestRelease(t *testing.T) {
 	}
 
 	// ...and make sure that the cache has emptied itself.
-	require.Equal(t, len(c.data), 0)
+	require.Equal(t, c.Count(), 0)
 
 	// Verify all the counts & metrics are correct.
 	// All existing files are closed
