Skip to content

Commit 49a0bf5

Browse files
peteralfonsiPeter Alfonsijainankitk
authored and
akolarkunnu
committed
[Bugfix] Fix cache maximum size settings not working properly with pluggable caching (opensearch-project#16636)
* Fix cache size setting Signed-off-by: Peter Alfonsi <petealft@amazon.com> * Changelog Signed-off-by: Peter Alfonsi <petealft@amazon.com> * Deprecate original IRC size setting Signed-off-by: Peter Alfonsi <petealft@amazon.com> * spotlessApply Signed-off-by: Peter Alfonsi <petealft@amazon.com> * Addressed Ankit's comments Signed-off-by: Peter Alfonsi <petealft@amazon.com> * Address Sagar's comment Signed-off-by: Peter Alfonsi <petealft@amazon.com> --------- Signed-off-by: Peter Alfonsi <petealft@amazon.com> Signed-off-by: Peter Alfonsi <peter.alfonsi@gmail.com> Signed-off-by: Ankit Jain <akjain@amazon.com> Co-authored-by: Peter Alfonsi <petealft@amazon.com> Co-authored-by: Ankit Jain <akjain@amazon.com>
1 parent 63accb7 commit 49a0bf5

File tree

15 files changed

+403
-62
lines changed

15 files changed

+403
-62
lines changed

‎CHANGELOG.md

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -95,6 +95,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
9595
- Fix case insensitive and escaped query on wildcard ([#16827](https://github.com/opensearch-project/OpenSearch/pull/16827))
9696
- Fix _list/shards API failing when closed indices are present ([#16606](https://github.com/opensearch-project/OpenSearch/pull/16606))
9797
- Fix remote shards balance ([#15335](https://github.com/opensearch-project/OpenSearch/pull/15335))
98+
- Fix max request cache size settings not working properly with pluggable caching ([#16636](https://github.com/opensearch-project/OpenSearch/pull/16636))
9899
- Always use `constant_score` query for `match_only_text` field ([#16964](https://github.com/opensearch-project/OpenSearch/pull/16964))
99100
- Fix Shallow copy snapshot failures on closed index ([#16868](https://github.com/opensearch-project/OpenSearch/pull/16868))
100101
- Fix multi-value sort for unsigned long ([#16732](https://github.com/opensearch-project/OpenSearch/pull/16732))

‎modules/cache-common/src/main/java/org/opensearch/cache/common/tier/TieredSpilloverCache.java

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -150,6 +150,9 @@ static class TieredSpilloverCacheSegment<K, V> implements ICache<K, V> {
150150

151151
private final TieredSpilloverCacheStatsHolder statsHolder;
152152

153+
private final long onHeapCacheMaxWeight;
154+
private final long diskCacheMaxWeight;
155+
153156
/**
154157
* This map is used to handle concurrent requests for same key in computeIfAbsent() to ensure we load the value
155158
* only once.
@@ -218,6 +221,8 @@ static class TieredSpilloverCacheSegment<K, V> implements ICache<K, V> {
218221
cacheListMap.put(diskCache, new TierInfo(isDiskCacheEnabled, TIER_DIMENSION_VALUE_DISK));
219222
this.caches = Collections.synchronizedMap(cacheListMap);
220223
this.policies = builder.policies; // Will never be null; builder initializes it to an empty list
224+
this.onHeapCacheMaxWeight = onHeapCacheSizeInBytes;
225+
this.diskCacheMaxWeight = diskCacheSizeInBytes;
221226
}
222227

223228
// Package private for testing
@@ -526,6 +531,16 @@ void updateStatsOnPut(String destinationTierValue, ICacheKey<K> key, V value) {
526531
statsHolder.incrementSizeInBytes(dimensionValues, weigher.applyAsLong(key, value));
527532
}
528533

534+
// pkg-private for testing
535+
long getOnHeapCacheMaxWeight() {
536+
return onHeapCacheMaxWeight;
537+
}
538+
539+
// pkg-private for testing
540+
long getDiskCacheMaxWeight() {
541+
return diskCacheMaxWeight;
542+
}
543+
529544
/**
530545
* A class which receives removal events from the heap tier.
531546
*/

‎modules/cache-common/src/main/java/org/opensearch/cache/common/tier/TieredSpilloverCacheSettings.java

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -85,6 +85,9 @@ public class TieredSpilloverCacheSettings {
8585

8686
/**
8787
* Setting which defines the onHeap cache size to be used within tiered cache.
88+
* This setting overrides size settings from the heap tier implementation.
89+
* For example, if OpenSearchOnHeapCache is the heap tier in the request cache, and
90+
* indices.requests.cache.opensearch_onheap.size is set, that value will be ignored in favor of this setting.
8891
*
8992
* Pattern: {cache_type}.tiered_spillover.onheap.store.size
9093
* Example: indices.request.cache.tiered_spillover.onheap.store.size
@@ -96,6 +99,9 @@ public class TieredSpilloverCacheSettings {
9699

97100
/**
98101
* Setting which defines the disk cache size to be used within tiered cache.
102+
* This setting overrides the size setting from the disk tier implementation.
103+
* For example, if EhcacheDiskCache is the disk tier in the request cache, and
104+
* indices.requests.cache.ehcache_disk.max_size_in_bytes is set, that value will be ignored in favor of this setting.
99105
*/
100106
public static final Setting.AffixSetting<Long> TIERED_SPILLOVER_DISK_STORE_SIZE = Setting.suffixKeySetting(
101107
TieredSpilloverCache.TieredSpilloverCacheFactory.TIERED_SPILLOVER_CACHE_NAME + ".disk.store.size",

‎modules/cache-common/src/test/java/org/opensearch/cache/common/tier/MockDiskCache.java

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -128,6 +128,10 @@ public void close() {
128128

129129
}
130130

131+
long getMaximumWeight() {
132+
return maxSize;
133+
}
134+
131135
public static class MockDiskCacheFactory implements Factory {
132136

133137
public static final String NAME = "mockDiskCache";

‎modules/cache-common/src/test/java/org/opensearch/cache/common/tier/TieredSpilloverCacheTests.java

Lines changed: 132 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -58,6 +58,7 @@
5858

5959
import static org.opensearch.cache.common.tier.TieredSpilloverCache.ZERO_SEGMENT_COUNT_EXCEPTION_MESSAGE;
6060
import static org.opensearch.cache.common.tier.TieredSpilloverCacheSettings.DISK_CACHE_ENABLED_SETTING_MAP;
61+
import static org.opensearch.cache.common.tier.TieredSpilloverCacheSettings.MIN_DISK_CACHE_SIZE_IN_BYTES;
6162
import static org.opensearch.cache.common.tier.TieredSpilloverCacheSettings.TIERED_SPILLOVER_ONHEAP_STORE_SIZE;
6263
import static org.opensearch.cache.common.tier.TieredSpilloverCacheSettings.TIERED_SPILLOVER_SEGMENTS;
6364
import static org.opensearch.cache.common.tier.TieredSpilloverCacheSettings.TOOK_TIME_POLICY_CONCRETE_SETTINGS_MAP;
@@ -2166,6 +2167,134 @@ public void testDropStatsForDimensions() throws Exception {
21662167
assertEquals(new ImmutableCacheStats(0, 0, 0, 0, 0), tieredSpilloverCache.stats().getTotalStats());
21672168
}
21682169

2170+
public void testSegmentSizesWhenUsingFactory() {
2171+
// The TSC's tier size settings, TIERED_SPILLOVER_ONHEAP_STORE_SIZE and TIERED_SPILLOVER_DISK_STORE_SIZE,
2172+
// should always be respected, overriding the individual implementation's size settings if present
2173+
long expectedHeapSize = 256L * between(10, 20);
2174+
long expectedDiskSize = MIN_DISK_CACHE_SIZE_IN_BYTES + 256L * between(30, 40);
2175+
long heapSizeFromImplSetting = 50;
2176+
int diskSizeFromImplSetting = 50;
2177+
int numSegments = getNumberOfSegments();
2178+
2179+
int keyValueSize = 1;
2180+
MockCacheRemovalListener<String, String> removalListener = new MockCacheRemovalListener<>();
2181+
Settings settings = Settings.builder()
2182+
.put(
2183+
CacheSettings.getConcreteStoreNameSettingForCacheType(CacheType.INDICES_REQUEST_CACHE).getKey(),
2184+
TieredSpilloverCache.TieredSpilloverCacheFactory.TIERED_SPILLOVER_CACHE_NAME
2185+
)
2186+
.put(
2187+
TieredSpilloverCacheSettings.TIERED_SPILLOVER_ONHEAP_STORE_NAME.getConcreteSettingForNamespace(
2188+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2189+
).getKey(),
2190+
OpenSearchOnHeapCache.OpenSearchOnHeapCacheFactory.NAME
2191+
)
2192+
.put(
2193+
TieredSpilloverCacheSettings.TIERED_SPILLOVER_DISK_STORE_NAME.getConcreteSettingForNamespace(
2194+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2195+
).getKey(),
2196+
MockDiskCache.MockDiskCacheFactory.NAME
2197+
)
2198+
// These two size settings should be honored
2199+
.put(
2200+
TieredSpilloverCacheSettings.TIERED_SPILLOVER_ONHEAP_STORE_SIZE.getConcreteSettingForNamespace(
2201+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2202+
).getKey(),
2203+
expectedHeapSize + "b"
2204+
)
2205+
.put(
2206+
TieredSpilloverCacheSettings.TIERED_SPILLOVER_DISK_STORE_SIZE.getConcreteSettingForNamespace(
2207+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2208+
).getKey(),
2209+
expectedDiskSize
2210+
)
2211+
// The size setting from the OpenSearchOnHeap implementation should not be honored
2212+
.put(
2213+
OpenSearchOnHeapCacheSettings.MAXIMUM_SIZE_IN_BYTES.getConcreteSettingForNamespace(
2214+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2215+
).getKey(),
2216+
heapSizeFromImplSetting + "b"
2217+
)
2218+
.put(FeatureFlags.PLUGGABLE_CACHE, "true")
2219+
.put(
2220+
TIERED_SPILLOVER_SEGMENTS.getConcreteSettingForNamespace(CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()).getKey(),
2221+
numSegments
2222+
)
2223+
.build();
2224+
String storagePath = getStoragePath(settings);
2225+
2226+
TieredSpilloverCache<String, String> tieredSpilloverCache = (TieredSpilloverCache<
2227+
String,
2228+
String>) new TieredSpilloverCache.TieredSpilloverCacheFactory().create(
2229+
new CacheConfig.Builder<String, String>().setKeyType(String.class)
2230+
.setKeyType(String.class)
2231+
.setWeigher((k, v) -> keyValueSize)
2232+
.setRemovalListener(removalListener)
2233+
.setKeySerializer(new StringSerializer())
2234+
.setValueSerializer(new StringSerializer())
2235+
.setSettings(settings)
2236+
.setDimensionNames(dimensionNames)
2237+
.setCachedResultParser(s -> new CachedQueryResult.PolicyValues(20_000_000L)) // Values will always appear to have taken
2238+
// 20_000_000 ns = 20 ms to compute
2239+
.setClusterSettings(clusterSettings)
2240+
.setStoragePath(storagePath)
2241+
.build(),
2242+
CacheType.INDICES_REQUEST_CACHE,
2243+
Map.of(
2244+
OpenSearchOnHeapCache.OpenSearchOnHeapCacheFactory.NAME,
2245+
new OpenSearchOnHeapCache.OpenSearchOnHeapCacheFactory(),
2246+
MockDiskCache.MockDiskCacheFactory.NAME,
2247+
// The size value passed in here acts as the "implementation setting" for the disk tier, and should also be ignored
2248+
new MockDiskCache.MockDiskCacheFactory(0, diskSizeFromImplSetting, false, keyValueSize)
2249+
)
2250+
);
2251+
checkSegmentSizes(tieredSpilloverCache, expectedHeapSize, expectedDiskSize);
2252+
}
2253+
2254+
public void testSegmentSizesWhenNotUsingFactory() {
2255+
long expectedHeapSize = 256L * between(10, 20);
2256+
long expectedDiskSize = MIN_DISK_CACHE_SIZE_IN_BYTES + 256L * between(30, 40);
2257+
int heapSizeFromImplSetting = 50;
2258+
int diskSizeFromImplSetting = 50;
2259+
2260+
Settings settings = Settings.builder()
2261+
.put(
2262+
CacheSettings.getConcreteStoreNameSettingForCacheType(CacheType.INDICES_REQUEST_CACHE).getKey(),
2263+
TieredSpilloverCache.TieredSpilloverCacheFactory.TIERED_SPILLOVER_CACHE_NAME
2264+
)
2265+
.put(FeatureFlags.PLUGGABLE_CACHE, "true")
2266+
// The size setting from the OpenSearchOnHeapCache implementation should not be honored
2267+
.put(
2268+
OpenSearchOnHeapCacheSettings.MAXIMUM_SIZE_IN_BYTES.getConcreteSettingForNamespace(
2269+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2270+
).getKey(),
2271+
heapSizeFromImplSetting + "b"
2272+
)
2273+
.build();
2274+
2275+
int keyValueSize = 1;
2276+
MockCacheRemovalListener<String, String> removalListener = new MockCacheRemovalListener<>();
2277+
int numSegments = getNumberOfSegments();
2278+
CacheConfig<String, String> cacheConfig = getCacheConfig(1, settings, removalListener, numSegments);
2279+
TieredSpilloverCache<String, String> tieredSpilloverCache = getTieredSpilloverCache(
2280+
new OpenSearchOnHeapCache.OpenSearchOnHeapCacheFactory(),
2281+
new MockDiskCache.MockDiskCacheFactory(0, diskSizeFromImplSetting, true, keyValueSize),
2282+
cacheConfig,
2283+
null,
2284+
removalListener,
2285+
numSegments,
2286+
expectedHeapSize,
2287+
expectedDiskSize
2288+
);
2289+
checkSegmentSizes(tieredSpilloverCache, expectedHeapSize, expectedDiskSize);
2290+
}
2291+
2292+
private void checkSegmentSizes(TieredSpilloverCache<String, String> cache, long expectedHeapSize, long expectedDiskSize) {
2293+
TieredSpilloverCache.TieredSpilloverCacheSegment<String, String> segment = cache.tieredSpilloverCacheSegments[0];
2294+
assertEquals(expectedHeapSize / cache.getNumberOfSegments(), segment.getOnHeapCacheMaxWeight());
2295+
assertEquals(expectedDiskSize / cache.getNumberOfSegments(), segment.getDiskCacheMaxWeight());
2296+
}
2297+
21692298
private List<String> getMockDimensions() {
21702299
List<String> dims = new ArrayList<>();
21712300
for (String dimensionName : dimensionNames) {
@@ -2455,9 +2584,9 @@ private void verifyComputeIfAbsentThrowsException(
24552584
MockCacheRemovalListener<String, String> removalListener = new MockCacheRemovalListener<>();
24562585
Settings settings = Settings.builder()
24572586
.put(
2458-
OpenSearchOnHeapCacheSettings.getSettingListForCacheType(CacheType.INDICES_REQUEST_CACHE)
2459-
.get(MAXIMUM_SIZE_IN_BYTES_KEY)
2460-
.getKey(),
2587+
TieredSpilloverCacheSettings.TIERED_SPILLOVER_ONHEAP_STORE_SIZE.getConcreteSettingForNamespace(
2588+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2589+
).getKey(),
24612590
onHeapCacheSize * keyValueSize + "b"
24622591
)
24632592
.build();

‎plugins/cache-ehcache/src/main/java/org/opensearch/cache/EhcacheDiskCacheSettings.java

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -101,6 +101,7 @@ public class EhcacheDiskCacheSettings {
101101

102102
/**
103103
* Disk cache max size setting.
104+
* If this cache is used as a tier in a TieredSpilloverCache, this setting is ignored.
104105
*/
105106
public static final Setting.AffixSetting<Long> DISK_CACHE_MAX_SIZE_IN_BYTES_SETTING = Setting.suffixKeySetting(
106107
EhcacheDiskCache.EhcacheDiskCacheFactory.EHCACHE_DISK_CACHE_NAME + ".max_size_in_bytes",

‎plugins/cache-ehcache/src/main/java/org/opensearch/cache/store/disk/EhcacheDiskCache.java

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -680,6 +680,11 @@ private V deserializeValue(ByteArrayWrapper binary) {
680680
return valueSerializer.deserialize(binary.value);
681681
}
682682

683+
// Pkg-private for testing.
684+
long getMaximumWeight() {
685+
return maxWeightInBytes;
686+
}
687+
683688
/**
684689
* Factory to create an ehcache disk cache.
685690
*/

‎plugins/cache-ehcache/src/test/java/org/opensearch/cache/store/disk/EhCacheDiskCacheTests.java

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,11 +20,13 @@
2020
import org.opensearch.common.cache.RemovalNotification;
2121
import org.opensearch.common.cache.serializer.BytesReferenceSerializer;
2222
import org.opensearch.common.cache.serializer.Serializer;
23+
import org.opensearch.common.cache.settings.CacheSettings;
2324
import org.opensearch.common.cache.stats.ImmutableCacheStats;
2425
import org.opensearch.common.cache.store.config.CacheConfig;
2526
import org.opensearch.common.metrics.CounterMetric;
2627
import org.opensearch.common.settings.Settings;
2728
import org.opensearch.common.unit.TimeValue;
29+
import org.opensearch.common.util.FeatureFlags;
2830
import org.opensearch.common.util.io.IOUtils;
2931
import org.opensearch.core.common.bytes.BytesArray;
3032
import org.opensearch.core.common.bytes.BytesReference;
@@ -1201,6 +1203,65 @@ public void testEhcacheCloseWithDestroyCacheMethodThrowingException() throws Exc
12011203
ehcacheDiskCache.close();
12021204
}
12031205

1206+
public void testWithCacheConfigSizeSettings() throws Exception {
1207+
// The cache should get its size from the config if present, and otherwise should get it from the setting.
1208+
long maxSizeFromSetting = between(MINIMUM_MAX_SIZE_IN_BYTES + 1000, MINIMUM_MAX_SIZE_IN_BYTES + 2000);
1209+
long maxSizeFromConfig = between(MINIMUM_MAX_SIZE_IN_BYTES + 3000, MINIMUM_MAX_SIZE_IN_BYTES + 4000);
1210+
1211+
EhcacheDiskCache<String, String> cache = setupMaxSizeTest(maxSizeFromSetting, maxSizeFromConfig, false);
1212+
assertEquals(maxSizeFromSetting, cache.getMaximumWeight());
1213+
1214+
cache = setupMaxSizeTest(maxSizeFromSetting, maxSizeFromConfig, true);
1215+
assertEquals(maxSizeFromConfig, cache.getMaximumWeight());
1216+
}
1217+
1218+
// Modified from OpenSearchOnHeapCacheTests. Can't reuse, as we can't add a dependency on the server.test module.
1219+
private EhcacheDiskCache<String, String> setupMaxSizeTest(long maxSizeFromSetting, long maxSizeFromConfig, boolean putSizeInConfig)
1220+
throws Exception {
1221+
MockRemovalListener<String, String> listener = new MockRemovalListener<>();
1222+
try (NodeEnvironment env = newNodeEnvironment(Settings.builder().build())) {
1223+
Settings settings = Settings.builder()
1224+
.put(FeatureFlags.PLUGGABLE_CACHE, true)
1225+
.put(
1226+
CacheSettings.getConcreteStoreNameSettingForCacheType(CacheType.INDICES_REQUEST_CACHE).getKey(),
1227+
EhcacheDiskCache.EhcacheDiskCacheFactory.EHCACHE_DISK_CACHE_NAME
1228+
)
1229+
.put(
1230+
EhcacheDiskCacheSettings.getSettingListForCacheType(CacheType.INDICES_REQUEST_CACHE)
1231+
.get(DISK_MAX_SIZE_IN_BYTES_KEY)
1232+
.getKey(),
1233+
maxSizeFromSetting
1234+
)
1235+
.put(
1236+
EhcacheDiskCacheSettings.getSettingListForCacheType(CacheType.INDICES_REQUEST_CACHE)
1237+
.get(DISK_STORAGE_PATH_KEY)
1238+
.getKey(),
1239+
env.nodePaths()[0].indicesPath.toString() + "/request_cache/" + 0
1240+
)
1241+
.build();
1242+
1243+
CacheConfig.Builder<String, String> cacheConfigBuilder = new CacheConfig.Builder<String, String>().setKeyType(String.class)
1244+
.setValueType(String.class)
1245+
.setKeySerializer(new StringSerializer())
1246+
.setValueSerializer(new StringSerializer())
1247+
.setWeigher(getWeigher())
1248+
.setRemovalListener(listener)
1249+
.setSettings(settings)
1250+
.setDimensionNames(List.of(dimensionName))
1251+
.setStatsTrackingEnabled(true);
1252+
if (putSizeInConfig) {
1253+
cacheConfigBuilder.setMaxSizeInBytes(maxSizeFromConfig);
1254+
}
1255+
1256+
ICache.Factory cacheFactory = new EhcacheDiskCache.EhcacheDiskCacheFactory();
1257+
return (EhcacheDiskCache<String, String>) cacheFactory.create(
1258+
cacheConfigBuilder.build(),
1259+
CacheType.INDICES_REQUEST_CACHE,
1260+
null
1261+
);
1262+
}
1263+
}
1264+
12041265
static class MockEhcahceDiskCache extends EhcacheDiskCache<String, String> {
12051266

12061267
public MockEhcahceDiskCache(Builder<String, String> builder) {

‎server/src/main/java/org/opensearch/common/cache/service/CacheService.java

Lines changed: 17 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -46,11 +46,8 @@ public CacheService(Map<String, ICache.Factory> cacheStoreTypeFactories, Setting
4646
}
4747

4848
public <K, V> ICache<K, V> createCache(CacheConfig<K, V> config, CacheType cacheType) {
49-
Setting<String> cacheSettingForCacheType = CacheSettings.CACHE_TYPE_STORE_NAME.getConcreteSettingForNamespace(
50-
cacheType.getSettingPrefix()
51-
);
52-
String storeName = cacheSettingForCacheType.get(settings);
53-
if (!FeatureFlags.PLUGGABLE_CACHE_SETTING.get(settings) || (storeName == null || storeName.isBlank())) {
49+
String storeName = getStoreNameFromSetting(cacheType, settings);
50+
if (!pluggableCachingEnabled(cacheType, settings)) {
5451
// Condition 1: In case feature flag is off, we default to onHeap.
5552
// Condition 2: In case storeName is not explicitly mentioned, we assume user is looking to use older
5653
// settings, so we again fallback to onHeap to maintain backward compatibility.
@@ -74,4 +71,19 @@ public NodeCacheStats stats(CommonStatsFlags flags) {
7471
}
7572
return new NodeCacheStats(statsMap, flags);
7673
}
74+
75+
/**
76+
* Check if pluggable caching is on, and if a store type is present for this cache type.
77+
*/
78+
public static boolean pluggableCachingEnabled(CacheType cacheType, Settings settings) {
79+
String storeName = getStoreNameFromSetting(cacheType, settings);
80+
return FeatureFlags.PLUGGABLE_CACHE_SETTING.get(settings) && storeName != null && !storeName.isBlank();
81+
}
82+
83+
private static String getStoreNameFromSetting(CacheType cacheType, Settings settings) {
84+
Setting<String> cacheSettingForCacheType = CacheSettings.CACHE_TYPE_STORE_NAME.getConcreteSettingForNamespace(
85+
cacheType.getSettingPrefix()
86+
);
87+
return cacheSettingForCacheType.get(settings);
88+
}
7789
}

0 commit comments

Comments
 (0)