public void testRunnableExecutionOnTerminatedExecutor() { DistributedExecutorService des = createDES(getCache()); des.shutdown(); BoringRunnable runnable = new BoringRunnable(); expectException(RejectedExecutionException.class, () -> des.execute(runnable)); }
public void testDistributedExecutorRealShutdown() { ConfigurationBuilder config = TestCacheManagerFactory.getDefaultCacheConfiguration(true); config.clustering().cacheMode(CacheMode.REPL_SYNC); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createClusteredCacheManager(config); ExecutorService service = new WithinThreadExecutor(); try { Cache<Object, Object> cache = cacheManager.getCache(); DistributedExecutorService des = new DefaultExecutorService(cache, service); des.shutdown(); assert des.isShutdown(); assert des.isTerminated(); assert !service.isShutdown(); } finally { TestingUtil.killCacheManagers(cacheManager); service.shutdown(); } }
public void testDistributedExecutorRealShutdownWithOwnership() { ConfigurationBuilder config = TestCacheManagerFactory.getDefaultCacheConfiguration(true); config.clustering().cacheMode(CacheMode.REPL_SYNC); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createClusteredCacheManager(config); ExecutorService service = new WithinThreadExecutor(); try { Cache<Object, Object> cache = cacheManager.getCache(); DistributedExecutorService des = new DefaultExecutorService(cache, service, true); des.shutdown(); assert des.isShutdown(); assert des.isTerminated(); assert service.isShutdown(); } finally { TestingUtil.killCacheManagers(cacheManager); } }
public void testBasicLocalDistributedCallable() throws Exception { long taskTimeout = TimeUnit.SECONDS.toMillis(15); EmbeddedCacheManager cacheManager1 = manager(0); Cache<Object, Object> cache1 = cacheManager1.getCache(); // initiate task from cache1 and execute on same node DistributedExecutorService des = new DefaultExecutorService(cache1); try { SameNodeTaskFailoverPolicy sameNodeTaskFailoverPolicy = new SameNodeTaskFailoverPolicy(3); DistributedTaskBuilder<Void> builder = des .createDistributedTaskBuilder(new TestExceptionCallable()) .failoverPolicy(sameNodeTaskFailoverPolicy) .timeout(taskTimeout, TimeUnit.MILLISECONDS); CompletableFuture<Void> future = des.submit(builder.build()); expectExecutionException(TestException.class, future); assertEquals(3, sameNodeTaskFailoverPolicy.failoverCount.get()); } finally { des.shutdown(); } }
public void testDistributedExecutorShutDown() { ConfigurationBuilder config = TestCacheManagerFactory.getDefaultCacheConfiguration(true); config.clustering().cacheMode(CacheMode.REPL_SYNC); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createClusteredCacheManager(config); try { Cache<Object, Object> cache = cacheManager.getCache(); DistributedExecutorService des = new DefaultExecutorService(cache); des.shutdown(); assert des.isShutdown(); assert des.isTerminated(); } finally { TestingUtil.killCacheManagers(cacheManager); } }
public void testBasicTargetRemoteDistributedCallable() throws Exception { long taskTimeout = TimeUnit.SECONDS.toMillis(15); EmbeddedCacheManager cacheManager1 = manager(0); final EmbeddedCacheManager cacheManager2 = manager(1); Cache<Object, Object> cache1 = cacheManager1.getCache(); Cache<Object, Object> cache2 = cacheManager2.getCache(); // initiate task from cache1 and execute on same node DistributedExecutorService des = new DefaultExecutorService(cache1); Address target = cache2.getAdvancedCache().getRpcManager().getAddress(); try { DistributedTaskBuilder<Integer> builder = des .createDistributedTaskBuilder(new SleepingSimpleCallable()) .failoverPolicy(new RandomNodeTaskFailoverPolicy(2)) .timeout(taskTimeout, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); fork(() -> { TestingUtil.killCacheManagers(cacheManager2); latch.countDown(); }); assertEquals((Integer) 1, future.get()); } finally { des.shutdown(); } }
public void testBasicTargetRemoteDistributedCallable() throws Exception { long taskTimeout = TimeUnit.SECONDS.toMillis(15); EmbeddedCacheManager cacheManager1 = manager(0); final EmbeddedCacheManager cacheManager2 = manager(1); Cache<Object, Object> cache1 = cacheManager1.getCache(); Cache<Object, Object> cache2 = cacheManager2.getCache(); DistributedExecutorService des = null; try { des = new DefaultExecutorService(cache1); Address target = cache2.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder<Integer> builder = des.createDistributedTaskBuilder(new SimpleCallable()) .failoverPolicy(DefaultExecutorService.RANDOM_NODE_FAILOVER) .timeout(taskTimeout, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); AssertJUnit.assertEquals((Integer) 1, future.get()); } catch (Exception ex) { AssertJUnit.fail("Task did not failover properly " + ex); } finally { if (des != null) des.shutdown(); } }
public void testBasicTargetRemoteDistributedCallableWithoutAnyTimeout() throws Exception { ConfigurationBuilder confBuilder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false); confBuilder.clustering().remoteTimeout(0L); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createClusteredCacheManager(confBuilder); EmbeddedCacheManager cacheManager1 = TestCacheManagerFactory.createClusteredCacheManager(confBuilder); Cache<Object, Object> cache1 = cacheManager.getCache(); Cache<Object, Object> cache2 = cacheManager1.getCache(); DistributedExecutorService des = null; try { // initiate task from cache1 and execute on same node des = new DefaultExecutorService(cache1); Address target = cache2.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder<Integer> builder = des .createDistributedTaskBuilder(new DistributedExecutorTest.SleepingSimpleCallable(latchHolder)); Future<Integer> future = des.submit(target, builder.build()); Thread.sleep(100); latchHolder.get().open(); AssertJUnit.assertEquals((Integer) 1, future.get()); } finally { if (des != null) des.shutdown(); TestingUtil.killCacheManagers(cacheManager, cacheManager1); } }