/** {@inheritDoc} */ @Override protected RuntimeException convertException(IgniteCheckedException e) { if (e instanceof IgniteFutureCancelledCheckedException || e instanceof IgniteInterruptedCheckedException || e instanceof IgniteFutureTimeoutCheckedException) return U.convertException(e); return CU.convertToCacheException(e); } }
/** * @param cancel {@code True} to close with cancellation. * @throws CacheException If failed. */ @Override public void close(boolean cancel) throws CacheException { try { closeEx(cancel); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } }
/** {@inheritDoc} */ @Override public R next() { try { R next = unmaskNull(internalIterator().next()); cnt.decrementAndGet(); return next; } catch (NoSuchElementException ignored) { return null; } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } }
/** * @param reconnectFut Reconnect future. * @throws IgniteCheckedException If failed. */ public void onDisconnected(IgniteFuture<?> reconnectFut) throws IgniteCheckedException { IgniteClientDisconnectedCheckedException err = new IgniteClientDisconnectedCheckedException(reconnectFut, "Data streamer has been closed, client node disconnected."); disconnectErr = (CacheException)CU.convertToCacheException(err); for (Buffer buf : bufMappings.values()) buf.cancelAll(err); closeEx(true, err); }
/** {@inheritDoc} */ @Override public void destroyCaches(Collection<String> cacheNames) { CU.validateCacheNames(cacheNames); IgniteInternalFuture stopFut = destroyCachesAsync(cacheNames, true); try { stopFut.get(); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } }
/** {@inheritDoc} */ @Override public boolean destroyCache0(String cacheName, boolean sql) throws CacheException { CU.validateCacheName(cacheName); IgniteInternalFuture<Boolean> stopFut = destroyCacheAsync(cacheName, sql, true); try { return stopFut.get(); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } }
/** {@inheritDoc} */ @Override public void flush() throws CacheException { lock(true); try { doFlush(); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } finally { unlock(true); } }
/** * @param ignite Ignite. */ public javax.cache.CacheManager findManager(Ignite ignite) { synchronized (cacheManagers) { for (Map<URI, GridFutureAdapter<CacheManager>> map : cacheManagers.values()) { for (GridFutureAdapter<CacheManager> fut : map.values()) { if (fut.isDone()) { assert !fut.isFailed(); try { CacheManager mgr = fut.get(); if (mgr.unwrap(Ignite.class) == ignite) return mgr; } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } } } } } return null; }
/** * @param mgr Manager. */ protected void removeClosedManager(CacheManager mgr) { synchronized (cacheManagers) { Map<URI, GridFutureAdapter<CacheManager>> uriMap = cacheManagers.get(mgr.getClassLoader()); GridFutureAdapter<CacheManager> fut = uriMap.get(mgr.getURI()); if (fut != null && fut.isDone() && !fut.isFailed()) { try { CacheManager cachedManager = fut.get(); if (cachedManager == mgr) uriMap.remove(mgr.getURI()); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } } } }
/** {@inheritDoc} */ @Override public <K, V> IgniteCache<K, V> cache(String name) { CU.validateCacheName(name); guard(); try { checkClusterState(); return ctx.cache().publicJCache(name, false, true); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public Collection<IgniteCache> getOrCreateCaches(Collection<CacheConfiguration> cacheCfgs) { A.notNull(cacheCfgs, "cacheCfgs"); CU.validateConfigurationCacheNames(cacheCfgs); guard(); try { checkClusterState(); ctx.cache().dynamicStartCaches(cacheCfgs, false, true, false).get(); List<IgniteCache> createdCaches = new ArrayList<>(cacheCfgs.size()); for (CacheConfiguration cacheCfg : cacheCfgs) createdCaches.add(ctx.cache().publicJCache(cacheCfg.getName())); return createdCaches; } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public Collection<IgniteCache> createCaches(Collection<CacheConfiguration> cacheCfgs) { A.notNull(cacheCfgs, "cacheCfgs"); CU.validateConfigurationCacheNames(cacheCfgs); guard(); try { checkClusterState(); ctx.cache().dynamicStartCaches(cacheCfgs, true, true, false).get(); List<IgniteCache> createdCaches = new ArrayList<>(cacheCfgs.size()); for (CacheConfiguration cacheCfg : cacheCfgs) createdCaches.add(ctx.cache().publicJCache(cacheCfg.getName())); return createdCaches; } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } finally { unguard(); } }
@Nullable @Override public <K, V> V put(String cacheName, K key, V val, long ttl) { try { if (ttl > 0) { ExpiryPolicy plc = new TouchedExpiryPolicy(new Duration(MILLISECONDS, ttl)); IgniteCache<K, V> cache = ctx.cache().<K, V>publicJCache(cacheName).withExpiryPolicy(plc); return cache.getAndPut(key, val); } else return ctx.cache().<K, V>jcache(cacheName).getAndPut(key, val); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } }
@Nullable @Override public <K, V> V putIfAbsent(String cacheName, K key, V val, long ttl) { try { if (ttl > 0) { ExpiryPolicy plc = new TouchedExpiryPolicy(new Duration(MILLISECONDS, ttl)); IgniteCache<K, V> cache = ctx.cache().<K, V>publicJCache(cacheName).withExpiryPolicy(plc); return cache.getAndPutIfAbsent(key, val); } else return ctx.cache().<K, V>jcache(cacheName).getAndPutIfAbsent(key, val); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } }
/** {@inheritDoc} */ @Override public <K, V> void addCacheConfiguration(CacheConfiguration<K, V> cacheCfg) { A.notNull(cacheCfg, "cacheCfg"); CU.validateNewCacheName(cacheCfg.getName()); guard(); try { checkClusterState(); ctx.cache().addCacheConfiguration(cacheCfg); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <K, V> IgniteCache<K, V> createCache(String cacheName) { CU.validateNewCacheName(cacheName); guard(); try { checkClusterState(); ctx.cache().createFromTemplate(cacheName).get(); return ctx.cache().publicJCache(cacheName); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <K, V> IgniteCache<K, V> getOrCreateCache(String cacheName) { CU.validateNewCacheName(cacheName); guard(); try { checkClusterState(); IgniteCacheProxy<K, V> cache = ctx.cache().publicJCache(cacheName, false, true); if (cache == null) { ctx.cache().getOrCreateFromTemplate(cacheName, true).get(); return ctx.cache().publicJCache(cacheName); } return cache; } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <K, V> IgniteCache<K, V> createNearCache(String cacheName, NearCacheConfiguration<K, V> nearCfg) { CU.validateNewCacheName(cacheName); A.notNull(nearCfg, "nearCfg"); guard(); try { checkClusterState(); ctx.cache().dynamicStartCache(null, cacheName, nearCfg, true, true, true).get(); IgniteCacheProxy<K, V> cache = ctx.cache().publicJCache(cacheName); checkNearCacheStarted(cache); return cache; } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <K, V> IgniteCache<K, V> createCache(CacheConfiguration<K, V> cacheCfg) { A.notNull(cacheCfg, "cacheCfg"); CU.validateNewCacheName(cacheCfg.getName()); guard(); try { checkClusterState(); ctx.cache().dynamicStartCache(cacheCfg, cacheCfg.getName(), null, true, true, true).get(); return ctx.cache().publicJCache(cacheCfg.getName()); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <K, V> IgniteCache<K, V> createCache( CacheConfiguration<K, V> cacheCfg, NearCacheConfiguration<K, V> nearCfg ) { A.notNull(cacheCfg, "cacheCfg"); CU.validateNewCacheName(cacheCfg.getName()); A.notNull(nearCfg, "nearCfg"); guard(); try { checkClusterState(); ctx.cache().dynamicStartCache(cacheCfg, cacheCfg.getName(), nearCfg, true, true, true).get(); return ctx.cache().publicJCache(cacheCfg.getName()); } catch (IgniteCheckedException e) { throw CU.convertToCacheException(e); } finally { unguard(); } }