/** * Constructor that initializes the builder with the settings from a {@link CacheSettings} instance * * @param settings the instance to initialize the builder with */ public CacheSettingsBuilder(CacheSettings settings) { this.expireAfterAccess = settings.getExpireAfterAccess(); this.expireAfterWrite = settings.getExpireAfterWrite(); this.flushable = settings.getFlushable(); this.local = settings.getLocal(); this.maxEntries = settings.getMaxEntries(); this.replicateAsynchronously = settings.getReplicateAsynchronously(); this.replicateViaCopy = settings.getReplicateViaCopy(); this.statisticsEnabled = settings.getStatisticsEnabled(); }
public MapConfig configureMapConfig(CacheSettings settings, MapConfig mapConfig, int partitionsCount) boolean hybrid = !settings.getReplicateViaCopy(true); Integer multiplier = hybrid ? HYBRID_MULTIPLIER : 1; Integer maxEntries = settings.getMaxEntries(); final Long expireAfterAccess = settings.getExpireAfterAccess(); if (expireAfterAccess != null) final Long expireAfterWrite = settings.getExpireAfterWrite(); if (expireAfterWrite != null) final boolean nearCache = settings.getReplicateAsynchronously(true); if (nearCache)
private static CacheBuilder<Object, Object> createCacheBuilder(CacheSettings settings) { final CacheBuilder<Object, Object> cacheBuilder = CacheBuilder.newBuilder(); if (null != settings.getMaxEntries()) { cacheBuilder.maximumSize(settings.getMaxEntries()); } // Old form of stats collection - leave in place. It allows stats from the delegate. if (null != settings.getStatisticsEnabled() && settings.getStatisticsEnabled()) { cacheBuilder.recordStats(); } if (null != settings.getExpireAfterAccess()) { cacheBuilder.expireAfterAccess(settings.getExpireAfterAccess(), MILLISECONDS); } else if (null != settings.getExpireAfterWrite()) { cacheBuilder.expireAfterWrite(settings.getExpireAfterWrite(), MILLISECONDS); } return cacheBuilder; } }
if (null != settings.getMaxEntries()) config.setMaxEntriesLocalHeap(settings.getMaxEntries()); if (settings.getExpireAfterAccess() != null || settings.getExpireAfterWrite() != null) if (null != settings.getExpireAfterAccess()) config.timeToIdleSeconds(SECONDS.convert(settings.getExpireAfterAccess(), MILLISECONDS)); if (null != settings.getExpireAfterWrite()) config.timeToLiveSeconds(SECONDS.convert(settings.getExpireAfterWrite(), MILLISECONDS));
private <K, V> Cache<K, V> doCreateCache(String name, CacheLoader<K, V> loader, CacheSettings settings) { if (settings.getLocal(false)) { return localCacheFactory.getCache(name, loader, settings); } if (settings.getReplicateViaCopy(true)) { return createDistributedCache(name, loader, settings); } if (settings.getReplicateAsynchronously(true)) { return createAsyncHybridCache(name, loader, settings); } else { return createHybridCache(name, loader, settings); } }
@Override public final boolean isFlushable() { return settings.getFlushable(true); }
protected CacheSettings mergeSettings(String name, CacheSettings settings) { if (cacheSettingsDefaultsProvider == null) { return settings; } return cacheSettingsDefaultsProvider.getDefaults(name).override(settings); }
@Override @Nonnull public CacheConfiguration.CacheEventListenerFactoryConfiguration createCacheReplicatorConfiguration(final CacheSettings settings, final boolean selfLoadingCache) { final boolean replicateAsynchronously = settings.getReplicateAsynchronously(false); final boolean replicateViaCopy = settings.getReplicateViaCopy(false); // If the cache is self loading there is no need to replicate puts or updates as the loader takes care of // populating the cache as needed. // Else if the cache is replicating via copy then puts and updates should be replicated. // Else replicating puts is dangerous as it may lead to invalidations ping ponging between nodes. Whether to // replicate updates is ambiguous, but setting it may help to prevent stale caches while being less vulnerable // to the invalidation storm that comes with simply replicating puts. final boolean replicatePuts = !selfLoadingCache && replicateViaCopy; final boolean replicateUpdates = !selfLoadingCache; final String cacheProperties = String.format(CACHE_PROPERTIES, replicateAsynchronously, replicatePuts, replicateViaCopy, replicateUpdates, replicateViaCopy); return new CacheConfiguration.CacheEventListenerFactoryConfiguration() .className(RMICacheReplicatorFactory.class.getName()) .properties(cacheProperties); } }
@Override public boolean isStatisticsEnabled() { return settings.getStatisticsEnabled(true); }
@Override public final Integer currentMaxEntries() { return settings.getMaxEntries(); }
@Override public final Long currentExpireAfterWriteMillis() { return settings.getExpireAfterWrite(); }
@Override public final Long currentExpireAfterAccessMillis() { return settings.getExpireAfterAccess(); }
@Override public final boolean isReplicateAsynchronously() { return settings.getReplicateAsynchronously(false); }
@Override public final boolean isLocal() { return settings.getLocal(false); }
@Override public final boolean isReplicateViaCopy() { return settings.getReplicateViaCopy(false); }
private <V> CachedReference<V> doCreateCachedReference(String name, Supplier<V> supplier, CacheSettings settings) { if (settings.getLocal(false)) { return localCacheFactory.getCachedReference(name, supplier, settings); } // remote cached reference if (settings.getReplicateViaCopy(true)) { return createDistributedCachedReference(name, supplier, settings); } if (settings.getReplicateAsynchronously(true)) { return createAsyncHybridCachedReference(name, supplier, settings); } else { return createHybridCachedReference(name, supplier, settings); } }
@Override public final boolean isFlushable() { return settings.getFlushable(true); }
protected <V> CachedReference<V> createDistributedCachedReference(String name, Supplier<V> supplier, CacheSettings settings) { // override the settings to ensure the reference is flushable and the max is set to 1000. A low value for // maxEntries would trigger continuous cache invalidations because of the way map eviction works in Hazelcast. final CacheSettings overriddenSettings = checkNotNull(settings, "settings").override( new CacheSettingsBuilder().flushable().maxEntries(1000).build()); final String mapName = PREFIX_CACHE_REFERENCE + name; configureMap(mapName, overriddenSettings); final IMap<String, OsgiSafe<V>> map = hazelcast.getMap(mapName); return new HazelcastCachedReference<V>(name, map, supplier, this); }
@Override public boolean isStatisticsEnabled() { return settings.getStatisticsEnabled(true); }
@Override public boolean isReplicateAsynchronously() { CacheSettings cacheSettings = getCacheSettings(); return cacheSettings == null || cacheSettings.getReplicateAsynchronously(true); }