From 446948bc829ed8920a5bd822edbf81cdddc239c0 Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Tue, 5 May 2026 23:31:52 -0600
Subject: [PATCH 01/12] Scrub attribute cache and add listingComplete flag.

---
 component/attr_cache/attr_cache.go | 171 +++++++++++++++++------------
 component/attr_cache/cacheMap.go   |   2 +
 2 files changed, 104 insertions(+), 69 deletions(-)

diff --git a/component/attr_cache/attr_cache.go b/component/attr_cache/attr_cache.go
index afa5e1a06..c80eb5cc0 100644
--- a/component/attr_cache/attr_cache.go
+++ b/component/attr_cache/attr_cache.go
@@ -239,15 +239,6 @@ func (ac *AttrCache) deleteDirectory(path string, deletedAt time.Time) error {
 	return nil
 }
 
-// does the cache show this path as existing?
-func (ac *AttrCache) pathExistsInCache(path string) bool {
-	item, found := ac.cache.get(path)
-	if !found {
-		return false
-	}
-	return item.exists()
-}
-
 // returns the parent directory (without a trailing slash)
 func getParentDir(childPath string) string {
 	parentDir := path.Dir(internal.TruncateDirName(childPath))
@@ -466,33 +457,43 @@ func (ac *AttrCache) CreateDir(options internal.CreateDirOptions) error {
 		ac.cacheLock.Lock()
 		defer ac.cacheLock.Unlock()
 		// does the directory already exist?
-		oldDirAttrCacheItem, found := ac.cache.get(options.Name)
-		directoryAlreadyExists := found && oldDirAttrCacheItem.exists()
+		dirAttrCacheItem, found := ac.cache.get(options.Name)
+		directoryAlreadyExists := found && dirAttrCacheItem.exists()
 		// if the attribute cache tracks directory existence
 		// then prevent redundant directory creation
-		if ac.cacheDirs && directoryAlreadyExists {
-			return os.ErrExist
-		}
-		// invalidate existing directory entry (this is redundant but readable)
-		if found {
-			oldDirAttrCacheItem.invalidate()
-		}
-		// add (or replace) the directory entry
-		newDirAttr := internal.CreateObjAttrDir(options.Name)
-		newDirAttrCacheItem := ac.cache.insert(insertOptions{
-			attr:     newDirAttr,
-			exists:   true,
-			cachedAt: currentTime,
-		})
-		if newDirAttrCacheItem != nil {
-			newDirAttrCacheItem.setMode(options.Mode)
-		}
-		// update flags for tracking directory existence
-		if ac.cacheDirs && newDirAttrCacheItem != nil {
-			newDirAttrCacheItem.markInCloud(false)
+		if directoryAlreadyExists {
+			if ac.cacheDirs {
+				return os.ErrExist
+			}
+		} else {
+			// invalidate existing directory entry (this is redundant but readable)
+			if found {
+				dirAttrCacheItem.invalidate()
+			}
+			// add (or replace) the directory entry
+			newDirAttr := internal.CreateObjAttrDir(options.Name)
+			dirAttrCacheItem = ac.cache.insert(insertOptions{
+				attr:     newDirAttr,
+				exists:   true,
+				cachedAt: currentTime,
+			})
+			// insert returns nil when entries are maxed out
+			if dirAttrCacheItem != nil {
+				// update flag for tracking directory existence
+				if ac.cacheDirs {
+					dirAttrCacheItem.markInCloud(false)
+				}
+				// this is a new directory, so we have a complete (empty) listing for it
+				dirAttrCacheItem.listingComplete = true
+			}
+			// if this is a new entry, update the parent directory timestamps
+			if err == nil {
+				ac.touchParentDirTimes(options.Name, currentTime, ac.cacheDirs)
+			}
 		}
-		if err == nil && !directoryAlreadyExists {
-			ac.touchParentDirTimes(options.Name, currentTime, ac.cacheDirs)
+		// if returning success, update the mode
+		if err == nil && dirAttrCacheItem != nil {
+			dirAttrCacheItem.setMode(options.Mode)
 		}
 	}
 	return err
@@ -579,15 +580,6 @@ func (ac *AttrCache) StreamDir(
 			}
 		}
 	}
-	// add cached items in
-	if len(cachedPathList) > 0 {
-		log.Info(
-			"AttrCache::StreamDir : %s merging in %d list cache entries...",
-			options.Name,
-			len(cachedPathList),
-		)
-		pathList = append(pathList, cachedPathList...)
-	}
 	// values should be returned in ascending order by key, without duplicates
 	// sort
 	slices.SortFunc[[]*internal.ObjAttr, *internal.ObjAttr](
@@ -603,7 +595,18 @@ func (ac *AttrCache) StreamDir(
 			return a.Path == b.Path
 		},
 	)
-	ac.cacheListSegment(pathList, options.Name, options.Token, nextToken)
+	// cache the listing (if there was no error)
+	if err == nil {
+		// record when the directory was listed, an up to what token
+		// this will allow us to serve directory listings from this cache
+		ac.cacheListSegment(pathList, options.Name, options.Token, nextToken)
+		// if the listing is complete, record the fact that we have a complete listing
+		if nextToken == "" {
+			ac.markListingComplete(options.Name)
+		}
+	} else {
+		log.Err("AttrCache::StreamDir : %s encountered error [%v]", options.Name, err)
+	}
 	log.Trace("AttrCache::StreamDir : %s returning %d entries", options.Name, len(pathList))
 	return pathList, nextToken, err
 }
