public CacheGroup(CacheGroupConfiguration config) { this.cache = config.getCache(); this.nodeFactory = config.getMemberFactory(); this.cache.getCacheManager().addListener(this); this.cache.addListener(this); }
@Override public EmbeddedCacheManager get() { GlobalConfiguration config = this.configuration.get(); String defaultCacheName = config.defaultCacheName().orElse(null); // We need to create a dummy default configuration if cache has a default cache Configuration defaultConfiguration = (defaultCacheName != null) ? new ConfigurationBuilder().build() : null; EmbeddedCacheManager manager = new DefaultCacheManager(config, defaultConfiguration, false); // Undefine the default cache, if we defined one if (defaultCacheName != null) { manager.undefineConfiguration(defaultCacheName); } // Override GlobalConfigurationManager with a local implementation @SuppressWarnings("deprecation") BasicComponentRegistry registry = manager.getGlobalComponentRegistry().getComponent(BasicComponentRegistry.class); registry.replaceComponent(GlobalConfigurationManager.class.getName(), new LocalGlobalConfigurationManager(), false); registry.rewire(); manager.start(); manager.addListener(this); InfinispanLogger.ROOT_LOGGER.debugf("%s cache container started", this.name); return manager; }
@Override public void addListener(Object listener) { this.container.addListener(listener); }
public ViewChangeListener(EmbeddedCacheManager cm) { this.cm = cm; cm.addListener(this); }
public void addManagerListener(Object listener) { cache.getCacheManager().addListener(listener); }
public static void registerAndStartContainer(final EmbeddedCacheManager container, final Object listener) { PrivilegedAction<Void> action = () -> { container.addListener(listener); container.start(); return null; }; doPrivileged(action); }
@Override public void listenRoleChange(IListenRoleChange i) throws ListenRoleChangeAddException { EmbeddedCacheManager manager = this.cm; if (manager == null) { // In case we cannot fetch the information, lets assume we // are standby, so to have less responsibility. throw new ListenRoleChangeAddException(); } if (this.roleChangeListeners == null) { this.roleChangeListeners = new HashSet<IListenRoleChange>(); this.cacheManagerListener = new ViewChangedListener( this.roleChangeListeners); manager.addListener(this.cacheManagerListener); } if (this.roleChangeListeners != null) { this.roleChangeListeners.add(i); } }
@Test public void addListener() { Object listener = new Object(); this.subject.addListener(listener); verify(this.manager).addListener(listener); }
@Override public void init(CacheLoaderConfig config, Cache<?, ?> cache, StreamingMarshaller m) throws CacheLoaderException { super.init(config, cache, m); this.cacheManager = cache == null ? null : cache.getCacheManager(); listener = new CacheListener(); cacheManager.addListener(listener); }
/** * Create a new InfinispanRegistry using the specified replicated cache. * @param serviceCache the replicated cache to use */ public InfinispanRegistry(Cache<String, String> serviceCache) { _serviceCache = serviceCache; _serializer = SerializerFactory.create(FormatType.JSON, null, true); serviceCache.getCacheManager().addListener(new MemberDropListener()); _nodeName = serviceCache.getCacheManager().getAddress().toString(); }
public CacheGroup(CacheGroupConfiguration config) { this.cache = config.getCache(); this.nodeFactory = config.getMemberFactory(); this.cache.getCacheManager().addListener(this); this.cache.addListener(this); }
@Override public void start(StartContext context) { this.refreshLocalEntry(); Cache<Address, Map.Entry<K, V>> cache = this.cache.getValue(); cache.getCacheManager().addListener(this); cache.addListener(this); }
public void initCache() { this.cache.getAdvancedCache().getComponentRegistry().registerComponent(sessionFactory, KeycloakSessionFactory.class); cache.getCacheManager().addListener(new ViewChangeListener()); }
public ClusteredLockImpl(String name, ClusteredLockKey lockKey, AdvancedCache<ClusteredLockKey, ClusteredLockValue> clusteredLockCache, EmbeddedClusteredLockManager clusteredLockManager) { this.name = name; this.lockKey = lockKey; this.clusteredLockCache = clusteredLockCache; this.clusteredLockManager = clusteredLockManager; this.pendingRequests = new ConcurrentLinkedQueue<>(); this.readWriteMap = ReadWriteMapImpl.create(FunctionalMapImpl.create(clusteredLockCache)); originator = clusteredLockCache.getCacheManager().getAddress(); requestExpirationScheduler = new RequestExpirationScheduler(clusteredLockManager.getScheduledExecutorService()); clusterChangeListener = new ClusterChangeListener(); lockReleasedListener = new LockReleasedListener(); this.clusteredLockCache.getCacheManager().addListener(clusterChangeListener); this.clusteredLockCache.addListener(lockReleasedListener, new ClusteredLockFilter(lockKey)); }
public void testViewChange() throws Exception { EmbeddedCacheManager cmA = TestCacheManagerFactory.createClusteredCacheManager(); CacheContainer cmB = null; try { cmA.getCache(); GetCacheManagerCheckListener listener = new GetCacheManagerCheckListener(); cmA.addListener(listener); cmB = TestCacheManagerFactory.createClusteredCacheManager(); cmB.getCache(); assertNotNull(listener.firstEvent.get(10, TimeUnit.SECONDS)); } finally { TestingUtil.killCacheManagers(cmA, cmB); } }
@Test public void testDependencyOnStoppedCaches() { cacheManager.defineConfiguration("A", new ConfigurationBuilder().build()); cacheManager.defineConfiguration("B", new ConfigurationBuilder().build()); Cache<?, ?> cacheA = cacheManager.getCache("A"); Cache<?, ?> cacheB = cacheManager.getCache("B"); cacheA.stop(); cacheManager.addCacheDependency("A", "B"); CacheEventListener listener = new CacheEventListener(); cacheManager.addListener(listener); cacheManager.stop(); assertAllTerminated(cacheA, cacheB); assertEquals(Arrays.asList("B", GlobalConfigurationManager.CONFIG_STATE_CACHE_NAME, DEFAULT_CACHE_NAME), listener.stopOrder); }
private void addSelfToTopologyView(EmbeddedCacheManager cacheManager) { addressCache = cacheManager.getCache(configuration.topologyCacheName()); clusterAddress = cacheManager.getAddress(); address = new ServerAddress(configuration.publicHost(), configuration.publicPort()); distributedExecutorService = new DefaultExecutorService(addressCache); viewChangeListener = new CrashedMemberDetectorListener(addressCache, this); cacheManager.addListener(viewChangeListener); topologyChangeListener = new ReAddMyAddressListener(addressCache, clusterAddress, address); addressCache.addListener(topologyChangeListener); // Map cluster address to server endpoint address log.debugf("Map %s cluster address with %s server endpoint in address cache", clusterAddress, address); // Guaranteed delivery required since if data is lost, there won't be // any further cache calls, so negative acknowledgment can cause issues. addressCache.getAdvancedCache().withFlags(Flag.SKIP_CACHE_LOAD, Flag.GUARANTEED_DELIVERY) .put(clusterAddress, address); }
@Override protected void createCacheManagers() throws Throwable { addClusterEnabledCacheManager(getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, true), new TransportFlags().withMerge(true)); ml0 = new MergeListener(); manager(0).addListener(ml0); discard = TestingUtil.getDiscardForCache(manager(0)); discard.setDiscardAll(true); addClusterEnabledCacheManager(getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, true), new TransportFlags().withMerge(true)); ml1 = new MergeListener(); manager(1).addListener(ml1); cache(0).put("k", "v0"); cache(1).put("k", "v1"); Thread.sleep(2000); assert advancedCache(0).getRpcManager().getTransport().getMembers().size() == 1; assert advancedCache(1).getRpcManager().getTransport().getMembers().size() == 1; }
@Test public void testRemoveCache() { cacheManager.defineConfiguration("A", new ConfigurationBuilder().build()); cacheManager.defineConfiguration("B", new ConfigurationBuilder().build()); cacheManager.defineConfiguration("C", new ConfigurationBuilder().build()); Cache<?, ?> cacheA = cacheManager.getCache("A"); Cache<?, ?> cacheB = cacheManager.getCache("B"); Cache<?, ?> cacheC = cacheManager.getCache("C"); cacheManager.addCacheDependency("A", "B"); cacheManager.addCacheDependency("A", "C"); cacheManager.addCacheDependency("B", "C"); cacheManager.administration().removeCache("B"); CacheEventListener listener = new CacheEventListener(); cacheManager.addListener(listener); cacheManager.stop(); assertAllTerminated(cacheA, cacheB, cacheC); assertEquals(Arrays.asList("A", "C", GlobalConfigurationManager.CONFIG_STATE_CACHE_NAME, DEFAULT_CACHE_NAME), listener.stopOrder); }
public void testAddRemoveListenerWhileNotRunning() throws Exception { GetCacheManagerCheckListener listener = new GetCacheManagerCheckListener(); ConfigurationBuilderHolder holder = new ConfigurationBuilderHolder(); holder.getGlobalConfigurationBuilder().clusteredDefault().defaultCacheName("default"); holder.newConfigurationBuilder("default").clustering().cacheMode(CacheMode.DIST_SYNC); EmbeddedCacheManager cmA = TestCacheManagerFactory.createClusteredCacheManager(false, holder, false); EmbeddedCacheManager cmB = null; try { cmA.addListener(listener); cmA.getCache(); cmB = TestCacheManagerFactory.createClusteredCacheManager(); cmB.getCache(); assertNotNull(listener.firstEvent.get(10, TimeUnit.SECONDS)); } finally { TestingUtil.killCacheManagers(cmA, cmB); } // Should not throw an exception? cmA.removeListener(listener); }