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 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 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 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(); }
public void testSleepingCallableWithTimeoutExcDistApi() throws Exception { DistributedExecutorService des = createDES(getCache()); DistributedTaskBuilder<Integer> taskBuilder = des.createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); DistributedTask<Integer> distributedTask = taskBuilder.build(); Future<Integer> future = des.submit(distributedTask); log.tracef("Sleeping task submitted"); expectException(TimeoutException.class, () -> future.get(100, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }
public void testSleepingCallableWithTimeoutOption() throws Exception { DistributedExecutorService des = createDES(getCache()); Future<Integer> future = des.submit(new SleepingSimpleCallable(latchHolder)); Thread.sleep(100); latchHolder.get().open(); Integer r = future.get(10, TimeUnit.SECONDS); assertEquals((Integer) 1, r); //the same using DistributedTask API DistributedTaskBuilder<Integer> taskBuilder = des.createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); DistributedTask<Integer> distributedTask = taskBuilder.build(); future = des.submit(distributedTask); Thread.sleep(100); latchHolder.get().open(); r = future.get(10, TimeUnit.SECONDS); assertEquals((Integer) 1, r); }
public void testDistributedCallableEverywhereWithEmptyKeys() throws Exception { Cache<Object, Object> c1 = getCache(); c1.put("key1", "Manik"); c1.put("key2", "Mircea"); c1.put("key3", "Galder"); c1.put("key4", "Sanne"); DistributedExecutorService des = createDES(getCache()); List<CompletableFuture<Boolean>> list = des.submitEverywhere(new SimpleDistributedCallable(false), new String[]{}); 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, new String[]{}); assert list != null && !list.isEmpty(); for (Future<Boolean> f : list) { assert f.get(); } }
public void testBasicTargetDistributedCallableTargetSameNode() throws Exception { Cache<Object, Object> cache1 = getCache(); //initiate task from cache1 and select cache1 as target DistributedExecutorService des = createDES(cache1); Address target = cache1.getAdvancedCache().getRpcManager().getAddress(); Future<Boolean> future = des.submit(target, 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(target, distributedTask); r = future.get(); assert r; }
public void testBasicTargetLocalDistributedCallableWithoutSpecTimeout() throws Exception { Cache<Object, Object> cache1 = cache(0, cacheName()); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = cache1.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder builder = des .createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); Future<Integer> future = des.submit(target, builder.build()); Thread.sleep(100); latchHolder.get().open(); assertEquals((Integer) 1, future.get()); }
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()); }
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 testBasicDistributedCallableWitkKeys() throws Exception { Cache<Object, Object> c1 = getCache(); c1.put("key1", "Manik"); c1.put("key2", "Mircea"); c1.put("key3", "Galder"); c1.put("key4", "Sanne"); DistributedExecutorService des = createDES(getCache()); Future<Boolean> future = des.submit(new SimpleDistributedCallable(true), "key1", "key2"); Boolean r = future.get(); assert r; // the same using DistributedTask API DistributedTaskBuilder<Boolean> taskBuilder = des .createDistributedTaskBuilder(new SimpleDistributedCallable(true)); DistributedTask<Boolean> distributedTask = taskBuilder.build(); future = des.submit(distributedTask, "key1", "key2"); r = future.get(); assert r; }
public void testBasicTargetRemoteDistributedCallableWithException() throws Exception { Cache<Object, Object> cache1 = cache(0, cacheName()); Cache<Object, Object> cache2 = cache(1, cacheName()); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = cache2.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder builder = des .createDistributedTaskBuilder(new ExceptionThrowingCallable()); Future<Integer> future = des.submit(target, builder.build()); expectException(ExecutionException.class, () -> future.get()); }
public void testBasicTargetDistributedCallableWithTimeout() throws Exception { Cache<Object, Object> cache1 = getCache(); // initiate task from cache1 and select cache2 as target DistributedExecutorService des = createDES(cache1); Address target = cache1.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder<Integer> builder = des.createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); builder.timeout(10, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); expectException(ExecutionException.class, TimeoutException.class, () -> future.get()); latchHolder.get().open(); }
public void testBasicTargetDistributedCallable() throws Exception { Cache<Object, Object> cache1 = cache(0, cacheName()); Cache<Object, Object> cache2 = cache(1, cacheName()); // initiate task from cache1 and select cache2 as target DistributedExecutorService des = createDES(cache1); Address target = cache2.getAdvancedCache().getRpcManager().getAddress(); Future<Boolean> future = des.submit(target, 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(target, distributedTask); r = future.get(); assert r; }
public void testBasicTargetLocalDistributedCallableWithLowFutureAndHighTaskTimeout() throws Exception { Cache<Object, Object> cache1 = cache(0, cacheName()); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = cache1.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder builder = des .createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); builder.timeout(10000, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); expectException(TimeoutException.class, () -> future.get(100, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }
public void testBasicTargetLocalDistributedCallableWithHighFutureAndLowTaskTimeout() throws Exception { Cache<Object, Object> cache1 = cache(0, cacheName()); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = cache1.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder builder = des .createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); builder.timeout(100, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); expectException(TimeoutException.class, () -> future.get(10000, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }
public void testBasicTargetRemoteDistributedCallableWithLowFutureAndHighTaskTimeout() throws Exception { Cache<Object, Object> cache1 = cache(0, cacheName()); Cache<Object, Object> cache2 = cache(1, cacheName()); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = cache2.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder builder = des .createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); builder.timeout(10000, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); expectException(TimeoutException.class, () -> future.get(100, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }
public void testBasicTargetRemoteDistributedCallableWithHighFutureAndLowTaskTimeout() throws Exception { Cache<Object, Object> cache1 = cache(0, cacheName()); Cache<Object, Object> cache2 = cache(1, cacheName()); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = cache2.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder builder = des .createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); builder.timeout(100, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); expectException(TimeoutException.class, () -> future.get(10000, TimeUnit.MILLISECONDS)); 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(); } }