public void testExecutorLocalExecuteRunnable() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.LOCAL, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; atomicIntegerSupplier.get().set(0); executor(cm1).execute(() -> atomicIntegerSupplier.get().getAndIncrement()); eventuallyEquals(1, () -> atomicIntegerSupplier.get().get()); } }); }
public void testExecutorLocalRunnable() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.LOCAL, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; atomicIntegerSupplier.get().set(0); SerializableSupplier<AtomicInteger> supplier = atomicIntegerSupplier; executor(cm1).submit(() -> supplier.get().getAndIncrement()).get(10, TimeUnit.SECONDS); assertSize(cms, atomicIntegerSupplier.get().get()); } }); }
public void testExecutorLocalTriConsumer() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.LOCAL, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; AtomicReference<Throwable> throwable = new AtomicReference<>(); List<Address> addresses = Collections.synchronizedList(new ArrayList<>(2)); executor(cm1).submitConsumer(m -> m.getAddress(), (a, i, t) -> { if (t != null) { throwable.set(t); } else { addresses.add(i); } }).get(10, TimeUnit.SECONDS); Throwable t = throwable.get(); if (t != null) { throw new RuntimeException(t); } assertEquals(1, addresses.size()); assertTrue(addresses.contains(cm1.getAddress())); } }); }
public void testExecutorRunnable() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; atomicIntegerSupplier.get().set(0); SerializableSupplier<AtomicInteger> supplier = atomicIntegerSupplier; executor(cm1).submit(() -> supplier.get().getAndIncrement()).get(10, TimeUnit.SECONDS); assertSize(cms, atomicIntegerSupplier.get().get()); } }); }
public void testExecutorTriConsumerException() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; AtomicInteger exceptionCount = new AtomicInteger(); CompletableFuture<Void> future = executor(cm1).submitConsumer(m -> { throw new TestException(); }, (a, i, t) -> { Exceptions.assertException(TestException.class, t); exceptionCount.incrementAndGet(); }); future.get(10, TimeUnit.SECONDS); assertSize(cms, exceptionCount.get()); } }); }
public void testExecutorRunnableException() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; CompletableFuture<Void> future = executor(cm1).submit(() -> { throw new TestException(); }); Exceptions.expectExecutionException(TestException.class, future); } }); }
public void testExecutorExecuteRunnable() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; atomicIntegerSupplier.get().set(0); SerializableSupplier<AtomicInteger> supplier = atomicIntegerSupplier; executor(cm1).execute(() -> supplier.get().getAndIncrement()); eventuallyAssertSize(cms, () -> atomicIntegerSupplier.get().get()); } }); }
public void testExecutorRunnablePredicateFilter() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; atomicIntegerSupplier.get().set(0); SerializableSupplier<AtomicInteger> supplier = atomicIntegerSupplier; executor(cm1).filterTargets(a -> a.equals(cm1.getAddress())) .submit(() -> supplier.get().getAndIncrement()).get(10, TimeUnit.SECONDS); assertEquals(1, atomicIntegerSupplier.get().get()); } }); }
public void testExecutorTriConsumerExceptionFromConsumer() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; CompletableFuture<Void> future = executor(cm1).submitConsumer(m -> null, (a, i, t) -> { throw new NullPointerException(); }); Exceptions.expectExecutionException(NullPointerException.class, future); } }); }
public void testExecutorRunnableCollectionFilter() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; EmbeddedCacheManager cm2 = cms[1]; atomicIntegerSupplier.get().set(0); SerializableSupplier<AtomicInteger> supplier = atomicIntegerSupplier; executor(cm1).filterTargets(Collections.singleton(cm2.getAddress())) .submit(() -> supplier.get().getAndIncrement()).get(10, TimeUnit.SECONDS); assertEquals(1, atomicIntegerSupplier.get().get()); } }); }
private void test(ConfigurationBuilder cfg, final Assertion assertion) { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createClusteredCacheManager(cfg), TestCacheManagerFactory.createClusteredCacheManager(cfg)) { @Override public void call() { EmbeddedCacheManager slave = isMaster(cms[0].getCache()) ? cms[1] : cms[0]; RpcManager wireTappedRpcManager = spyOnTransport(slave.getCache()); slave.getCache().put(1, new Person("person1", "blurb1", 20)); slave.getCache().put(2, new Person("person2", "blurb2", 27)); slave.getCache().put(3, new Person("person3", "blurb3", 56)); assertion.doAssertion(wireTappedRpcManager); } }); }
public void testExecutorTimeoutException() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.DIST_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.DIST_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; CompletableFuture<Void> future = executor(cm1).timeout(10, TimeUnit.MILLISECONDS).submit(() -> { try { Thread.sleep(1000); } catch (InterruptedException e) { fail("Unexpected interrupt: " + e); } }); // This fails when local node is invoked since timeout is not adhered to Exceptions .expectExecutionException(org.infinispan.util.concurrent.TimeoutException.class, future); } }); }
public void testExecutorTriConsumer() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; EmbeddedCacheManager cm2 = cms[1]; AtomicReference<Throwable> throwable = new AtomicReference<>(); List<Address> addresses = Collections.synchronizedList(new ArrayList<>(2)); executor(cm1).submitConsumer(EmbeddedCacheManager::getAddress, (a, i, t) -> { if (t != null) { throwable.set(t); } else { addresses.add(i); } }).get(10, TimeUnit.SECONDS); Throwable t = throwable.get(); if (t != null) { throw new RuntimeException(t); } assertContains(cms, addresses); } }); }
public void testExecutorTriConsumerExceptionWhenComplete() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; CompletableFuture<Void> future = executor(cm1).filterTargets(cm1.getAddress()::equals).submitConsumer(m -> null, (a, i, t) -> { throw new NullPointerException(); }); Exchanger<Throwable> exchanger = new Exchanger<>(); future.whenCompleteAsync((v, t) -> { try { exchanger.exchange(t, 10, TimeUnit.SECONDS); } catch (InterruptedException | TimeoutException e) { throw new RuntimeException(e); } }); Throwable t = exchanger.exchange(null, 10, TimeUnit.SECONDS); assertNotNull(t); assertEquals(NullPointerException.class, t.getClass()); } }); } }
public void testExecutorRunnable3NodesException() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; CompletableFuture<Void> future = executor(cm1).submit(() -> { throw new TestException(); }); Exceptions.expectExecutionException(TestException.class, future); } }); }
public void testExecutorRunnable3NodesExceptionExcludeLocal() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; CompletableFuture<Void> future = executor(cm1).filterTargets(a -> !a.equals(cm1.getAddress())).submit(() -> { throw new TestException(); }); Exceptions.expectExecutionException(TestException.class, future); } }); }
public void testExecutor3NodesRunnable() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; atomicIntegerSupplier.get().set(0); SerializableSupplier<AtomicInteger> supplier = atomicIntegerSupplier; executor(cm1).submit(() -> supplier.get().getAndIncrement()).get(10, TimeUnit.SECONDS); assertSize(cms, atomicIntegerSupplier.get().get()); } }); }
public void testMetadataCacheStarted() throws Exception { String persistentStateLocation = TestingUtil.tmpDirectory(this.getClass()); Util.recursiveFileRemove(persistentStateLocation); final String persistentStateLocation1 = persistentStateLocation + "/1"; final String persistentStateLocation2 = persistentStateLocation + "/2"; TestingUtil.withCacheManagers(new MultiCacheManagerCallable(createCacheManager(persistentStateLocation1), createCacheManager(persistentStateLocation2)) { @Override public void call() throws Exception { assertFalse(cms[0].isRunning(ProtobufMetadataManagerConstants.PROTOBUF_METADATA_CACHE_NAME)); cms[0].getCache(); assertTrue(cms[0].isRunning(ProtobufMetadataManagerConstants.PROTOBUF_METADATA_CACHE_NAME)); assertFalse(cms[1].isRunning(ProtobufMetadataManagerConstants.PROTOBUF_METADATA_CACHE_NAME)); cms[1].getCache(); assertTrue(cms[1].isRunning(ProtobufMetadataManagerConstants.PROTOBUF_METADATA_CACHE_NAME)); } }); } }
public void testCacheManagerRestartReusingConfigurations() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.REPL_SYNC, false)) { @Override public void call() { EmbeddedCacheManager cm1 = cms[0]; EmbeddedCacheManager cm2 = cms[1]; TestingUtil.waitForNoRebalance(cm1.getCache(), cm2.getCache()); Cache<Object, Object> c1 = cm1.getCache(); GlobalConfiguration globalCfg = cm1.getCacheManagerConfiguration(); Configuration cfg = c1.getCacheConfiguration(); TestingUtil.killCacheManagers(cm1); globalCfg = new GlobalConfigurationBuilder().read(globalCfg).build(); withCacheManager(new CacheManagerCallable( new DefaultCacheManager(globalCfg, cfg)) { @Override public void call() { Cache<Object, Object> c = cm.getCache(); c.put(1, "v1"); assertEquals("v1", c.get(1)); } }); } }); }
public void testExecutor3NodeTriConsumer() { withCacheManagers(new MultiCacheManagerCallable( TestCacheManagerFactory.createCacheManager(CacheMode.DIST_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.DIST_SYNC, false), TestCacheManagerFactory.createCacheManager(CacheMode.DIST_SYNC, false)) { @Override public void call() throws InterruptedException, ExecutionException, TimeoutException { EmbeddedCacheManager cm1 = cms[0]; AtomicReference<Throwable> throwable = new AtomicReference<>(); List<Address> addresses = Collections.synchronizedList(new ArrayList<>(2)); executor(cm1).submitConsumer(m -> m.getAddress(), (a, i, t) -> { if (t != null) { throwable.set(t); } else { addresses.add(i); } }).get(10, TimeUnit.SECONDS); Throwable t = throwable.get(); if (t != null) { throw new RuntimeException(t); } assertContains(cms, addresses); } }); }