@Override public Set<String> getCacheNames() { return this.container.getCacheNames(); }
@Override public Collection<String> getCacheNames() { return this.nativeCacheManager.getCacheNames(); }
/** * {@inheritDoc} * @see org.infinispan.manager.EmbeddedCacheManager#getCacheNames() */ @Override public Set<String> getCacheNames() { Set<String> names = new HashSet<>(this.cm.getCacheNames()); names.add(this.defaultCache); return names; }
@ManagedAttribute(description = "Retrieves a list of caches for the cache manager") public String[] getCacheNames() { Set<String> cacheNames = new HashSet<>(cacheManager.getCacheNames()); cacheNames.add(BasicCacheContainer.DEFAULT_CACHE_NAME); return cacheNames.toArray(new String[0]); }
@PostConstruct public void init() { // Start caches on startup for (String name : cacheManager.getCacheNames()) { cacheManager.getCache(name); } }
@ManagedAttribute(description = "Retrieves a list of caches for the cache manager") public String[] getCacheNames() { Set<String> cacheNames = new HashSet<String>(cacheManager.getCacheNames()); cacheNames.add(BasicCacheContainer.DEFAULT_CACHE_NAME); return cacheNames.toArray(new String[0]); }
private List<Cache<?, ?>> getAllCaches(Session session) { List<Cache<?, ?>> caches = new ArrayList<Cache<?, ?>>(); EmbeddedCacheManager container = session.getCacheManager(); for (String cacheName : container.getCacheNames()) { if (container.isRunning(cacheName)) { caches.add(session.getCache(cacheName)); } } caches.add(container.getCache()); return caches; }
private List<Cache<?, ?>> getAllCaches(Session session) { List<Cache<?, ?>> caches = new ArrayList<>(); EmbeddedCacheManager container = session.getCacheManager(); for (String cacheName : container.getCacheNames()) { if (container.isRunning(cacheName)) { caches.add(session.getCache(cacheName)); } } caches.add(container.getCache()); return caches; }
public void testCacheRegistrationInDefaultCacheManager() { // Make sure the cache is registered cache.put("foo", "bar"); final Set<String> cacheNames = defaultCacheManager.getCacheNames(); assertEquals(cacheNames.size(), 2); assertTrue(cacheNames.contains("small")); assertTrue(cacheNames.contains("large")); }
public void testCacheRegistrationInSpecificCacheManager() { // Make sure the cache is registered cache.put("foo", "bar"); final Set<String> cacheNames = specificCacheManager.getCacheNames(); assertEquals(cacheNames.size(), 1); assertTrue(cacheNames.contains("very-large")); } }
@Test public void getCacheNames() { Set<String> caches = Collections.singleton("other"); when(this.manager.getCacheNames()).thenReturn(caches); Set<String> result = this.subject.getCacheNames(); assertEquals(2, result.size()); assertTrue(result.contains("other")); assertTrue(result.contains("default")); }
public static Set<String> getInternalAndUserCacheNames(EmbeddedCacheManager cacheManager) { Set<String> testCaches = new HashSet<>(cacheManager.getCacheNames()); if (cacheManager.isDefaultRunning()) { String defaultCacheName = cacheManager.getCacheManagerConfiguration().defaultCacheName().orElse(CacheContainer.DEFAULT_CACHE_NAME); testCaches.add(defaultCacheName); } testCaches.addAll(getInternalCacheNames(cacheManager)); return testCaches; }
public void shouldAvoidRpcsDuringIndexing() throws Exception { String[] indexCaches = {DEFAULT_INDEXESDATA_CACHENAME, DEFAULT_INDEXESMETADATA_CACHENAME, DEFAULT_LOCKING_CACHENAME}; RpcCollector rpcCollector = new RpcCollector(); cacheManagers.stream() .flatMap(cm -> cm.getCacheNames().stream().map(cm::getCache)) .forEach(cache -> replaceRpcManager(cache, rpcCollector)); waitForClusterToForm(indexCaches); populate(1, 100); stream(indexCaches).forEach(c -> assertNoRPCs(c, rpcCollector)); }
@Override public void reset() { resetCache(cacheManager.getCache()); for (String cacheName : cacheManager.getCacheNames()) { resetCache(cacheManager.getCache(cacheName)); } timestamp = timeService.time(); }
@Override public void reset() { if (cacheManager.getCacheManagerConfiguration().defaultCacheName().isPresent()) resetCache(cacheManager.getCache()); for (String cacheName : cacheManager.getCacheNames()) { resetCache(cacheManager.getCache(cacheName)); } timestamp = timeService.time(); }
private static Set<Cache> getRunningCaches(EmbeddedCacheManager cacheContainer) { if (cacheContainer == null || !cacheContainer.getStatus().allowInvocations()) return Collections.emptySet(); Set<String> running = new LinkedHashSet<>(getOrderedCacheNames(cacheContainer)); extractGlobalComponent(cacheContainer, InternalCacheRegistry.class).filterPrivateCaches(running); running.addAll(cacheContainer.getCacheNames()); running.add(cacheContainer.getCacheManagerConfiguration().defaultCacheName().orElse(DEFAULT_CACHE_NAME)); return running.stream() .map(s -> cacheContainer.getCache(s, false)) .filter(Objects::nonNull) .filter(c -> c.getStatus().allowInvocations()) .collect(Collectors.toCollection(LinkedHashSet::new)); }
@Override protected void createCacheManagers() throws Throwable { configuration = configure(); createCluster(configuration, 2); waitForClusterToForm(); //check that a default cache has been created manager(0).getCacheNames().contains(getRecoveryCacheName()); manager(1).getCacheNames().contains(getRecoveryCacheName()); }
private void preStartCaches() { // Start defined caches to avoid issues with lazily started caches. Skip internal caches if authorization is not // enabled InternalCacheRegistry icr = cacheManager.getGlobalComponentRegistry().getComponent(InternalCacheRegistry.class); boolean authz = cacheManager.getCacheManagerConfiguration().security().authorization().enabled(); for (String cacheName : cacheManager.getCacheNames()) { getCacheInstance(UNKNOWN_TYPES, null, cacheName, cacheManager, false, (!icr.internalCacheHasFlag(cacheName, InternalCacheRegistry.Flag.PROTECTED) || authz)); } }
public void clear() { InternalCacheRegistry registry = cacheManager.getGlobalComponentRegistry() .getComponent(InternalCacheRegistry.class); cacheManager.getCacheNames().stream() .filter(cacheName -> !registry.isInternalCache(cacheName)) .forEach(cacheName -> cacheManager.getCache(cacheName).getAdvancedCache().getDataContainer().clear()); }
@Test public void testRegionNamesQualified() { TestRegionFactory factory = TestRegionFactoryProvider.INSTANCE.findRegionFactory(sessionFactory().getCache()); EmbeddedCacheManager cacheManager = factory.getCacheManager(); for (String cacheName : cacheManager.getCacheNames()) { assertTrue(cacheName.startsWith(FOO_BAR)); } // In Hibernate < 5.3 the region factory got qualified names and couldn't use any unqualified form if (!TestRegionFactoryProvider.INSTANCE.getRegionFactoryClass().getName().contains(".v51.")) { for (InfinispanBaseRegion region : TestSessionAccess.findTestSessionAccess().getAllRegions(sessionFactory())) { assertFalse(region.getName().startsWith(FOO_BAR)); } } } }