fix: move live Statfs to RemainingResources; use *uint64 for min-free config

- TotalResources reverts to static startup value to keep total-remaining
  arithmetic consistent for BBS metrics
- RemainingResources caps reported DiskMB at live partition free space
  (syscall.Statfs), so schedulers see reduced capacity when disk fills
- MinCachePartitionFreeBytes changed to *uint64: nil means use the 5 GB
  default, 0 explicitly disables the check (previously impossible)

ai-assisted=yes
TNZ-111552

Author: kart2bc

src/code.cloudfoundry.org/cacheddownloader/file_cache.go

@@ -4,11 +4,9 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math"
 	"os"
 	"path/filepath"
 	"sync"
-	"syscall"
 	"time"
 
 	"code.cloudfoundry.org/archiver/compressor"
@@ -34,14 +32,6 @@ type FileCache struct {
 	Seq                       uint64
 }
 
-func defaultFreeSpaceOnPartition(path string) int64 {
-	var stat syscall.Statfs_t
-	if err := syscall.Statfs(path, &stat); err != nil {
-		return math.MaxInt64
-	}
-	return int64(stat.Bavail) * int64(stat.Bsize)
-}
-
 type FileCacheEntry struct {
 	Size                  int64
 	Access                time.Time
@@ -202,6 +192,10 @@ func (e *FileCacheEntry) expandedDirectory() (string, error) {
 			if err != nil {
 				fmt.Fprintln(os.Stderr, "Unable to delete the cached file", err)
 			}
+			// GetDirectory doubled Size before calling here; tar is now gone so halve it
+			// back to reflect only the .tar.d on disk. Mirrors the symmetric halving in
+			// decrementFileInUseCount() which fires when the tar is deleted later.
+			e.Size = e.Size / 2
 		}
 	}
 

src/code.cloudfoundry.org/cacheddownloader/file_cache_unix.go

@@ -0,0 +1,16 @@
+//go:build !windows
+
+package cacheddownloader
+
+import (
+	"math"
+	"syscall"
+)
+
+func defaultFreeSpaceOnPartition(path string) int64 {
+	var stat syscall.Statfs_t
+	if err := syscall.Statfs(path, &stat); err != nil {
+		return math.MaxInt64
+	}
+	return int64(stat.Bavail) * int64(stat.Bsize)
+}

src/code.cloudfoundry.org/cacheddownloader/file_cache_windows.go

@@ -0,0 +1,9 @@
+//go:build windows
+
+package cacheddownloader
+
+import "math"
+
+func defaultFreeSpaceOnPartition(path string) int64 {
+	return math.MaxInt64
+}

src/code.cloudfoundry.org/executor/depot/depot.go

