/** * {@inheritDoc} */ public void addListener(Object listener) { parentCache.addListener(listener); }
@Override protected void registerListener() { ((AdvancedCache<?, ?>) eventSource.getNativeCache()).addListener(this); }
/** * Clustered timestamps region constructor. * * @param cache instance to store update timestamps * @param name of the update timestamps region * @param factory for the update timestamps region */ public ClusteredTimestampsRegionImpl( AdvancedCache cache, String name, InfinispanRegionFactory factory) { super(cache, name, factory); cache.addListener(this); populateLocalCache(); }
void start(SearchFactoryHandler searchFactoryHandler) { if (indexedEntities != null) { throw new IllegalStateException("Cannot start internal cache unless we are in autodetect mode"); } if (searchFactoryHandler == null) { throw new IllegalArgumentException("null argument not allowed"); } this.searchFactoryHandler = searchFactoryHandler; startInternalCache(); knownClassesCache.addListener(searchFactoryHandler.getCacheListener(), key -> key.getKey().equals(cacheName)); }
void start(SearchFactoryHandler searchFactoryHandler) { if (indexedEntities != null) { throw new IllegalStateException("Cannot start internal cache unless we are in autodetect mode"); } if (searchFactoryHandler == null) { throw new IllegalArgumentException("null argument not allowed"); } this.searchFactoryHandler = searchFactoryHandler; startInternalCache(); knownClassesCache.addListener(searchFactoryHandler.getCacheListener(), key -> key.getKey().equals(cacheName)); }
cache.addListener(new CacheEventListener()); listeners.put(fullName, lListeners); alreadyAdded = true;
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)); }
localCollectionCache = localManager.getCache( Customer.class.getName() + ".contacts" ).getAdvancedCache(); localListener = new MyListener( "local" ); localCustomerCache.addListener( localListener ); localContactCache.addListener( localListener ); localCollectionCache.addListener( localListener ); remoteCollectionCache = remoteManager.getCache( Customer.class.getName() + ".contacts" ).getAdvancedCache(); remoteListener = new MyListener( "remote" ); remoteCustomerCache.addListener( remoteListener ); remoteContactCache.addListener( remoteListener ); remoteCollectionCache.addListener( remoteListener );
@Override public void run() { PutBlocker blocker = null; try { blocker = new PutBlocker(blockerLatch, triggerLatch, KEY); cache.addListener(blocker); withSession(sessionFactory, session -> TEST_SESSION_ACCESS.fromRegion(region).put(session, KEY, VALUE2)); } catch (Exception e) { holder.addException(e); } finally { if (blocker != null) { cache.removeListener(blocker); } if (triggerLatch.getCount() > 0) { triggerLatch.countDown(); } } } };
public void testGetConflictsDuringStateTransfer() throws Throwable { createCluster(); splitCluster(); RehashListener listener = new RehashListener(); getCache(0).addListener(listener); CountDownLatch latch = new CountDownLatch(1); delayStateTransferCompletion(latch); fork(() -> partition(0).merge(partition(1), false)); listener.latch.await(); Exceptions.expectException(IllegalStateException.class, ".* Unable to retrieve conflicts as StateTransfer is currently in progress for cache .*", () -> getConflicts(0)); latch.countDown(); }
public void testGetAllVersionsDuringStateTransfer() throws Exception { final int key = 1; final int value = 1; createCluster(); getCache(2).put(key, value); splitCluster(); RehashListener listener = new RehashListener(); getCache(0).addListener(listener); CountDownLatch latch = new CountDownLatch(1); delayStateTransferCompletion(latch); // Trigger the merge and wait for state transfer to begin Future<?> mergeFuture = fork(() -> partition(0).merge(partition(1))); assertTrue(listener.latch.await(10, TimeUnit.SECONDS)); Future<Map<Address, InternalCacheValue<Object>>> versionFuture = fork(() -> getAllVersions(0, key)); // Check that getAllVersions doesn't return while state transfer is in progress Exceptions.expectException(TimeoutException.class, () -> versionFuture.get(100, TimeUnit.MILLISECONDS)); // Allow and wait for state transfer to finish latch.countDown(); mergeFuture.get(30, TimeUnit.SECONDS); // Check the results Map<Address, InternalCacheValue<Object>> versionMap = versionFuture.get(60, TimeUnit.SECONDS); assertTrue(versionMap != null); assertTrue(!versionMap.isEmpty()); // mergepolicy == null, so no conflict resolution occurs therefore it's possible that versionMap may contain null entries assertEquals(String.format("Returned versionMap %s", versionMap),2, versionMap.size()); }
@Override public void run() { GetBlocker blocker = new GetBlocker( blockerLatch, KEY ); try { cache.addListener( blocker ); withSession(sessionFactory, session -> TEST_SESSION_ACCESS.fromRegion(region).get(session, KEY )); } catch (Exception e) { holder.addException(e); } finally { cache.removeListener( blocker ); } } };
public void testTransactionSuspended() throws Exception { TestListener listener = new TestListener(); cache.getAdvancedCache().addListener(listener); assertTrue(cache.isEmpty()); //created cache.put("key", "value"); assertEquals("value", cache.get("key")); //modified cache.put("key", "new-value"); assertEquals("new-value", cache.get("key")); tm().begin(); assertEquals("new-value", cache.get("key")); tm().commit(); //removed cache.remove("key"); assertNull(cache.get("key")); cache.clear(); assertTrue(cache.isEmpty()); if (listener.list.size() > 0) { for (Throwable throwable : listener.list) { log.error("Error in listener...", throwable); } fail("Listener catch some errors"); } }
cache0.addListener(listener0); TopologyUpdateListener listener2 = new TopologyUpdateListener(); cache2.addListener(listener2);