LDEV-1109 pin RAM resource directories with HardRef to survive GC

https://luceeserver.atlassian.net/browse/LDEV-1109

Author: zspitzer

core/src/main/java/lucee/commons/io/res/type/cache/CacheResourceProvider.java

@@ -19,11 +19,9 @@
 package lucee.commons.io.res.type.cache;
 
 import java.io.IOException;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 import lucee.commons.io.cache.Cache;
 import lucee.commons.io.cache.CacheEntry;
@@ -57,8 +55,6 @@ public final class CacheResourceProvider implements ResourceProviderPro {
 
 	private Cache defaultCache;
 
-	private Set<Integer> inits = new HashSet<Integer>();
-
 	// private Config config;
 
 	/**
@@ -152,7 +148,14 @@ String[] getChildNames(String path) throws IOException {
 	 */
 	CacheResourceCore createCore(String path, String name, int type) throws IOException {
 		CacheResourceCore value = new CacheResourceCore(type, path, name);
-		getCache().put(toKey(path, name), value, null, null);
+		Cache cache = getCache();
+		String key = toKey(path, name);
+		if (type == CacheResourceCore.TYPE_DIRECTORY && cache instanceof RamCache) {
+			((RamCache) cache).putPinned(key, value, null, null);
+		}
+		else {
+			cache.put(key, value, null, null);
+		}
 		return value;
 	}
 
@@ -215,18 +218,21 @@ public Cache getCache() {
 			}
 			c = defaultCache;
 		}
-		if (!inits.contains(c.hashCode())) {
-			String k = toKey("null", "");
-			try {
-				if (!c.contains(k)) {
-					CacheResourceCore value = new CacheResourceCore(CacheResourceCore.TYPE_DIRECTORY, null, "");
+		// LDEV-1109: always verify root exists - it may have been lost to GC via soft references
+		String k = toKey("null", "");
+		try {
+			if (!c.contains(k)) {
+				CacheResourceCore value = new CacheResourceCore(CacheResourceCore.TYPE_DIRECTORY, null, "");
+				if (c instanceof RamCache) {
+					((RamCache) c).putPinned(k, value, Constants.LONG_ZERO, Constants.LONG_ZERO);
+				}
+				else {
 					c.put(k, value, Constants.LONG_ZERO, Constants.LONG_ZERO);
 				}
 			}
-			catch (IOException e) {
-				// simply ignore
-			}
-			inits.add(c.hashCode());
+		}
+		catch (IOException e) {
+			// simply ignore
 		}
 		return c;
 	}

core/src/main/java/lucee/runtime/cache/ram/RamCache.java

@@ -197,12 +197,23 @@ public List<String> keys() {
 
 	@Override
 	public void put(String key, Object value, Long idleTime, Long until) {
+		put(key, value, idleTime, until, false);
+	}
+
+	/**
+	 * Store an entry that is pinned with a hard reference, preventing it from being garbage collected.
+	 * Use this for structural entries (like directory metadata) that must survive memory pressure.
+	 */
+	public void putPinned(String key, Object value, Long idleTime, Long until) {
+		put(key, value, idleTime, until, true);
+	}
 
+	private void put(String key, Object value, Long idleTime, Long until, boolean pinned) {
 		Ref<RamCacheEntry> tmp = entries.get(key);
 		RamCacheEntry entry = tmp == null ? null : tmp.get();
 		if (entry == null) {
 			RamCacheEntry e = new RamCacheEntry(key, decouple(value), idleTime == null ? this.idleTime : idleTime.longValue(), until == null ? this.until : until.longValue());
-			entries.put(key, outOfMemory ? new HardRef<RamCacheEntry>(e) : new SoftRef<RamCacheEntry>(e));
+			entries.put(key, (pinned || outOfMemory) ? new HardRef<RamCacheEntry>(e) : new SoftRef<RamCacheEntry>(e));
 		}
 		else entry.update(value);
 	}

test/tickets/LDEV1109.cfc

@@ -0,0 +1,83 @@
+component extends="org.lucee.cfml.test.LuceeTestCase" labels="ram" {
+
+	function afterAll() {
+		if ( directoryExists( "ram://LDEV1109" ) ) {
+			directoryDelete( "ram://LDEV1109", true );
+		}
+	}
+
+	function run( testResults, testBox ) {
+		describe( "LDEV-1109 RAM drive should survive cache eviction", function() {
+
+			it( title="ram:// root should exist after cache is cleared", body=function() {
+				// verify root exists before clear
+				expect( directoryExists( "ram://" ) ).toBeTrue();
+
+				// clear the cache, simulating GC reclaiming all references
+				var ramCache = _getRamCache();
+				ramCache.clear();
+
+				// root should be auto-recreated on next access
+				expect( directoryExists( "ram://" ) ).toBeTrue();
+			});
+
+			it( title="ram:// directories should be stored with HardRef not SoftRef", body=function() {
+				var dir = "ram://LDEV1109";
+				// cleanup from previous run
+				if ( directoryExists( dir ) ) directoryDelete( dir, true );
+
+				// create directory structure with a file
+				directoryCreate( dir );
+				directoryCreate( dir & "/subdir" );
+				fileWrite( dir & "/subdir/file.txt", "data" );
+
+				// use reflection to access the private entries map in RamCache
+				var ramCache = _getRamCache();
+				var entriesField = ramCache.getClass().getDeclaredField( "entries" );
+				entriesField.setAccessible( true );
+				var entries = entriesField.get( ramCache );
+
+				var HardRef = createObject( "java", "lucee.runtime.cache.ram.ref.HardRef" );
+				var dirCount = 0;
+				var fileCount = 0;
+
+				var iter = entries.values().iterator();
+				while ( iter.hasNext() ) {
+					var ref = iter.next();
+					var rce = ref.get();
+					if ( isNull( rce ) ) continue;
+					var val = rce.getValue();
+					if ( !isInstanceOf( val, "lucee.commons.io.res.type.cache.CacheResourceCore" ) ) continue;
+
+					if ( val.getType() == 1 ) {
+						// TYPE_DIRECTORY = 1: must be pinned with HardRef
+						expect( ref ).toBeInstanceOf( "lucee.runtime.cache.ram.ref.HardRef",
+							"directory entry should use HardRef, not SoftRef" );
+						dirCount++;
+					}
+					else if ( val.getType() == 2 ) {
+						// TYPE_FILE = 2: should use SoftRef (reclaimable under memory pressure)
+						expect( ref ).toBeInstanceOf( "lucee.runtime.cache.ram.ref.SoftRef",
+							"file entry should use SoftRef, not HardRef" );
+						fileCount++;
+					}
+				}
+
+				// root + LDEV1109 + subdir = at least 3 directories
+				expect( dirCount ).toBeGTE( 3, "should have at least 3 directory entries" );
+				// at least 1 file
+				expect( fileCount ).toBeGTE( 1, "should have at least 1 file entry" );
+			});
+		});
+	}
+
+	private function _getRamCache() {
+		var providers = getPageContext().getConfig().getResourceProviders();
+		for ( var p in providers ) {
+			if ( p.getScheme() == "ram" ) {
+				return p.getCache();
+			}
+		}
+		throw( message="RAM resource provider not found" );
+	}
+}