public void testBasicTargetDistributedCallableWithNullExecutionPolicy() throws Exception { Cache<Object, Object> cache1 = getCache(); //initiate task from cache1 and select cache2 as target DistributedExecutorService des = createDES(cache1); //the same using DistributedTask API DistributedTaskBuilder<Boolean> taskBuilder = des.createDistributedTaskBuilder(new SimpleDistributedCallable(false)); expectException(IllegalArgumentException.class, () -> taskBuilder.executionPolicy(null)); }
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 testDistributedCallableEverywhere() throws Exception { DistributedExecutorService des = createDES(getCache()); List<CompletableFuture<Boolean>> list = des.submitEverywhere(new SimpleDistributedCallable(false)); assert list != null && !list.isEmpty(); for (Future<Boolean> f : list) { assert f.get(); } // the same using DistributedTask API DistributedTaskBuilder<Boolean> taskBuilder = des .createDistributedTaskBuilder(new SimpleDistributedCallable(false)); DistributedTask<Boolean> distributedTask = taskBuilder.build(); list = des.submitEverywhere(distributedTask); assert list != null && !list.isEmpty(); for (Future<Boolean> f : list) { assert f.get(); } }
public void testDistributedCallableRandomFailoverPolicy() throws Exception { ConfigurationBuilder config = TestCacheManagerFactory.getDefaultCacheConfiguration(true); config.clustering().cacheMode(CacheMode.REPL_SYNC); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createClusteredCacheManager(config); DistributedExecutorService des = null; try { Cache<Object, Object> cache1 = cacheManager.getCache(); cache1.put("key1", "value1"); cache1.put("key2", "value2"); //initiate task from cache1 and select cache1 as target des = new DefaultExecutorService(cache1); //the same using DistributedTask API DistributedTaskBuilder<Integer> taskBuilder = des.createDistributedTaskBuilder(new FailOnlyOnceCallable()); taskBuilder.failoverPolicy(DefaultExecutorService.RANDOM_NODE_FAILOVER); DistributedTask<Integer> task = taskBuilder.build(); assert task.getTaskFailoverPolicy().equals(DefaultExecutorService.RANDOM_NODE_FAILOVER); Future<Integer> val = des.submit(task, "key1"); val.get(); throw new IllegalStateException("Should have raised exception"); } catch (ExecutionException e){ // The failover policy throws an IllegalStateException because there are no nodes to retry on. // Verify that the distributed executor didn't wrap the exception in too many extra exceptions. AssertJUnit.assertTrue("Wrong exception: " + e, e.getCause() instanceof IllegalStateException); } finally { if (des != null) des.shutdownNow(); TestingUtil.killCacheManagers(cacheManager); } }
private void executeDifferentExecutionPolicies(DistributedTaskExecutionPolicy policy) throws ExecutionException, InterruptedException { assert address(0) instanceof TopologyAwareAddress; assert address(1) instanceof TopologyAwareAddress; Cache<Object, Object> cache1 = cache(0, CACHE_NAME); Cache<Object, Object> cache2 = cache(1, CACHE_NAME); cache1.put("key1", "value1"); cache1.put("key2", "value2"); cache1.put("key3", "value3"); cache1.put("key4", "value4"); cache2.put("key5", "value5"); cache2.put("key6", "value6"); //initiate task from cache1 and select cache2 as target DistributedExecutorService des = new DefaultExecutorService(cache1); try { //the same using DistributedTask API DistributedTaskBuilder<Boolean> taskBuilder = des.createDistributedTaskBuilder(new LocalDistributedExecutorTest.SimpleDistributedCallable(true)); taskBuilder.executionPolicy(policy); DistributedTask<Boolean> distributedTask = taskBuilder.build(); Future<Boolean> future = des.submit(distributedTask, "key1", "key6"); assert future.get(); } finally { des.shutdownNow(); } } }
public void testBasicDistributedCallable() throws Exception { DistributedExecutorService des = createDES(getCache()); Future<Boolean> future = des.submit(new SimpleDistributedCallable(false)); Boolean r = future.get(); assert r; // the same using DistributedTask API DistributedTaskBuilder<Boolean> taskBuilder = des .createDistributedTaskBuilder(new SimpleDistributedCallable(false)); DistributedTask<Boolean> distributedTask = taskBuilder.build(); future = des.submit(distributedTask); r = future.get(); assert r; }
public void testDistributedCallableEmptyFailoverPolicy() throws Exception { ConfigurationBuilder config = TestCacheManagerFactory.getDefaultCacheConfiguration(true); config.clustering().cacheMode(CacheMode.REPL_SYNC); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createClusteredCacheManager(config); DistributedExecutorService des = null; try { Cache<Object, Object> cache1 = cacheManager.getCache(); //initiate task from cache1 and select cache1 as target des = new DefaultExecutorService(cache1); //the same using DistributedTask API DistributedTaskBuilder<Integer> taskBuilder = des.createDistributedTaskBuilder(new ExceptionThrowingCallable()); taskBuilder.failoverPolicy(null); DistributedTask<Integer> task = taskBuilder.build(); assert task.getTaskFailoverPolicy().equals(DefaultExecutorService.NO_FAILOVER); Future<Integer> f = des.submit(task); expectException(ExecutionException.class, TestException.class, f::get); } finally { if (des != null) des.shutdownNow(); TestingUtil.killCacheManagers(cacheManager); } }
public void testCancelAndGet() throws Exception { DistributedExecutorService des = createDES(getCache()); List<Address> cacheMembers = getCache().getAdvancedCache().getRpcManager().getMembers(); List<Address> members = new ArrayList<>(cacheMembers); assertEquals(caches(cacheName()).size(), members.size()); members.remove(getCache().getAdvancedCache().getRpcManager().getAddress()); DistributedTaskBuilder<Integer> tb = des.createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); final Future<Integer> future = des.submit(members.get(0),tb.build()); future.cancel(true); expectException(CancellationException.class, () -> future.get()); latchHolder.get().open(); }
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(); } }
taskBuilder.failoverPolicy(DefaultExecutorService.RANDOM_NODE_FAILOVER); DistributedTask<Integer> task = taskBuilder.build();
public void testTaskCancellation() throws Exception { CyclicBarrier barrier = new CyclicBarrier(2); cache(1, cacheName()).getAdvancedCache().getComponentRegistry().registerComponent(barrier, "barrier"); DistributedExecutorService des = createDES(getCache()); List<Address> cacheMembers = getCache().getAdvancedCache().getRpcManager().getMembers(); assertEquals(caches(cacheName()).size(), cacheMembers.size()); DistributedTaskBuilder<Integer> tb = des.createDistributedTaskBuilder(new LongRunningCallable()); final Future<Integer> future = des.submit(address(1), tb.build()); // Will unblock when LongRunningCallable starts running barrier.await(10, TimeUnit.SECONDS); future.cancel(true); boolean taskCancelled = false; try { future.get(); } catch (Exception e) { taskCancelled = e instanceof CancellationException; } assert taskCancelled : "Dist task not cancelled "; // Will unblock when LongRunningCallable is interrupted barrier.await(10, TimeUnit.SECONDS); assert future.isCancelled(); assert future.isDone(); //Testing whether the cancellation already happened. boolean isCanceled = future.cancel(true); assert !isCanceled; }
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(); } }
taskBuilder.failoverPolicy(new DistributedTaskFailoverPolicy() { DistributedTask<Integer> task = taskBuilder.build(); assert task.getTaskFailoverPolicy().maxFailoverAttempts() == 0;
public void testExceptionCallableWithTimedCallDistApi() throws Exception { DistributedExecutorService des = createDES(getCache()); DistributedTaskBuilder<Integer> taskBuilder = des.createDistributedTaskBuilder(new ExceptionThrowingCallable(latchHolder, true)); DistributedTask<Integer> distributedTask = taskBuilder.build(); Future<Integer> future = des.submit(distributedTask); expectException(TimeoutException.class, () -> future.get(10, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }
taskBuilder.failoverPolicy(new DistributedTaskFailoverPolicy() { DistributedTask<Integer> task = taskBuilder.build(); AssertJUnit.assertEquals(1, task.getTaskFailoverPolicy().maxFailoverAttempts()); Future<Integer> val = des.submit(task, "key1");
public void testBasicTargetLocalDistributedCallableWithTimeout() throws Exception { Cache<Object, Object> cache1 = getCache(); Cache<Object, Object> cache2 = cache(1, cacheName()); CyclicBarrier barrier = new CyclicBarrier(2); cache2.getAdvancedCache().getComponentRegistry().registerComponent(barrier, "barrier"); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = address(0); DistributedTaskBuilder builder = des.createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); builder.timeout(100, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); expectException(ExecutionException.class, () -> future.get()); }