Re: cache.getAsync() blocks if cluster is not activated.

[Andrei Aleksandrov]

Hi,

I don't think that it should hang because there are no cache operations 
allowed when the cluster isn't activated. It should be some kind of 
CacheExcdption.

Is it possible to prepare some reproducer or unit test? Otherwise please 
provide some details:

1)What Ignite version was used?
2)Can you please share a server and cache configuration?

BR,
Andrei
7/15/2020 9:57 PM, John Smith пишет:
Hi, testing some failover scenarios etc...

When we call cache.getAsync() and the state of the cluster is not 
active. It seems to block.

I implemented a cache repository as follows and using Vertx.io. It 
seems to block at the cacheOperation.apply(cache)

So when I call myRepo.get(myKey) which underneath applies the 
cache.getAsync() function it blocks.

public class IgniteCacheRepository<K,V> implements CacheRepository<K,V> {
     public final long DEFAULT_OPERATION_TIMEOUT =1000; private final 
TimeUnitDEFAULT_TIMEOUT_UNIT = TimeUnit.MILLISECONDS; private Vertxvertx; private 
IgniteCache<K, V> cache; public IgniteCacheRepository(Vertx vertx, IgniteCache<K, 
V> cache) {
         this.vertx = vertx; this.cache = cache; }

     @Override public Future<Void>put(K key, V value) {
         return executeAsync(cache -> cache.putAsync(key, value), 
DEFAULT_OPERATION_TIMEOUT, DEFAULT_TIMEOUT_UNIT); }

     @Override public Future<V> get(K key) {
         return executeAsync(cache -> cache.getAsync(key), 
DEFAULT_OPERATION_TIMEOUT, DEFAULT_TIMEOUT_UNIT); }

     @Override public <T> Future<T> invoke(K key, EntryProcessor<K, V, T> 
processor, Object... arguments) {
         return executeAsync(cache -> cache.invokeAsync(key, processor, 
arguments), DEFAULT_OPERATION_TIMEOUT, DEFAULT_TIMEOUT_UNIT); }

     @Override public <T> T cache() {
         return (T)cache; }

     /** * Adapt Ignite async operation to vertx futures. * * @param 
cacheOperation The ignite operation to execute async. * @return The 
value from the cache operation. */ private <T> Future<T> executeAsync(Function<IgniteCache<K, V>, IgniteFuture<T>> cacheOperation, long timeout, TimeUnit unit) {
         Future<T> future = Future.future(); try {
             IgniteFuture<T> value = cacheOperation.apply(cache); 
value.listenAsync(result -> {
                 try {
                     future.complete(result.get(timeout, unit)); 
}catch(Exception ex) {
                     future.fail(ex); }
             }, 
VertxIgniteExecutorAdapter.getOrCreate(vertx.getOrCreateContext())); 
}catch(Exception ex) {
             // Catch some RuntimeException that can be thrown by Ignite cache. 
future.fail(ex); }

         return future; }
}