@@ -616,9 +619,8 @@ func (ac *AttrCache) fetchCachedDirList(
 	path string,
 	token string,
 ) ([]*internal.ObjAttr, string, error) {
-	var pathList []*internal.ObjAttr
 	if !ac.cacheOnList {
-		return pathList, "", fmt.Errorf("cache on list is disabled")
+		return nil, "", fmt.Errorf("cache on list is disabled")
 	}
 	// start accessing the cache
 	ac.cacheLock.RLock()
@@ -627,25 +629,22 @@ func (ac *AttrCache) fetchCachedDirList(
 	listDirCache, found := ac.cache.get(path)
 	if !found {
 		log.Warn("AttrCache::fetchCachedDirList : %s directory not found in cache", path)
-		return pathList, "", fmt.Errorf("%s directory not found in cache", path)
+		return nil, "", fmt.Errorf("%s directory not found in cache", path)
 	}
 	// is the requested data cached?
-	if listDirCache.listCache == nil {
-		listDirCache.listCache = make(map[string]listCacheSegment)
-	}
 	cachedListSegment, found := listDirCache.listCache[token]
 	if !found {
 		// the data for this token is not in the cache
 		// don't provide cached data when new (uncached) data is being requested
 		log.Info("AttrCache::fetchCachedDirList : %s listing segment %s not cached", path, token)
-		return pathList, "", fmt.Errorf("%s directory listing segment %s not cached", path, token)
+		return nil, "", fmt.Errorf("%s directory listing segment %s not cached", path, token)
 	}
 	// check timeout
 	if time.Since(cachedListSegment.cachedAt).Seconds() >= float64(ac.cacheTimeout) {
 		log.Info("AttrCache::fetchCachedDirList : %s listing segment %s cache expired", path, token)
 		// drop the invalid segment from the list cache
 		delete(listDirCache.listCache, token)
-		return pathList, "", fmt.Errorf(
+		return nil, "", fmt.Errorf(
 			"%s directory listing segment %s cache expired",
 			path,
 			token,
@@ -727,6 +726,15 @@ func (ac *AttrCache) cacheListSegment(
 		listDirPath, token, nextToken, len(pathList))
 }
 
+func (ac *AttrCache) markListingComplete(listDirPath string) {
+	ac.cacheLock.Lock()
+	defer ac.cacheLock.Unlock()
+	listDirItem, found := ac.cache.get(listDirPath)
+	if found {
+		listDirItem.listingComplete = true
+	}
+}
+
 // IsDirEmpty: Whether or not the directory is empty
 func (ac *AttrCache) IsDirEmpty(options internal.IsDirEmptyOptions) bool {
 	log.Trace("AttrCache::IsDirEmpty : %s", options.Name)
@@ -737,14 +745,15 @@ func (ac *AttrCache) IsDirEmpty(options internal.IsDirEmptyOptions) bool {
 			"AttrCache::IsDirEmpty : %s Dir cache is disabled. Checking with container",
 			options.Name,
 		)
+		// when offline, this will return false
 		return ac.NextComponent().IsDirEmpty(options)
 	}
 	// Is the directory in our cache?
 	ac.cacheLock.RLock()
-	pathInCache := ac.pathExistsInCache(options.Name)
-	ac.cacheLock.RUnlock()
+	defer ac.cacheLock.RUnlock()
+	item, found := ac.cache.get(options.Name)
 	// If the directory does not exist in the attribute cache then let the next component answer
-	if !pathInCache {
+	if !found || !item.exists() {
 		log.Debug(
 			"AttrCache::IsDirEmpty : %s not found in attr_cache. Checking with container",
 			options.Name,
@@ -753,10 +762,15 @@ func (ac *AttrCache) IsDirEmpty(options internal.IsDirEmptyOptions) bool {
 	}
 	log.Debug("AttrCache::IsDirEmpty : %s found in attr_cache", options.Name)
 	// Check if the cached directory is empty or not
-	if ac.anyContentsInCache(options.Name) {
+	if item.hasExistingChildren() {
 		log.Debug("AttrCache::IsDirEmpty : %s has a subpath in attr_cache", options.Name)
 		return false
 	}
+	// do we have a complete listing?
+	if item.listingComplete {
+		// we know the directory is empty
+		return true
+	}
 	// Dir is in cache but no contents are, so check with container
 	log.Debug(
 		"AttrCache::IsDirEmpty : %s children not found in cache. Checking with container",
@@ -765,16 +779,10 @@ func (ac *AttrCache) IsDirEmpty(options internal.IsDirEmptyOptions) bool {
 	return ac.NextComponent().IsDirEmpty(options)
 }
 
-func (ac *AttrCache) anyContentsInCache(prefix string) bool {
-	ac.cacheLock.RLock()
-	defer ac.cacheLock.RUnlock()
-
-	directory, found := ac.cache.get(prefix)
-	if found && directory.exists() {
-		for _, chldItem := range directory.children {
-			if chldItem.exists() {
-				return true
-			}
+func (value *attrCacheItem) hasExistingChildren() bool {
+	for _, childItem := range value.children {
+		if childItem.exists() {
+			return true
 		}
 	}
 	return false
@@ -796,7 +804,7 @@ func (ac *AttrCache) RenameDir(options internal.RenameDirOptions) error {
 		if ac.cacheDirs {
 			// if attr_cache is tracking directories, validate this rename
 			// First, check if the destination directory already exists
-			if ac.pathExistsInCache(options.Dst) {
+			if item, found := ac.cache.get(options.Dst); found && item.exists() {
 				return os.ErrExist
 			}
 		} else {
@@ -1159,10 +1167,9 @@ func (ac *AttrCache) GetAttr(options internal.GetAttrOptions) (*internal.ObjAttr
 
 	ac.cacheLock.RLock()
 	value, found := ac.cache.get(options.Name)
-	ac.cacheLock.RUnlock()
 	if found && value.valid() && time.Since(value.cachedAt).Seconds() < float64(ac.cacheTimeout) {
-		// Try to serve the request from the attribute cache
-		// Is the entry marked deleted?
+		ac.cacheLock.RUnlock()
+		// Serve the request from the attribute cache
 		if !value.exists() {
 			log.Debug("AttrCache::GetAttr : %s (ENOENT) served from cache", options.Name)
 			return nil, syscall.ENOENT
@@ -1170,6 +1177,32 @@ func (ac *AttrCache) GetAttr(options internal.GetAttrOptions) (*internal.ObjAttr
 			return value.attr, nil
 		}
 	}
+	if ac.cacheDirs {
+		// drill up for the nearest valid parent directory attribute cache
+		foundCachedParent := false
+		for parent := getParentDir(options.Name); ; parent = getParentDir(parent) {
+			value, found = ac.cache.get(parent)
+			// skip invalid data
+			if !found || !value.valid() {
+				if parent == "" {
+					// no valid parent found
+					break
+				}
+				continue
+			}
+			// don't trust expired entries
+			if time.Since(value.cachedAt).Seconds() > float64(ac.cacheTimeout) {
+				break
+			}
+			// found the nearest cached parent
+			// if it does not exist, or has a complete listing, then our target does not exist
+			foundCachedParent = !value.exists() || value.listingComplete
+		}
+		ac.cacheLock.RUnlock()
+		if foundCachedParent {
+			return nil, syscall.ENOENT
+		}
+	}
 
 	// Get the attributes from next component and cache them
 	pathAttr, err := ac.NextComponent().GetAttr(options)
diff --git a/component/attr_cache/cacheMap.go b/component/attr_cache/cacheMap.go
index a39f6cfe1..d001c3749 100644
--- a/component/attr_cache/cacheMap.go
+++ b/component/attr_cache/cacheMap.go
@@ -58,6 +58,8 @@ type attrCacheItem struct {
 	attrFlag  common.BitMap64
 	children  map[string]*attrCacheItem
 	parent    *attrCacheItem
+
+	listingComplete bool
 }
 
 // all cache entries are organized into this structure

From 4ece5da059048205e0a10d40ae7825527611e6f9 Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Thu, 7 May 2026 18:30:00 -0600
Subject: [PATCH 02/12] Change listingComplete to a timestamp so it can expire

---
 component/attr_cache/attr_cache.go      | 46 ++++++++-----------
 component/attr_cache/attr_cache_test.go | 59 +++++++++++++++++++++++++
 component/attr_cache/cacheMap.go        | 38 +++++++++++++---
 3 files changed, 109 insertions(+), 34 deletions(-)

diff --git a/component/attr_cache/attr_cache.go b/component/attr_cache/attr_cache.go
index c80eb5cc0..d3fb1237c 100644
--- a/component/attr_cache/attr_cache.go
+++ b/component/attr_cache/attr_cache.go
@@ -434,7 +434,7 @@ func (ac *AttrCache) cleanupExpiredEntries() {
 					time.Since(item.cachedAt).Seconds() >= float64(ac.cacheTimeout) {
 					if item.parent != nil {
 						if item.exists() {
-							item.parent.listCache = nil
+							item.parent.clearListCache()
 						}
 						delete(item.parent.children, item.attr.Name)
 					}
@@ -484,7 +484,7 @@ func (ac *AttrCache) CreateDir(options internal.CreateDirOptions) error {
 					dirAttrCacheItem.markInCloud(false)
 				}
 				// this is a new directory, so we have a complete (empty) listing for it
-				dirAttrCacheItem.listingComplete = true
+				dirAttrCacheItem.markListingComplete(currentTime)
 			}
 			// if this is a new entry, update the parent directory timestamps
 			if err == nil {
@@ -602,7 +602,7 @@ func (ac *AttrCache) StreamDir(
 		ac.cacheListSegment(pathList, options.Name, options.Token, nextToken)
 		// if the listing is complete, record the fact that we have a complete listing
 		if nextToken == "" {
-			ac.markListingComplete(options.Name)
+			ac.markListingComplete(options.Name, time.Now())
 		}
 	} else {
 		log.Err("AttrCache::StreamDir : %s encountered error [%v]", options.Name, err)
@@ -726,12 +726,12 @@ func (ac *AttrCache) cacheListSegment(
 		listDirPath, token, nextToken, len(pathList))
 }
 
-func (ac *AttrCache) markListingComplete(listDirPath string) {
+func (ac *AttrCache) markListingComplete(listDirPath string, listedAt time.Time) {
 	ac.cacheLock.Lock()
 	defer ac.cacheLock.Unlock()
 	listDirItem, found := ac.cache.get(listDirPath)
 	if found {
-		listDirItem.listingComplete = true
+		listDirItem.markListingComplete(listedAt)
 	}
 }
 
@@ -767,7 +767,7 @@ func (ac *AttrCache) IsDirEmpty(options internal.IsDirEmptyOptions) bool {
 		return false
 	}
 	// do we have a complete listing?
-	if item.listingComplete {
+	if time.Since(item.listingCompletedAt).Seconds() < float64(ac.cacheTimeout) {
 		// we know the directory is empty
 		return true
 	}
@@ -1177,32 +1177,24 @@ func (ac *AttrCache) GetAttr(options internal.GetAttrOptions) (*internal.ObjAttr
 			return value.attr, nil
 		}
 	}
+	// try to use a parent directory
+	doesNotExist := false
 	if ac.cacheDirs {
 		// drill up for the nearest valid parent directory attribute cache
-		foundCachedParent := false
-		for parent := getParentDir(options.Name); ; parent = getParentDir(parent) {
-			value, found = ac.cache.get(parent)
-			// skip invalid data
-			if !found || !value.valid() {
-				if parent == "" {
-					// no valid parent found
-					break
-				}
-				continue
-			}
-			// don't trust expired entries
-			if time.Since(value.cachedAt).Seconds() > float64(ac.cacheTimeout) {
-				break
+		parent, found := ac.cache.getCachedParent(options.Name)
+		// did we find a fresh entry?
+		if found && time.Since(parent.cachedAt).Seconds() <= float64(ac.cacheTimeout) {
+			// if it does not exist, then the target does not exist
+			if !parent.exists() ||
+				time.Since(parent.listingCompletedAt).Seconds() <= float64(ac.cacheTimeout) {
+				doesNotExist = true
 			}
-			// found the nearest cached parent
-			// if it does not exist, or has a complete listing, then our target does not exist
-			foundCachedParent = !value.exists() || value.listingComplete
-		}
-		ac.cacheLock.RUnlock()
-		if foundCachedParent {
-			return nil, syscall.ENOENT
 		}
 	}
+	ac.cacheLock.RUnlock()
+	if doesNotExist {
+		return nil, syscall.ENOENT
+	}
 
 	// Get the attributes from next component and cache them
 	pathAttr, err := ac.NextComponent().GetAttr(options)
diff --git a/component/attr_cache/attr_cache_test.go b/component/attr_cache/attr_cache_test.go
index 5ebfe446a..99d062734 100644
--- a/component/attr_cache/attr_cache_test.go
+++ b/component/attr_cache/attr_cache_test.go
@@ -957,6 +957,43 @@ func (suite *attrCacheTestSuite) TestIsDirEmptyFalseInCache() {
 	suite.assert.False(empty)
 }
 
+func (suite *attrCacheTestSuite) TestIsDirEmptyCompleteListingFresh() {
+	defer suite.cleanupTest()
+
+	path := "dir/"
+	options := internal.IsDirEmptyOptions{Name: path}
+	suite.addPathToCache(path, false)
+
+	item, found := suite.attrCache.cache.get(internal.TruncateDirName(path))
+	suite.assert.True(found)
+	item.markListingComplete(time.Now())
+
+	suite.mock.EXPECT().IsDirEmpty(options).MaxTimes(0)
+
+	empty := suite.attrCache.IsDirEmpty(options)
+	suite.assert.True(empty)
+}
+
+func (suite *attrCacheTestSuite) TestIsDirEmptyCompleteListingExpired() {
+	defer suite.cleanupTest()
+	suite.cleanupTest()
+	config := "attr_cache:\n  timeout-sec: 1"
+	suite.setupTestHelper(config)
+
+	path := "dir/"
+	options := internal.IsDirEmptyOptions{Name: path}
+	suite.addPathToCache(path, false)
+
+	item, found := suite.attrCache.cache.get(internal.TruncateDirName(path))
+	suite.assert.True(found)
+	item.markListingComplete(time.Now().Add(-2 * time.Second))
+
+	suite.mock.EXPECT().IsDirEmpty(options).Return(false)
+
+	empty := suite.attrCache.IsDirEmpty(options)
+	suite.assert.False(empty)
+}
+
 // Tests Rename Directory
 func (suite *attrCacheTestSuite) TestRenameDir() {
 	defer suite.cleanupTest()
@@ -1835,6 +1872,28 @@ func (suite *attrCacheTestSuite) TestGetAttrEnoentError() {
 	}
 }
 
+func (suite *attrCacheTestSuite) TestGetAttrWithCompleteParentListing() {
+	defer suite.cleanupTest()
+
+	parentPath := "dir"
+	childPath := "dir/missing"
+
+	parentItem := suite.attrCache.cache.insert(insertOptions{
+		attr:     internal.CreateObjAttrDir(parentPath),
+		exists:   true,
+		cachedAt: time.Now(),
+	})
+	suite.assert.NotNil(parentItem)
+	parentItem.markListingComplete(time.Now())
+
+	options := internal.GetAttrOptions{Name: childPath}
+	suite.mock.EXPECT().GetAttr(options).MaxTimes(0)
+
+	result, err := suite.attrCache.GetAttr(options)
+	suite.assert.Equal(syscall.ENOENT, err)
+	suite.assert.Nil(result)
+}
+
 // Tests Cache Timeout
 func (suite *attrCacheTestSuite) TestCacheTimeout() {
 	defer suite.cleanupTest()
diff --git a/component/attr_cache/cacheMap.go b/component/attr_cache/cacheMap.go
index d001c3749..9bf13798e 100644
--- a/component/attr_cache/cacheMap.go
+++ b/component/attr_cache/cacheMap.go
@@ -59,7 +59,7 @@ type attrCacheItem struct {
 	children  map[string]*attrCacheItem
 	parent    *attrCacheItem
 
-	listingComplete bool
+	listingCompletedAt time.Time
 }
 
 // all cache entries are organized into this structure
@@ -152,9 +152,9 @@ func (ctm *cacheTreeMap) insertItem(newItem *attrCacheItem, fromDirList bool) {
 	// add the parent to this item
 	newItem.parent = parentItem
 	// if this changes the parent directory's contents
-	// invalidate the parent's listing cache
+	// invalidate the parent's listing cache state
 	if !fromDirList && newItem.exists() {
-		parentItem.listCache = nil
+		parentItem.clearListCache()
 	}
 	// add the new item to the tree and the map
 	if parentItem.children == nil {
@@ -164,6 +164,19 @@ func (ctm *cacheTreeMap) insertItem(newItem *attrCacheItem, fromDirList bool) {
 	ctm.cacheMap[path] = newItem
 }
 
+func (ctm *cacheTreeMap) getCachedParent(name string) (*attrCacheItem, bool) {
+	if name == "" {
+		return nil, false
+	}
+	parent := getParentDir(name)
+	item, found := ctm.get(parent)
+	if !found || !item.valid() {
+		// drill up recursively
+		return ctm.getCachedParent(parent)
+	}
+	return item, found
+}
+
 func (value *attrCacheItem) valid() bool {
 	return value.attrFlag.IsSet(AttrFlagValid)
 }
@@ -172,6 +185,17 @@ func (value *attrCacheItem) exists() bool {
 	return value.valid() && value.attrFlag.IsSet(AttrFlagExists)
 }
 
+func (value *attrCacheItem) clearListCache() {
+	value.listCache = nil
+	value.listingCompletedAt = time.Time{}
+}
+
+func (value *attrCacheItem) markListingComplete(listedAt time.Time) {
+	value.listingCompletedAt = listedAt
+	// Update cachedAt for the directory itself, since a complete listing is fresh information
+	value.cachedAt = listedAt
+}
+
 // TODO: don't return true for deleted files.
 func (value *attrCacheItem) isInCloud() bool {
 	isObject := !value.attr.IsDir()
@@ -197,11 +221,11 @@ func (value *attrCacheItem) markDeleted(deletedTime time.Time) {
 	for _, val := range value.children {
 		val.markDeleted(deletedTime)
 	}
-	// invalidate the parent's listing cache
+	// invalidate the parent's listing cache state
 	if value.parent == nil {
 		log.Warn("AttrCache::markDeleted : %s has no pointer to its parent", value.attr.Path)
 	} else {
-		value.parent.listCache = nil
+		value.parent.clearListCache()
 	}
 	// update flags and timestamp
 	value.attrFlag.Clear(AttrFlagExists)
@@ -225,11 +249,11 @@ func (value *attrCacheItem) invalidate() {
 	}
 	// set invalid
 	value.attrFlag.Clear(AttrFlagValid)
-	// invalidate the parent's listing cache
+	// invalidate the parent's listing cache state
 	if value.parent == nil {
 		log.Warn("AttrCache::invalidate : %s has no pointer to its parent", value.attr.Path)
 	} else if value.exists() {
-		value.parent.listCache = nil
+		value.parent.clearListCache()
 	}
 }
 

From 900eee8853bf0ac0027e00ebf8f0b004db7f11fb Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Thu, 7 May 2026 21:32:59 -0600
Subject: [PATCH 03/12] Revert "Change listingComplete to a timestamp so it can
 expire"

This reverts commit 4ece5da059048205e0a10d40ae7825527611e6f9.
---
 component/attr_cache/attr_cache.go      | 46 +++++++++++--------
 component/attr_cache/attr_cache_test.go | 59 -------------------------
 component/attr_cache/cacheMap.go        | 38 +++-------------
 3 files changed, 34 insertions(+), 109 deletions(-)

diff --git a/component/attr_cache/attr_cache.go b/component/attr_cache/attr_cache.go
index d3fb1237c..c80eb5cc0 100644
--- a/component/attr_cache/attr_cache.go
+++ b/component/attr_cache/attr_cache.go
@@ -434,7 +434,7 @@ func (ac *AttrCache) cleanupExpiredEntries() {
 					time.Since(item.cachedAt).Seconds() >= float64(ac.cacheTimeout) {
 					if item.parent != nil {
 						if item.exists() {
-							item.parent.clearListCache()
+							item.parent.listCache = nil
 						}
 						delete(item.parent.children, item.attr.Name)
 					}
@@ -484,7 +484,7 @@ func (ac *AttrCache) CreateDir(options internal.CreateDirOptions) error {
 					dirAttrCacheItem.markInCloud(false)
 				}
 				// this is a new directory, so we have a complete (empty) listing for it
-				dirAttrCacheItem.markListingComplete(currentTime)
+				dirAttrCacheItem.listingComplete = true
 			}
 			// if this is a new entry, update the parent directory timestamps
 			if err == nil {
@@ -602,7 +602,7 @@ func (ac *AttrCache) StreamDir(
 		ac.cacheListSegment(pathList, options.Name, options.Token, nextToken)
 		// if the listing is complete, record the fact that we have a complete listing
 		if nextToken == "" {
-			ac.markListingComplete(options.Name, time.Now())
+			ac.markListingComplete(options.Name)
 		}
 	} else {
 		log.Err("AttrCache::StreamDir : %s encountered error [%v]", options.Name, err)
@@ -726,12 +726,12 @@ func (ac *AttrCache) cacheListSegment(
 		listDirPath, token, nextToken, len(pathList))
 }
 
-func (ac *AttrCache) markListingComplete(listDirPath string, listedAt time.Time) {
+func (ac *AttrCache) markListingComplete(listDirPath string) {
 	ac.cacheLock.Lock()
 	defer ac.cacheLock.Unlock()
 	listDirItem, found := ac.cache.get(listDirPath)
 	if found {
-		listDirItem.markListingComplete(listedAt)
+		listDirItem.listingComplete = true
 	}
 }
 
@@ -767,7 +767,7 @@ func (ac *AttrCache) IsDirEmpty(options internal.IsDirEmptyOptions) bool {
 		return false
 	}
 	// do we have a complete listing?
-	if time.Since(item.listingCompletedAt).Seconds() < float64(ac.cacheTimeout) {
+	if item.listingComplete {
 		// we know the directory is empty
 		return true
 	}
@@ -1177,23 +1177,31 @@ func (ac *AttrCache) GetAttr(options internal.GetAttrOptions) (*internal.ObjAttr
 			return value.attr, nil
 		}
 	}
-	// try to use a parent directory
-	doesNotExist := false
 	if ac.cacheDirs {
 		// drill up for the nearest valid parent directory attribute cache
-		parent, found := ac.cache.getCachedParent(options.Name)
-		// did we find a fresh entry?
-		if found && time.Since(parent.cachedAt).Seconds() <= float64(ac.cacheTimeout) {
-			// if it does not exist, then the target does not exist
-			if !parent.exists() ||
-				time.Since(parent.listingCompletedAt).Seconds() <= float64(ac.cacheTimeout) {
-				doesNotExist = true
+		foundCachedParent := false
+		for parent := getParentDir(options.Name); ; parent = getParentDir(parent) {
+			value, found = ac.cache.get(parent)
+			// skip invalid data
+			if !found || !value.valid() {
+				if parent == "" {
+					// no valid parent found
+					break
+				}
+				continue
+			}
+			// don't trust expired entries
+			if time.Since(value.cachedAt).Seconds() > float64(ac.cacheTimeout) {
+				break
 			}
+			// found the nearest cached parent
+			// if it does not exist, or has a complete listing, then our target does not exist
+			foundCachedParent = !value.exists() || value.listingComplete
+		}
+		ac.cacheLock.RUnlock()
+		if foundCachedParent {
+			return nil, syscall.ENOENT
 		}
-	}
-	ac.cacheLock.RUnlock()
-	if doesNotExist {
-		return nil, syscall.ENOENT
 	}
 
 	// Get the attributes from next component and cache them
diff --git a/component/attr_cache/attr_cache_test.go b/component/attr_cache/attr_cache_test.go
index 99d062734..5ebfe446a 100644
--- a/component/attr_cache/attr_cache_test.go
+++ b/component/attr_cache/attr_cache_test.go
@@ -957,43 +957,6 @@ func (suite *attrCacheTestSuite) TestIsDirEmptyFalseInCache() {
 	suite.assert.False(empty)
 }
 
-func (suite *attrCacheTestSuite) TestIsDirEmptyCompleteListingFresh() {
-	defer suite.cleanupTest()
-
-	path := "dir/"
-	options := internal.IsDirEmptyOptions{Name: path}
-	suite.addPathToCache(path, false)
-
-	item, found := suite.attrCache.cache.get(internal.TruncateDirName(path))
-	suite.assert.True(found)
-	item.markListingComplete(time.Now())
-
-	suite.mock.EXPECT().IsDirEmpty(options).MaxTimes(0)
-
-	empty := suite.attrCache.IsDirEmpty(options)
-	suite.assert.True(empty)
-}
-
-func (suite *attrCacheTestSuite) TestIsDirEmptyCompleteListingExpired() {
-	defer suite.cleanupTest()
-	suite.cleanupTest()
-	config := "attr_cache:\n  timeout-sec: 1"
-	suite.setupTestHelper(config)
-
-	path := "dir/"
-	options := internal.IsDirEmptyOptions{Name: path}
-	suite.addPathToCache(path, false)
-
-	item, found := suite.attrCache.cache.get(internal.TruncateDirName(path))
-	suite.assert.True(found)
-	item.markListingComplete(time.Now().Add(-2 * time.Second))
-
-	suite.mock.EXPECT().IsDirEmpty(options).Return(false)
-
-	empty := suite.attrCache.IsDirEmpty(options)
-	suite.assert.False(empty)
-}
-
 // Tests Rename Directory
 func (suite *attrCacheTestSuite) TestRenameDir() {
 	defer suite.cleanupTest()
@@ -1872,28 +1835,6 @@ func (suite *attrCacheTestSuite) TestGetAttrEnoentError() {
 	}
 }
 
-func (suite *attrCacheTestSuite) TestGetAttrWithCompleteParentListing() {
-	defer suite.cleanupTest()
-
-	parentPath := "dir"
-	childPath := "dir/missing"
-
-	parentItem := suite.attrCache.cache.insert(insertOptions{
-		attr:     internal.CreateObjAttrDir(parentPath),
-		exists:   true,
-		cachedAt: time.Now(),
-	})
-	suite.assert.NotNil(parentItem)
-	parentItem.markListingComplete(time.Now())
-
-	options := internal.GetAttrOptions{Name: childPath}
-	suite.mock.EXPECT().GetAttr(options).MaxTimes(0)
-
-	result, err := suite.attrCache.GetAttr(options)
-	suite.assert.Equal(syscall.ENOENT, err)
-	suite.assert.Nil(result)
-}
-
 // Tests Cache Timeout
 func (suite *attrCacheTestSuite) TestCacheTimeout() {
 	defer suite.cleanupTest()
diff --git a/component/attr_cache/cacheMap.go b/component/attr_cache/cacheMap.go
index 9bf13798e..d001c3749 100644
--- a/component/attr_cache/cacheMap.go
+++ b/component/attr_cache/cacheMap.go
@@ -59,7 +59,7 @@ type attrCacheItem struct {
 	children  map[string]*attrCacheItem
 	parent    *attrCacheItem
 
-	listingCompletedAt time.Time
+	listingComplete bool
 }
 
 // all cache entries are organized into this structure
@@ -152,9 +152,9 @@ func (ctm *cacheTreeMap) insertItem(newItem *attrCacheItem, fromDirList bool) {
 	// add the parent to this item
 	newItem.parent = parentItem
 	// if this changes the parent directory's contents
-	// invalidate the parent's listing cache state
+	// invalidate the parent's listing cache
 	if !fromDirList && newItem.exists() {
-		parentItem.clearListCache()
+		parentItem.listCache = nil
 	}
 	// add the new item to the tree and the map
 	if parentItem.children == nil {
@@ -164,19 +164,6 @@ func (ctm *cacheTreeMap) insertItem(newItem *attrCacheItem, fromDirList bool) {
 	ctm.cacheMap[path] = newItem
 }
 
-func (ctm *cacheTreeMap) getCachedParent(name string) (*attrCacheItem, bool) {
-	if name == "" {
-		return nil, false
-	}
-	parent := getParentDir(name)
-	item, found := ctm.get(parent)
-	if !found || !item.valid() {
-		// drill up recursively
-		return ctm.getCachedParent(parent)
-	}
-	return item, found
-}
-
 func (value *attrCacheItem) valid() bool {
 	return value.attrFlag.IsSet(AttrFlagValid)
 }
@@ -185,17 +172,6 @@ func (value *attrCacheItem) exists() bool {
 	return value.valid() && value.attrFlag.IsSet(AttrFlagExists)
 }
 
-func (value *attrCacheItem) clearListCache() {
-	value.listCache = nil
-	value.listingCompletedAt = time.Time{}
-}
-
-func (value *attrCacheItem) markListingComplete(listedAt time.Time) {
-	value.listingCompletedAt = listedAt
-	// Update cachedAt for the directory itself, since a complete listing is fresh information
-	value.cachedAt = listedAt
-}
-
 // TODO: don't return true for deleted files.
 func (value *attrCacheItem) isInCloud() bool {
 	isObject := !value.attr.IsDir()
@@ -221,11 +197,11 @@ func (value *attrCacheItem) markDeleted(deletedTime time.Time) {
 	for _, val := range value.children {
 		val.markDeleted(deletedTime)
 	}
-	// invalidate the parent's listing cache state
+	// invalidate the parent's listing cache
 	if value.parent == nil {
 		log.Warn("AttrCache::markDeleted : %s has no pointer to its parent", value.attr.Path)
 	} else {
-		value.parent.clearListCache()
+		value.parent.listCache = nil
 	}
 	// update flags and timestamp
 	value.attrFlag.Clear(AttrFlagExists)
@@ -249,11 +225,11 @@ func (value *attrCacheItem) invalidate() {
 	}
 	// set invalid
 	value.attrFlag.Clear(AttrFlagValid)
-	// invalidate the parent's listing cache state
+	// invalidate the parent's listing cache
 	if value.parent == nil {
 		log.Warn("AttrCache::invalidate : %s has no pointer to its parent", value.attr.Path)
 	} else if value.exists() {
-		value.parent.clearListCache()
+		value.parent.listCache = nil
 	}
 }
 

From 0ed88acbae2f9f2d55554955f81bbf2ed0687451 Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Thu, 7 May 2026 23:29:25 -0600
Subject: [PATCH 04/12] Use timeout for listingComplete. Correct invalidate
 logic.

---
 component/attr_cache/attr_cache.go | 118 ++++++++++++++++-------------
 component/attr_cache/cacheMap.go   |  14 ++++
 2 files changed, 81 insertions(+), 51 deletions(-)

diff --git a/component/attr_cache/attr_cache.go b/component/attr_cache/attr_cache.go
index c80eb5cc0..e782382b2 100644
--- a/component/attr_cache/attr_cache.go
+++ b/component/attr_cache/attr_cache.go
@@ -428,14 +428,13 @@ func (ac *AttrCache) cleanupExpiredEntries() {
 	if len(keysToDelete) > 0 {
 		ac.cacheLock.Lock()
 		for _, path := range keysToDelete {
-			// Re-check if entry still exists and is still expired
-			if item, exists := ac.cache.cacheMap[path]; exists {
-				if len(item.children) == 0 &&
-					time.Since(item.cachedAt).Seconds() >= float64(ac.cacheTimeout) {
+			// Re-check if entry still exists, has no children, and is still expired
+			if item, found := ac.cache.cacheMap[path]; found && len(item.children) == 0 {
+				if time.Since(item.cachedAt).Seconds() >= float64(ac.cacheTimeout) {
+					if item.exists() {
+						item.invalidate()
+					}
 					if item.parent != nil {
-						if item.exists() {
-							item.parent.listCache = nil
-						}
 						delete(item.parent.children, item.attr.Name)
 					}
 					delete(ac.cache.cacheMap, path)
@@ -468,7 +467,7 @@ func (ac *AttrCache) CreateDir(options internal.CreateDirOptions) error {
 		} else {
 			// invalidate existing directory entry (this is redundant but readable)
 			if found {
-				dirAttrCacheItem.invalidate()
+				dirAttrCacheItem.markDeleted(currentTime)
 			}
 			// add (or replace) the directory entry
 			newDirAttr := internal.CreateObjAttrDir(options.Name)
@@ -732,6 +731,7 @@ func (ac *AttrCache) markListingComplete(listDirPath string) {
 	listDirItem, found := ac.cache.get(listDirPath)
 	if found {
 		listDirItem.listingComplete = true
+		listDirItem.cachedAt = time.Now()
 	}
 }
 
@@ -767,7 +767,7 @@ func (ac *AttrCache) IsDirEmpty(options internal.IsDirEmptyOptions) bool {
 		return false
 	}
 	// do we have a complete listing?
-	if item.listingComplete {
+	if item.listingComplete && time.Since(item.cachedAt).Seconds() < float64(ac.cacheTimeout) {
 		// we know the directory is empty
 		return true
 	}
@@ -1064,18 +1064,10 @@ func (ac *AttrCache) CopyToFile(options internal.CopyToFileOptions) error {
 	log.Trace("AttrCache::CopyToFile : %s", options.Name)
 
 	err := ac.NextComponent().CopyToFile(options)
-	if err != nil {
+	if os.IsNotExist(err) {
 		entry, found := ac.cache.get(options.Name)
-		if found {
-			entry.markDeleted(time.Now())
-		}
-		// todo: invalidating path here rather than updating with etag
-		// due to some changes that are required in az storage comp which
-		// were not necessarily required. Once they were done invalidation
-		// of the attribute can be removed.
-		value, found := ac.cache.get(internal.TruncateDirName(options.Name))
-		if found {
-			value.invalidate()
+		if found && entry.exists() {
+			entry.invalidate()
 		}
 	}
 	return err
@@ -1093,8 +1085,17 @@ func (ac *AttrCache) CopyFromFile(options internal.CopyFromFileOptions) error {
 			return err
 		}
 	}
+	// preserve existing metadata
 	if attr != nil {
-		options.Metadata = attr.Metadata
+		if options.Metadata == nil {
+			options.Metadata = attr.Metadata
+		} else {
+			for key, value := range attr.Metadata {
+				if _, exists := options.Metadata[key]; !exists {
+					options.Metadata[key] = value
+				}
+			}
+		}
 	}
 
 	err = ac.NextComponent().CopyFromFile(options)
@@ -1117,6 +1118,9 @@ func (ac *AttrCache) CopyFromFile(options internal.CopyFromFileOptions) error {
 			entry, found := ac.cache.get(options.Name)
 			if found {
 				entry.invalidate()
+			} else if parent, found := ac.cache.get(getParentDir(options.Name)); found && parent.exists() {
+				parent.listCache = nil
+				parent.listingComplete = false
 			}
 		} else {
 			// replace entry
@@ -1165,53 +1169,53 @@ func (ac *AttrCache) GetAttr(options internal.GetAttrOptions) (*internal.ObjAttr
 	// Don't log these by default, as it noticeably affects performance
 	// log.Trace("AttrCache::GetAttr : %s", options.Name)
 
+	// is the answer in the cache?
+	respondFromCache := false
+	var attrFromCache *internal.ObjAttr
+	var errFromCache error
 	ac.cacheLock.RLock()
 	value, found := ac.cache.get(options.Name)
 	if found && value.valid() && time.Since(value.cachedAt).Seconds() < float64(ac.cacheTimeout) {
-		ac.cacheLock.RUnlock()
 		// Serve the request from the attribute cache
+		respondFromCache = true
 		if !value.exists() {
 			log.Debug("AttrCache::GetAttr : %s (ENOENT) served from cache", options.Name)
-			return nil, syscall.ENOENT
+			errFromCache = syscall.ENOENT
 		} else {
-			return value.attr, nil
+			attrFromCache = value.attr
 		}
 	}
 	if ac.cacheDirs {
 		// drill up for the nearest valid parent directory attribute cache
-		foundCachedParent := false
-		for parent := getParentDir(options.Name); ; parent = getParentDir(parent) {
-			value, found = ac.cache.get(parent)
-			// skip invalid data
-			if !found || !value.valid() {
-				if parent == "" {
-					// no valid parent found
-					break
-				}
-				continue
-			}
-			// don't trust expired entries
-			if time.Since(value.cachedAt).Seconds() > float64(ac.cacheTimeout) {
-				break
+		parent, found := ac.cache.getCachedParent(options.Name)
+		if found && time.Since(parent.cachedAt).Seconds() < float64(ac.cacheTimeout) {
+			// Remember, we have no entry for options.Name
+			// parent is its nearest valid ancestor
+			// So, if parent doesn't exist, options.Name must not exist
+			// Or, if parent does exist, and the full list of its contents are cached,
+			// then since options.Name is *not* in the cache, it must not exist
+			if !parent.exists() || parent.listingComplete {
+				respondFromCache = true
+				errFromCache = syscall.ENOENT
 			}
-			// found the nearest cached parent
-			// if it does not exist, or has a complete listing, then our target does not exist
-			foundCachedParent = !value.exists() || value.listingComplete
-		}
-		ac.cacheLock.RUnlock()
-		if foundCachedParent {
-			return nil, syscall.ENOENT
 		}
 	}
+	ac.cacheLock.RUnlock()
+	if respondFromCache {
+		return attrFromCache, errFromCache
+	}
 
-	// Get the attributes from next component and cache them
+	// The answer is not cached, or it's expired
+	// Get the attributes from next component
 	pathAttr, err := ac.NextComponent().GetAttr(options)
-
+	// return unexpected errors immediately (no valid response to cache)
+	if err != nil && !os.IsNotExist(err) {
+		return pathAttr, err
+	}
+	// response is valid - cache it
 	ac.cacheLock.Lock()
 	defer ac.cacheLock.Unlock()
-
-	switch err {
-	case nil:
+	if err == nil {
 		// Retrieved attributes so cache them
 		ac.cache.insert(insertOptions{
 			attr:     pathAttr,
@@ -1221,7 +1225,7 @@ func (ac *AttrCache) GetAttr(options internal.GetAttrOptions) (*internal.ObjAttr
 		if ac.cacheDirs {
 			ac.markAncestorsInCloud(getParentDir(options.Name), time.Now())
 		}
-	case syscall.ENOENT:
+	} else {
 		// cache this entity not existing
 		ac.cache.insert(insertOptions{
 			attr:     internal.CreateObjAttr(options.Name, 0, time.Now()),
@@ -1272,6 +1276,12 @@ func (ac *AttrCache) FlushFile(options internal.FlushFileOptions) error {
 		toBeInvalid, found := ac.cache.get(options.Handle.Path)
 		if found {
 			toBeInvalid.invalidate()
+		} else if parent, found := ac.cache.get(getParentDir(options.Handle.Path)); found && parent.exists() {
+			parent.listCache = nil
+			parent.listingComplete = false
+		}
+		if ac.cacheDirs {
+			ac.markAncestorsInCloud(getParentDir(options.Handle.Path), time.Now())
 		}
 	}
 	return err
@@ -1319,6 +1329,12 @@ func (ac *AttrCache) CommitData(options internal.CommitDataOptions) error {
 		entry, found := ac.cache.get(options.Name)
 		if found {
 			entry.invalidate()
+		} else if parent, found := ac.cache.get(getParentDir(options.Name)); found && parent.exists() {
+			parent.listCache = nil
+			parent.listingComplete = false
+		}
+		if ac.cacheDirs {
+			ac.markAncestorsInCloud(getParentDir(options.Name), time.Now())
 		}
 	}
 	return err
diff --git a/component/attr_cache/cacheMap.go b/component/attr_cache/cacheMap.go
index d001c3749..cd0d43819 100644
--- a/component/attr_cache/cacheMap.go
+++ b/component/attr_cache/cacheMap.go
@@ -164,6 +164,19 @@ func (ctm *cacheTreeMap) insertItem(newItem *attrCacheItem, fromDirList bool) {
 	ctm.cacheMap[path] = newItem
 }
 
+func (ctm *cacheTreeMap) getCachedParent(name string) (*attrCacheItem, bool) {
+	if name == "" {
+		return nil, false
+	}
+	parent := getParentDir(name)
+	item, found := ctm.get(parent)
+	if !found || !item.valid() {
+		// drill up recursively
+		return ctm.getCachedParent(parent)
+	}
+	return item, found
+}
+
 func (value *attrCacheItem) valid() bool {
 	return value.attrFlag.IsSet(AttrFlagValid)
 }
@@ -230,6 +243,7 @@ func (value *attrCacheItem) invalidate() {
 		log.Warn("AttrCache::invalidate : %s has no pointer to its parent", value.attr.Path)
 	} else if value.exists() {
 		value.parent.listCache = nil
+		value.parent.listingComplete = false
 	}
 }
 

From 03bf432f68fd74c85110dd30b265f73ec57b5b4e Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Thu, 7 May 2026 23:41:48 -0600
Subject: [PATCH 05/12] Add unit tests for lstingComplete expiration.

---
 component/attr_cache/attr_cache_test.go | 36 +++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/component/attr_cache/attr_cache_test.go b/component/attr_cache/attr_cache_test.go
index 5ebfe446a..20c52f5a2 100644
--- a/component/attr_cache/attr_cache_test.go
+++ b/component/attr_cache/attr_cache_test.go
@@ -957,6 +957,42 @@ func (suite *attrCacheTestSuite) TestIsDirEmptyFalseInCache() {
 	suite.assert.False(empty)
 }
 
+func (suite *attrCacheTestSuite) TestIsDirEmptyCompleteListingFresh() {
+	defer suite.cleanupTest()
+
+	path := "dir/"
+	options := internal.IsDirEmptyOptions{Name: path}
+	suite.addPathToCache(path, false)
+
+	item, found := suite.attrCache.cache.get(path)
+	suite.assert.True(found)
+	item.listingComplete = true
+
+	suite.mock.EXPECT().IsDirEmpty(options).MaxTimes(0)
+
+	empty := suite.attrCache.IsDirEmpty(options)
+	suite.assert.True(empty)
+}
+
+func (suite *attrCacheTestSuite) TestIsDirEmptyCompleteListingExpired() {
+	defer suite.cleanupTest()
+
+	path := "dir/"
+	options := internal.IsDirEmptyOptions{Name: path}
+	suite.addPathToCache(path, false)
+
+	item, found := suite.attrCache.cache.get(path)
+	suite.assert.True(found)
+	item.listingComplete = true
+	item.cachedAt = time.Now().
+		Add(-(time.Duration(suite.attrCache.cacheTimeout) * time.Second) - time.Minute)
+
+	suite.mock.EXPECT().IsDirEmpty(options).Return(false)
+
+	empty := suite.attrCache.IsDirEmpty(options)
+	suite.assert.False(empty)
+}
+
 // Tests Rename Directory
 func (suite *attrCacheTestSuite) TestRenameDir() {
 	defer suite.cleanupTest()

From bf0fdc167a05fb1631c92a60091732486e7d6e61 Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Thu, 7 May 2026 23:47:53 -0600
Subject: [PATCH 06/12] Add GetAttr listingComplete test

---
 component/attr_cache/attr_cache_test.go | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/component/attr_cache/attr_cache_test.go b/component/attr_cache/attr_cache_test.go
index 20c52f5a2..fa53a3de4 100644
--- a/component/attr_cache/attr_cache_test.go
+++ b/component/attr_cache/attr_cache_test.go
@@ -1871,6 +1871,25 @@ func (suite *attrCacheTestSuite) TestGetAttrEnoentError() {
 	}
 }
 
+func (suite *attrCacheTestSuite) TestGetAttrWithCompleteParentListing() {
+	defer suite.cleanupTest()
+
+	parentPath := "dir/"
+	childPath := "dir/missing"
+
+	suite.addPathToCache(parentPath, false)
+	parentItem, found := suite.attrCache.cache.get(parentPath)
+	suite.assert.True(found)
+	parentItem.listingComplete = true
+
+	options := internal.GetAttrOptions{Name: childPath}
+	suite.mock.EXPECT().GetAttr(options).MaxTimes(0)
+
+	result, err := suite.attrCache.GetAttr(options)
+	suite.assert.Equal(syscall.ENOENT, err)
+	suite.assert.Nil(result)
+}
+
 // Tests Cache Timeout
 func (suite *attrCacheTestSuite) TestCacheTimeout() {
 	defer suite.cleanupTest()

From 74a729d0f8153d37436ab4fdf5d00b1a77e9cdfb Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Fri, 8 May 2026 16:54:00 -0600
Subject: [PATCH 07/12] Correct unit test

---
 component/attr_cache/attr_cache_test.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/component/attr_cache/attr_cache_test.go b/component/attr_cache/attr_cache_test.go
index 62f3373d7..d43e073ac 100644
--- a/component/attr_cache/attr_cache_test.go
+++ b/component/attr_cache/attr_cache_test.go
@@ -1826,6 +1826,7 @@ func (suite *attrCacheTestSuite) TestGetAttrDoesNotExist() {
 func (suite *attrCacheTestSuite) TestGetAttrOtherError() {
 	defer suite.cleanupTest()
 	var paths = []string{"a", "a/"}
+	errOther := errors.New("some other error")
 
 	for _, path := range paths {
 		// This is a little janky but required since testify suite does not support running setup or clean up for subtests.
@@ -1835,10 +1836,10 @@ func (suite *attrCacheTestSuite) TestGetAttrOtherError() {
 			truncatedPath := internal.TruncateDirName(path)
 
 			options := internal.GetAttrOptions{Name: path}
-			suite.mock.EXPECT().GetAttr(options).Return(nil, os.ErrNotExist)
+			suite.mock.EXPECT().GetAttr(options).Return(nil, errOther)
 
 			result, err := suite.attrCache.GetAttr(options)
-			suite.assert.Equal(err, os.ErrNotExist)
+			suite.assert.Equal(errOther, err)
 			suite.assert.Nil(result)
 			suite.assertNotInCache(truncatedPath)
 		})

From 6d95eea51b56e9873a20d9fc9c715e60dc267db8 Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Fri, 8 May 2026 17:39:38 -0600
Subject: [PATCH 08/12] CI fix: Cleanup shared space after each test

---
 test/e2e_tests/file_test.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/e2e_tests/file_test.go b/test/e2e_tests/file_test.go
index 223482fe4..b7719cd06 100644
--- a/test/e2e_tests/file_test.go
+++ b/test/e2e_tests/file_test.go
@@ -174,6 +174,8 @@ func (suite *fileTestSuite) TestOpenFlag_O_TRUNC() {
 	suite.Equal(0, read)
 	err = srcFile.Close()
 	suite.NoError(err)
+
+	suite.fileTestCleanup([]string{fileName})
 }
 
 func (suite *fileTestSuite) TestFileCreateUtf8Char() {
@@ -471,7 +473,7 @@ func (suite *fileTestSuite) TestFileCopy() {
 	err = dstFile.Close()
 	suite.NoError(err)
 
-	suite.fileTestCleanup([]string{dirName})
+	suite.fileTestCleanup([]string{dirName, fileName})
 }
 
 // # Get stats of a file

From ce158c463c9d817ca30bab5a683bb887f90067af Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Fri, 8 May 2026 17:50:20 -0600
Subject: [PATCH 09/12] Check mount success before running end-to-end tests.

---
 test/e2e_tests/data_validation_test.go | 11 ++++++++++-
 test/e2e_tests/dir_test.go             |  7 ++++++-
 test/e2e_tests/file_test.go            |  7 ++++++-
 3 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/test/e2e_tests/data_validation_test.go b/test/e2e_tests/data_validation_test.go
index 4244244d2..a0bc1e7e9 100644
--- a/test/e2e_tests/data_validation_test.go
+++ b/test/e2e_tests/data_validation_test.go
@@ -944,9 +944,18 @@ func TestDataValidationTestSuite(t *testing.T) {
 		fmt.Printf("Could not cleanup cache dir before testing [%s]\n", err.Error())
 	}
 
+	// Validate mount path exists before trying to create subdirectories
+	if _, err := os.Stat(dataValidationMntPathPtr); err != nil {
+		t.Fatalf(
+			"Mount path does not exist or is not accessible: %s [%v]",
+			dataValidationMntPathPtr,
+			err,
+		)
+	}
+
 	err = os.Mkdir(tObj.testMntPath, 0777)
 	if err != nil {
-		t.Errorf("Failed to create test directory [%s]\n", err.Error())
+		t.Fatalf("Failed to create test directory [%s]", err.Error())
 	}
 	_, _ = rand.Read(minBuff)
 	_, _ = rand.Read(medBuff)
diff --git a/test/e2e_tests/dir_test.go b/test/e2e_tests/dir_test.go
index a4e2dbfc2..4d8ba4770 100644
--- a/test/e2e_tests/dir_test.go
+++ b/test/e2e_tests/dir_test.go
@@ -910,9 +910,14 @@ func TestDirTestSuite(t *testing.T) {
 		fmt.Printf("Could not cleanup feature dir before testing [%s]\n", err.Error())
 	}
 
+	// Validate mount path exists before trying to create subdirectories
+	if _, err := os.Stat(pathPtr); err != nil {
+		t.Fatalf("Mount path does not exist or is not accessible: %s [%v]", pathPtr, err)
+	}
+
 	err = os.Mkdir(dirTest.testPath, 0777)
 	if err != nil {
-		t.Errorf("Failed to create test directory [%s]\n", err.Error())
+		t.Fatalf("Failed to create test directory [%s]", err.Error())
 	}
 	_, _ = rand.Read(dirTest.minBuff)
 	_, _ = rand.Read(dirTest.medBuff)
diff --git a/test/e2e_tests/file_test.go b/test/e2e_tests/file_test.go
index b7719cd06..acd6ae550 100644
--- a/test/e2e_tests/file_test.go
+++ b/test/e2e_tests/file_test.go
@@ -872,9 +872,14 @@ func TestFileTestSuite(t *testing.T) {
 		fmt.Printf("Could not cleanup feature dir before testing [%s]\n", err.Error())
 	}
 
+	// Validate mount path exists before trying to create subdirectories
+	if _, err := os.Stat(fileTestPathPtr); err != nil {
+		t.Fatalf("Mount path does not exist or is not accessible: %s [%v]", fileTestPathPtr, err)
+	}
+
 	err = os.Mkdir(fileTest.testPath, 0777)
 	if err != nil {
-		t.Errorf("Failed to create test directory [%s]\n", err.Error())
+		t.Fatalf("Failed to create test directory [%s]", err.Error())
 	}
 	_, _ = rand.Read(fileTest.minBuff)
 	_, _ = rand.Read(fileTest.medBuff)

From 2ba79bdd952f2cdff73013e123ffcfe933c681cd Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Fri, 8 May 2026 18:01:09 -0600
Subject: [PATCH 10/12] Extend CI mount timeout to improve reliability.

---
 .github/workflows/code-coverage.yml | 47 +++++++++++++++--------------
 1 file changed, 24 insertions(+), 23 deletions(-)

diff --git a/.github/workflows/code-coverage.yml b/.github/workflows/code-coverage.yml
index 1c5355a71..4cb05d60a 100644
--- a/.github/workflows/code-coverage.yml
+++ b/.github/workflows/code-coverage.yml
@@ -41,6 +41,7 @@ jobs:
       cloudfuse_CFG: "./cloudfuse.yaml"
       cloudfuse_STREAM_CFG: "./cloudfuse_stream.yaml"
       cloudfuse_BLOCK_CFG: "./cloudfuse_block.yaml"
+      MOUNT_READY_TIMEOUT: 60
       zig: 0.15.2
       GH_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -210,7 +211,7 @@ jobs:
           rm -rf ${TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_block.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -257,7 +258,7 @@ jobs:
           cat /tmp/configBlockProfilerTemp.yaml
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_block_profiler.cov mount ${MOUNT_DIR} --config-file=/tmp/configBlockProfilerTemp.yaml --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -309,7 +310,7 @@ jobs:
           rm -rf ${BLOCK_TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_block_block_cache.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -363,7 +364,7 @@ jobs:
           rm -rf ${TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_adls.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_ADLS_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -410,7 +411,7 @@ jobs:
           cat /tmp/configAdlsProfilerTemp.yaml
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_adls_profiler.cov mount ${MOUNT_DIR} --config-file=/tmp/configAdlsProfilerTemp.yaml --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -465,7 +466,7 @@ jobs:
           rm -rf ${TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_s3.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -510,7 +511,7 @@ jobs:
           cat /tmp/configBlockProfilerTemp.yaml
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_s3_profiler.cov mount ${MOUNT_DIR} --config-file=/tmp/configBlockProfilerTemp.yaml --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -558,7 +559,7 @@ jobs:
           rm -rf ${BLOCK_TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_s3_block_cache.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -613,7 +614,7 @@ jobs:
           rm -rf ${TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_s3.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -875,7 +876,7 @@ jobs:
           cat /tmp/configAdlsProfilerTemp.yaml
           ./cloudfuse.test mount ${MOUNT_DIR}/hmon_test --config-file=/tmp/configAdlsProfilerTemp.yaml
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -906,7 +907,7 @@ jobs:
           cat /tmp/configAdlsProfilerTemp.yaml
           ./cloudfuse.test mount ${MOUNT_DIR}/hmon_test --config-file=/tmp/configAdlsProfilerTemp.yaml
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -983,7 +984,7 @@ jobs:
           rm -rf ${TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_adls_proxy.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_ADLS_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1193,7 +1194,7 @@ jobs:
           rm -rf ${TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_block.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1241,7 +1242,7 @@ jobs:
           cat /tmp/configBlockProfilerTemp.yaml
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_block_profiler.cov mount ${MOUNT_DIR} --config-file=/tmp/configBlockProfilerTemp.yaml --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1295,7 +1296,7 @@ jobs:
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_block_block_cache.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &
           CFL_PID=$!
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1  # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1349,7 +1350,7 @@ jobs:
           rm -rf ${TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_adls.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_ADLS_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1398,7 +1399,7 @@ jobs:
           cat ${cloudfuse_ADLS_CFG_HMON}
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_adls_profiler.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_ADLS_CFG_HMON} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1  # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1458,7 +1459,7 @@ jobs:
           rm -rf ${TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_s3.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1505,7 +1506,7 @@ jobs:
           cat /tmp/configBlockProfilerTemp.yaml
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_s3_profiler.cov mount ${MOUNT_DIR} --config-file=/tmp/configBlockProfilerTemp.yaml --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1558,7 +1559,7 @@ jobs:
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_s3_block_cache.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &
           CFL_PID=$!
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1  # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1618,7 +1619,7 @@ jobs:
           rm -rf ${TEMP_DIR}/*
           ./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_s3.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1859,7 +1860,7 @@ jobs:
           cat ${cloudfuse_ADLS_CFG_HMON}
           ./cloudfuse.test mount ${MOUNT_DIR} --config-file=${cloudfuse_ADLS_CFG_HMON} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do
@@ -1899,7 +1900,7 @@ jobs:
           cat ${cloudfuse_ADLS_CFG_HMON}
           ./cloudfuse.test mount ${MOUNT_DIR} --config-file=${cloudfuse_ADLS_CFG_HMON} --foreground=true &
 
-          READY_TIMEOUT=20  # Seconds to wait for mount to be ready
+          READY_TIMEOUT=${MOUNT_READY_TIMEOUT}  # Seconds to wait for mount to be ready
           POLL_INTERVAL=1   # Seconds between checks
           SECONDS_WAITED=0
           while [ $SECONDS_WAITED -lt $READY_TIMEOUT ]; do

From ffaebf8e1ba0c7e94c6e618038a147d2a057f1cf Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Fri, 8 May 2026 18:49:10 -0600
Subject: [PATCH 11/12] Soften bucket cleanup failures, since they're so
 common. TODO: Root cause IsDirEmpty failures and CI races.

---
 .github/workflows/code-coverage.yml | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/code-coverage.yml b/.github/workflows/code-coverage.yml
index 4cb05d60a..a03ac72bd 100644
--- a/.github/workflows/code-coverage.yml
+++ b/.github/workflows/code-coverage.yml
@@ -222,7 +222,7 @@ jobs:
             SECONDS_WAITED=$((SECONDS_WAITED + POLL_INTERVAL))
           done
           ps -aux | grep cloudfuse
-          rm -rf ${MOUNT_DIR}/*
+          rm -rf ${MOUNT_DIR}/* || true
           cd test/e2e_tests
           go test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -tmp-path=${TEMP_DIR}
           cd -
@@ -269,7 +269,7 @@ jobs:
             SECONDS_WAITED=$((SECONDS_WAITED + POLL_INTERVAL))
           done
           ps -aux | grep cloudfuse
-          rm -rf ${MOUNT_DIR}/*
+          rm -rf ${MOUNT_DIR}/* || true
           cd test/e2e_tests
           go test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -tmp-path=${TEMP_DIR}
           cd -
@@ -322,7 +322,7 @@ jobs:
           done
 
           ps -aux | grep cloudfuse
-          rm -rf ${MOUNT_DIR}/*
+          rm -rf ${MOUNT_DIR}/* || true
           cd test/e2e_tests
           go test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -tmp-path=${BLOCK_TEMP_DIR}
           cd -
@@ -375,7 +375,7 @@ jobs:
             SECONDS_WAITED=$((SECONDS_WAITED + POLL_INTERVAL))
           done
           ps -aux | grep cloudfuse
-          rm -rf ${MOUNT_DIR}/*
+          rm -rf ${MOUNT_DIR}/* || true
           cd test/e2e_tests
           go test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -adls=true -tmp-path=${TEMP_DIR}
           cd -
@@ -422,7 +422,7 @@ jobs:
             SECONDS_WAITED=$((SECONDS_WAITED + POLL_INTERVAL))
           done
           ps -aux | grep cloudfuse
-          rm -rf ${MOUNT_DIR}/*
+          rm -rf ${MOUNT_DIR}/* || true
           cd test/e2e_tests
           go test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -tmp-path=${TEMP_DIR}
           cd -
@@ -667,7 +667,7 @@ jobs:
           TEMP_DIR: ${{ env.TEMP_DIR }}
           WORK_DIR: ${{ env.WORK_DIR }}
           cloudfuse_STREAM_CFG: ${{ env.cloudfuse_STREAM_CFG }}
-        run: "rm -rf ${MOUNT_DIR}/*\nrm -rf ${TEMP_DIR}/*\n./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_stream.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_STREAM_CFG} --foreground=true &\nsleep 10\nps -aux | grep cloudfuse\nrm -rf ${MOUNT_DIR}/*\ncd test/e2e_tests\ngo test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -tmp-path=${TEMP_DIR}\ncd -\nsudo fusermount -u ${MOUNT_DIR} \nsleep 5"
+        run: "rm -rf ${MOUNT_DIR}/*\nrm -rf ${TEMP_DIR}/*\n./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_stream.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_STREAM_CFG} --foreground=true &\nsleep 10\nps -aux | grep cloudfuse\nrm -rf ${MOUNT_DIR}/* || true\ncd test/e2e_tests\ngo test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -tmp-path=${TEMP_DIR}\ncd -\nsudo fusermount -u ${MOUNT_DIR} \nsleep 5"
 
       - name: Create Config File - Block Blob
         env:
@@ -856,7 +856,7 @@ jobs:
           WORK_DIR: ${{ env.WORK_DIR }}
           cloudfuse_CFG: ${{ env.cloudfuse_CFG }}
           CONTAINER_NAME: ${{ matrix.containerName }}
-        run: "set +x\nrm -rf ${MOUNT_DIR}/*\nrm -rf ${TEMP_DIR}/*\n./cloudfuse.test unmount all\n./cloudfuse.test gen-test-config --config-file=azure_key.yaml --container-name=${CONTAINER_NAME} --temp-path=${TEMP_DIR} --output-file=${cloudfuse_CFG}\n\n./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/secure_encrypt.cov secure encrypt --config-file=${cloudfuse_CFG} --output-file=${WORK_DIR}/cloudfuse.azsec --passphrase=12312312312312312312312312312312 \nif [ $? -ne 0 ]; then\n  exit 1\nfi\n./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/mount_secure.cov mount ${MOUNT_DIR} --config-file=${WORK_DIR}/cloudfuse.azsec --passphrase=12312312312312312312312312312312 &\nsleep 10\nps -aux | grep cloudfuse\nrm -rf ${MOUNT_DIR}/*\ncd test/e2e_tests\ngo test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -adls=false -tmp-path=${TEMP_DIR}\ncd -\n\n./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/secure_set.cov secure set --config-file=${WORK_DIR}/cloudfuse.azsec --passphrase=12312312312312312312312312312312 --key=logging.level --value=log_debug\n./cloudfuse.test unmount all\nsleep 5"
+        run: "set +x\nrm -rf ${MOUNT_DIR}/*\nrm -rf ${TEMP_DIR}/*\n./cloudfuse.test unmount all\n./cloudfuse.test gen-test-config --config-file=azure_key.yaml --container-name=${CONTAINER_NAME} --temp-path=${TEMP_DIR} --output-file=${cloudfuse_CFG}\n\n./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/secure_encrypt.cov secure encrypt --config-file=${cloudfuse_CFG} --output-file=${WORK_DIR}/cloudfuse.azsec --passphrase=12312312312312312312312312312312 \nif [ $? -ne 0 ]; then\n  exit 1\nfi\n./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/mount_secure.cov mount ${MOUNT_DIR} --config-file=${WORK_DIR}/cloudfuse.azsec --passphrase=12312312312312312312312312312312 &\nsleep 10\nps -aux | grep cloudfuse\nrm -rf ${MOUNT_DIR}/* || true\ncd test/e2e_tests\ngo test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -adls=false -tmp-path=${TEMP_DIR}\ncd -\n\n./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/secure_set.cov secure set --config-file=${WORK_DIR}/cloudfuse.azsec --passphrase=12312312312312312312312312312312 --key=logging.level --value=log_debug\n./cloudfuse.test unmount all\nsleep 5"
 
       - name: "CLI : Health monitor stop pid"
         shell: bash {0}
@@ -958,7 +958,7 @@ jobs:
           TEMP_DIR: ${{ env.TEMP_DIR }}
           WORK_DIR: ${{ env.WORK_DIR }}
           cloudfuse_CFG: ${{ env.cloudfuse_CFG }}
-        run: "rm -rf ${MOUNT_DIR}/*\nrm -rf ${TEMP_DIR}/*\n./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_block_proxy.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &\nsleep 10\nps -aux | grep cloudfuse\nrm -rf ${MOUNT_DIR}/*\ncd test/e2e_tests\ngo test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -tmp-path=${TEMP_DIR}\ncd -\nsudo fusermount -u ${MOUNT_DIR} \nsleep 5"
+        run: "rm -rf ${MOUNT_DIR}/*\nrm -rf ${TEMP_DIR}/*\n./cloudfuse.test -test.v -test.coverprofile=${WORK_DIR}/cloudfuse_block_proxy.cov mount ${MOUNT_DIR} --config-file=${cloudfuse_CFG} --foreground=true &\nsleep 10\nps -aux | grep cloudfuse\nrm -rf ${MOUNT_DIR}/* || true\ncd test/e2e_tests\ngo test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -tmp-path=${TEMP_DIR}\ncd -\nsudo fusermount -u ${MOUNT_DIR} \nsleep 5"
 
       - name: Create Config File - ADLS Proxy
         env:
@@ -995,7 +995,7 @@ jobs:
             SECONDS_WAITED=$((SECONDS_WAITED + POLL_INTERVAL))
           done
           ps -aux | grep cloudfuse
-          rm -rf ${MOUNT_DIR}/*
+          rm -rf ${MOUNT_DIR}/* || true
           cd test/e2e_tests
           go test -v -timeout=7200s ./... -args -mnt-path=${MOUNT_DIR} -adls=true -tmp-path=${TEMP_DIR}
           cd -

From 4ae7257bf2f00215ff7daf1c004f72c742fc5b21 Mon Sep 17 00:00:00 2001
From: Michael Habinsky <michael.habinsky@seagate.com>
Date: Fri, 8 May 2026 18:23:13 -0600
Subject: [PATCH 12/12] Fix scheduler CI race

---
 component/file_cache/file_cache_test.go | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/component/file_cache/file_cache_test.go b/component/file_cache/file_cache_test.go
index da252e77a..a0ac61708 100644
--- a/component/file_cache/file_cache_test.go
+++ b/component/file_cache/file_cache_test.go
@@ -1593,6 +1593,16 @@ loopbackfs:
 		_, err = os.Stat(filepath.Join(suite.fake_storage_path, file))
 	}
 	suite.assert.FileExists(filepath.Join(suite.fake_storage_path, file))
+
+	// Cloud file visibility can race slightly with scheduleOps cleanup on slower CI workers.
+	for i := 0; i < 300; i++ {
+		_, exists = suite.fileCache.scheduleOps.Load(file)
+		flock := suite.fileCache.fileLocks.Get(file)
+		if !exists && flock != nil && !flock.SyncPending {
+			break
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
 	_, exists = suite.fileCache.scheduleOps.Load(file)
 	suite.assert.False(exists, "File should have been removed from scheduleOps after upload")
 	suite.assert.False(
@@ -1706,6 +1716,17 @@ loopbackfs:
 	suite.assert.NoError(err)
 	suite.assert.FileExists(filepath.Join(suite.fake_storage_path, file),
 		"File should be uploaded immediately with no schedule (always-on mode)")
+
+	// Poll until scheduleOps is cleared (accounts for slower CI workers)
+	for i := 0; i < 300; i++ {
+		_, exists := suite.fileCache.scheduleOps.Load(file)
+		flock := suite.fileCache.fileLocks.Get(file)
+		if !exists && (flock == nil || !flock.SyncPending) {
+			break
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
+
 	_, exists := suite.fileCache.scheduleOps.Load(file)
 	suite.assert.False(exists, "File should not be in scheduleOps map")