@@ -219,17 +219,29 @@ func (c *client) DeleteContainer(logger lager.Logger, traceID string, guid strin
 
 func (c *client) RemainingResources(logger lager.Logger) (executor.ExecutorResources, error) {
 	logger = logger.Session("remaining-resources")
-	return c.containerStore.RemainingResources(logger), nil
+	remaining := c.containerStore.RemainingResources(logger)
+	if c.diskPath != "" {
+		if liveMB, ok := liveDiskMB(c.diskPath); ok && liveMB < remaining.DiskMB {
+			remaining.DiskMB = liveMB
+		}
+	}
+	return remaining, nil
 }
 
 func (c *client) Ping(logger lager.Logger) error {
 	return c.gardenClient.Ping()
 }
 
 func (c *client) TotalResources(logger lager.Logger) (executor.ExecutorResources, error) {
+	diskMB := c.totalCapacity.DiskMB
+	if c.diskPath != "" {
+		if liveMB, ok := liveDiskMB(c.diskPath); ok {
+			diskMB = liveMB
+		}
+	}
 	return executor.ExecutorResources{
 		MemoryMB:   c.totalCapacity.MemoryMB,
-		DiskMB:     getDiskMB(c.diskPath, c.totalCapacity.DiskMB),
+		DiskMB:     diskMB,
 		Containers: c.totalCapacity.Containers,
 	}, nil
 }

src/code.cloudfoundry.org/executor/depot/depot_test.go

@@ -698,49 +698,45 @@ var _ = Describe("Depot", func() {
 	})
 
 	Describe("RemainingResources", func() {
-		var resources executor.ExecutorResources
+		var remainingResources executor.ExecutorResources
 
 		BeforeEach(func() {
-			resources = executor.NewExecutorResources(1024, 1024, 3)
-			containerStore.RemainingResourcesReturns(resources)
+			remainingResources = executor.NewExecutorResources(1024, 1024, 3)
+			containerStore.RemainingResourcesReturns(remainingResources)
 		})
 
 		It("should reduce resources used by allocated and running containers", func() {
 			actualResources, err := depotClient.RemainingResources(logger)
 			Expect(err).NotTo(HaveOccurred())
-			Expect(actualResources).To(Equal(resources))
+			Expect(actualResources).To(Equal(remainingResources))
 		})
-	})
-
-	Describe("TotalResources", func() {
-		Context("when asked for total resources", func() {
-			Context("when disk path is not provided", func() {
-				It("should return the resources it was configured with", func() {
-					Expect(depotClient.TotalResources(logger)).To(Equal(resources))
-				})
-			})
-
-			Context("when disk path is provided", func() {
-				BeforeEach(func() {
-					diskPath = os.TempDir()
-				})
 
-				It("should return the resources it was configured with, with live disk capacity", func() {
-					totalResources, err := depotClient.TotalResources(logger)
-					Expect(err).NotTo(HaveOccurred())
+		Context("when disk path is configured and partition has less space than the store reports", func() {
+			var tmpDir string
 
-					Expect(totalResources.MemoryMB).To(Equal(resources.MemoryMB))
-					Expect(totalResources.Containers).To(Equal(resources.Containers))
+			BeforeEach(func() {
+				var err error
+				tmpDir, err = os.MkdirTemp("", "depot-remaining-disk-test")
+				Expect(err).NotTo(HaveOccurred())
+				diskPath = tmpDir
+				containerStore.RemainingResourcesReturns(executor.NewExecutorResources(1024, math.MaxInt32, 3))
+			})
 
-					// disk capacity should be updated
-					Expect(totalResources.DiskMB).NotTo(Equal(resources.DiskMB))
-					Expect(totalResources.DiskMB).To(BeNumerically(">", 0))
-					Expect(totalResources.DiskMB).To(BeNumerically("<=", math.MaxInt32))
-				})
+			It("caps remaining disk at the live partition free space from syscall.Statfs", func() {
+				result, err := depotClient.RemainingResources(logger)
+				Expect(err).NotTo(HaveOccurred())
+				Expect(result.DiskMB).NotTo(Equal(math.MaxInt32))
+				Expect(result.DiskMB).To(BeNumerically(">", 0))
 			})
 		})
 	})
 
+	Describe("TotalResources", func() {
+		It("returns the static startup resources", func() {
+			Expect(depotClient.TotalResources(logger)).To(Equal(resources))
+		})
+	})
+
 	Describe("VolumeDrivers", func() {
 		Context("when getting volume drivers succeeds", func() {
 			BeforeEach(func() {

src/code.cloudfoundry.org/executor/depot/depot_unix.go

@@ -1,17 +1,13 @@
 //go:build !windows
-// +build !windows
 
 package depot
 
 import "syscall"
 
-func getDiskMB(diskPath string, fallback int) int {
-	if diskPath == "" {
-		return fallback
-	}
+func liveDiskMB(path string) (int, bool) {
 	var stat syscall.Statfs_t
-	if err := syscall.Statfs(diskPath, &stat); err == nil {
-		return int(int64(stat.Bavail) * int64(stat.Bsize) / (1024 * 1024))
+	if err := syscall.Statfs(path, &stat); err != nil {
+		return 0, false
 	}
-	return fallback
+	return int(int64(stat.Bavail) * int64(stat.Bsize) / (1024 * 1024)), true
 }

src/code.cloudfoundry.org/executor/depot/depot_windows.go

@@ -1,8 +1,7 @@
 //go:build windows
-// +build windows
 
 package depot
 
-func getDiskMB(_ string, fallback int) int {
-	return fallback
+func liveDiskMB(path string) (int, bool) {
+	return 0, false
 }

src/code.cloudfoundry.org/executor/initializer/initializer.go

@@ -86,7 +86,7 @@ type ExecutorConfig struct {
 	InstanceIdentityPrivateKeyPath        string                `json:"instance_identity_private_key_path,omitempty"`
 	InstanceIdentityValidityPeriod        durationjson.Duration `json:"instance_identity_validity_period,omitempty"`
 	MaxCacheSizeInBytes                   uint64                `json:"max_cache_size_in_bytes,omitempty"`
-	MinCachePartitionFreeBytes            uint64                `json:"min_cache_partition_free_bytes,omitempty"`
+	MinCachePartitionFreeBytes            *uint64               `json:"min_cache_partition_free_bytes,omitempty"`
 	MaxConcurrentDownloads                int                   `json:"max_concurrent_downloads,omitempty"`
 	MaxLogLinesPerSecond                  int                   `json:"max_log_lines_per_second"`
 	MemoryMB                              string                `json:"memory_mb,omitempty"`

src/code.cloudfoundry.org/executor/initializer/initializer_garden.go

@@ -132,9 +132,9 @@ func Initialize(
 	downloader := cacheddownloader.NewDownloader(10*time.Minute, math.MaxInt8, assetTLSConfig)
 	uploader := uploader.New(logger, 10*time.Minute, assetTLSConfig)
 
-	minFree := int64(config.MinCachePartitionFreeBytes)
-	if minFree == 0 {
-		minFree = defaultMinCachePartitionFreeBytes
+	minFree := int64(defaultMinCachePartitionFreeBytes)
+	if config.MinCachePartitionFreeBytes != nil {
+		minFree = int64(*config.MinCachePartitionFreeBytes)
 	}
 	cache := cacheddownloader.NewCache(config.CachePath, int64(config.MaxCacheSizeInBytes), minFree)
 	cachedDownloader, err := cacheddownloader.New(