Skip to content

Commit 64486b6

Browse files
peteralfonsiPeter Alfonsi
peteralfonsi
and
Peter Alfonsi
authored
[Backport 2.x] [Bugfix] Fix cache maximum size settings not working properly with pluggable caching (#17042)
* [Bugfix] Fix cache maximum size settings not working properly with pluggable caching (#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> (cherry picked from commit a436076) * rerun gradle Signed-off-by: Peter Alfonsi <petealft@amazon.com> --------- Signed-off-by: Peter Alfonsi <petealft@amazon.com> Co-authored-by: Peter Alfonsi <petealft@amazon.com>
1 parent 841690c commit 64486b6

File tree

15 files changed

+403
-62
lines changed

15 files changed

+403
-62
lines changed

‎CHANGELOG.md

+1
Original file line numberDiff line numberDiff line change
@@ -103,6 +103,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
103103
- Skip remote-repositories validations for node-joins when RepositoriesService is not in sync with cluster-state ([#16763](https://github.com/opensearch-project/OpenSearch/pull/16763))
104104
- Fix _list/shards API failing when closed indices are present ([#16606](https://github.com/opensearch-project/OpenSearch/pull/16606))
105105
- Fix remote shards balance ([#15335](https://github.com/opensearch-project/OpenSearch/pull/15335))
106+
- Fix max request cache size settings not working properly with pluggable caching ([#16636](https://github.com/opensearch-project/OpenSearch/pull/16636))
106107
- Always use `constant_score` query for `match_only_text` field ([#16964](https://github.com/opensearch-project/OpenSearch/pull/16964))
107108
- Fix Shallow copy snapshot failures on closed index ([#16868](https://github.com/opensearch-project/OpenSearch/pull/16868))
108109
- 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

+15
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

+6
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

+4
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

+132-3
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;
@@ -2112,6 +2113,134 @@ public void testTieredCacheDefaultSegmentCount() {
21122113
assertTrue(VALID_SEGMENT_COUNT_VALUES.contains(tieredSpilloverCache.getNumberOfSegments()));
21132114
}
21142115

2116+
public void testSegmentSizesWhenUsingFactory() {
2117+
// The TSC's tier size settings, TIERED_SPILLOVER_ONHEAP_STORE_SIZE and TIERED_SPILLOVER_DISK_STORE_SIZE,
2118+
// should always be respected, overriding the individual implementation's size settings if present
2119+
long expectedHeapSize = 256L * between(10, 20);
2120+
long expectedDiskSize = MIN_DISK_CACHE_SIZE_IN_BYTES + 256L * between(30, 40);
2121+
long heapSizeFromImplSetting = 50;
2122+
int diskSizeFromImplSetting = 50;
2123+
int numSegments = getNumberOfSegments();
2124+
2125+
int keyValueSize = 1;
2126+
MockCacheRemovalListener<String, String> removalListener = new MockCacheRemovalListener<>();
2127+
Settings settings = Settings.builder()
2128+
.put(
2129+
CacheSettings.getConcreteStoreNameSettingForCacheType(CacheType.INDICES_REQUEST_CACHE).getKey(),
2130+
TieredSpilloverCache.TieredSpilloverCacheFactory.TIERED_SPILLOVER_CACHE_NAME
2131+
)
2132+
.put(
2133+
TieredSpilloverCacheSettings.TIERED_SPILLOVER_ONHEAP_STORE_NAME.getConcreteSettingForNamespace(
2134+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2135+
).getKey(),
2136+
OpenSearchOnHeapCache.OpenSearchOnHeapCacheFactory.NAME
2137+
)
2138+
.put(
2139+
TieredSpilloverCacheSettings.TIERED_SPILLOVER_DISK_STORE_NAME.getConcreteSettingForNamespace(
2140+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2141+
).getKey(),
2142+
MockDiskCache.MockDiskCacheFactory.NAME
2143+
)
2144+
// These two size settings should be honored
2145+
.put(
2146+
TieredSpilloverCacheSettings.TIERED_SPILLOVER_ONHEAP_STORE_SIZE.getConcreteSettingForNamespace(
2147+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2148+
).getKey(),
2149+
expectedHeapSize + "b"
2150+
)
2151+
.put(
2152+
TieredSpilloverCacheSettings.TIERED_SPILLOVER_DISK_STORE_SIZE.getConcreteSettingForNamespace(
2153+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2154+
).getKey(),
2155+
expectedDiskSize
2156+
)
2157+
// The size setting from the OpenSearchOnHeap implementation should not be honored
2158+
.put(
2159+
OpenSearchOnHeapCacheSettings.MAXIMUM_SIZE_IN_BYTES.getConcreteSettingForNamespace(
2160+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2161+
).getKey(),
2162+
heapSizeFromImplSetting + "b"
2163+
)
2164+
.put(FeatureFlags.PLUGGABLE_CACHE, "true")
2165+
.put(
2166+
TIERED_SPILLOVER_SEGMENTS.getConcreteSettingForNamespace(CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()).getKey(),
2167+
numSegments
2168+
)
2169+
.build();
2170+
String storagePath = getStoragePath(settings);
2171+
2172+
TieredSpilloverCache<String, String> tieredSpilloverCache = (TieredSpilloverCache<
2173+
String,
2174+
String>) new TieredSpilloverCache.TieredSpilloverCacheFactory().create(
2175+
new CacheConfig.Builder<String, String>().setKeyType(String.class)
2176+
.setKeyType(String.class)
2177+
.setWeigher((k, v) -> keyValueSize)
2178+
.setRemovalListener(removalListener)
2179+
.setKeySerializer(new StringSerializer())
2180+
.setValueSerializer(new StringSerializer())
2181+
.setSettings(settings)
2182+
.setDimensionNames(dimensionNames)
2183+
.setCachedResultParser(s -> new CachedQueryResult.PolicyValues(20_000_000L)) // Values will always appear to have taken
2184+
// 20_000_000 ns = 20 ms to compute
2185+
.setClusterSettings(clusterSettings)
2186+
.setStoragePath(storagePath)
2187+
.build(),
2188+
CacheType.INDICES_REQUEST_CACHE,
2189+
Map.of(
2190+
OpenSearchOnHeapCache.OpenSearchOnHeapCacheFactory.NAME,
2191+
new OpenSearchOnHeapCache.OpenSearchOnHeapCacheFactory(),
2192+
MockDiskCache.MockDiskCacheFactory.NAME,
2193+
// The size value passed in here acts as the "implementation setting" for the disk tier, and should also be ignored
2194+
new MockDiskCache.MockDiskCacheFactory(0, diskSizeFromImplSetting, false, keyValueSize)
2195+
)
2196+
);
2197+
checkSegmentSizes(tieredSpilloverCache, expectedHeapSize, expectedDiskSize);
2198+
}
2199+
2200+
public void testSegmentSizesWhenNotUsingFactory() {
2201+
long expectedHeapSize = 256L * between(10, 20);
2202+
long expectedDiskSize = MIN_DISK_CACHE_SIZE_IN_BYTES + 256L * between(30, 40);
2203+
int heapSizeFromImplSetting = 50;
2204+
int diskSizeFromImplSetting = 50;
2205+
2206+
Settings settings = Settings.builder()
2207+
.put(
2208+
CacheSettings.getConcreteStoreNameSettingForCacheType(CacheType.INDICES_REQUEST_CACHE).getKey(),
2209+
TieredSpilloverCache.TieredSpilloverCacheFactory.TIERED_SPILLOVER_CACHE_NAME
2210+
)
2211+
.put(FeatureFlags.PLUGGABLE_CACHE, "true")
2212+
// The size setting from the OpenSearchOnHeapCache implementation should not be honored
2213+
.put(
2214+
OpenSearchOnHeapCacheSettings.MAXIMUM_SIZE_IN_BYTES.getConcreteSettingForNamespace(
2215+
CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
2216+
).getKey(),
2217+
heapSizeFromImplSetting + "b"
2218+
)
2219+
.build();
2220+
2221+
int keyValueSize = 1;
2222+
MockCacheRemovalListener<String, String> removalListener = new MockCacheRemovalListener<>();
2223+
int numSegments = getNumberOfSegments();
2224+
CacheConfig<String, String> cacheConfig = getCacheConfig(1, settings, removalListener, numSegments);
2225+
TieredSpilloverCache<String, String> tieredSpilloverCache = getTieredSpilloverCache(
2226+
new OpenSearchOnHeapCache.OpenSearchOnHeapCacheFactory(),
2227+
new MockDiskCache.MockDiskCacheFactory(0, diskSizeFromImplSetting, true, keyValueSize),
2228+
cacheConfig,
2229+
null,
2230+
removalListener,
2231+
numSegments,
2232+
expectedHeapSize,
2233+
expectedDiskSize
2234+
);
2235+
checkSegmentSizes(tieredSpilloverCache, expectedHeapSize, expectedDiskSize);
2236+
}
2237+
2238+
private void checkSegmentSizes(TieredSpilloverCache<String, String> cache, long expectedHeapSize, long expectedDiskSize) {
2239+
TieredSpilloverCache.TieredSpilloverCacheSegment<String, String> segment = cache.tieredSpilloverCacheSegments[0];
2240+
assertEquals(expectedHeapSize / cache.getNumberOfSegments(), segment.getOnHeapCacheMaxWeight());
2241+
assertEquals(expectedDiskSize / cache.getNumberOfSegments(), segment.getDiskCacheMaxWeight());
2242+
}
2243+
21152244
public void testDropStatsForDimensions() throws Exception {
21162245
int onHeapCacheSize = randomIntBetween(300, 600);
21172246
int diskCacheSize = randomIntBetween(700, 1200);
@@ -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

+1
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

+5
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

+61
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

+17-5
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)