protected Cache<Object, Object> getCache() { return cache(0, cacheName()); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(getCacheMode(), false); createClusteredCaches(2, cacheName(), builder); }
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 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 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 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 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 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 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 testDistributedCallableEverywhereWithKeysOnBothNodes() throws Exception { Cache<Object, Object> c1 = getCache(); c1.put("key1", "Manik"); c1.put("key2", "Mircea"); c1.put("key3", "Galder"); c1.put("key4", "Sanne"); Cache<Object, Object> c2 = cache(1, cacheName()); c2.put("key5", "test"); c2.put("key6", "test1"); DistributedExecutorService des = createDES(getCache()); List<CompletableFuture<Boolean>> list = des.submitEverywhere(new SimpleDistributedCallable(true), "key1", "key2", "key5", "key6"); assertTrue(list != null && !list.isEmpty()); for (Future<Boolean> f : list) { assert f.get(); } // Check that the futures are distinct assertEquals(list.size(), new HashSet<>(list).size()); //the same using DistributedTask API DistributedTaskBuilder<Boolean> taskBuilder = des.createDistributedTaskBuilder(new SimpleDistributedCallable(true)); DistributedTask<Boolean> distributedTask = taskBuilder.build(); list = des.submitEverywhere(distributedTask, "key1", "key2"); assert list != null && !list.isEmpty(); for (Future<Boolean> f : list) { assert f.get(); } // Check that the futures are distinct assertEquals(list.size(), new HashSet<>(list).size()); }
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 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(); }