/** {@inheritDoc} */ @Override public boolean isRebalanceEnabled() { return ctx.cache().context().isRebalanceEnabled(); }
/** {@inheritDoc} */ @Override public void rebalanceEnabled(boolean rebalanceEnabled) { ctx.cache().context().rebalanceEnabled(rebalanceEnabled); }
/** * USED ONLY FOR TESTING. * * @param name Cache name. * @param <K> Key type. * @param <V> Value type. * @return Internal cache instance. */ /*@java.test.only*/ public <K, V> GridCacheAdapter<K, V> internalCache(String name) { CU.validateCacheName(name); checkClusterState(); return ctx.cache().internalCache(name); }
/** {@inheritDoc} */ @Nullable @Override public DataRegionMetrics dataRegionMetrics(String memPlcName) { guard(); try { return ctx.cache().context().database().memoryMetrics(memPlcName); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <K extends GridCacheUtilityKey, V> IgniteInternalCache<K, V> utilityCache() { guard(); try { checkClusterState(); return ctx.cache().utilityCache(); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public IgniteTransactions transactions() { guard(); try { checkClusterState(); return ctx.cache().transactions(); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public Collection<String> cacheNames() { guard(); try { checkClusterState(); return ctx.cache().publicCacheNames(); } finally { unguard(); } }
/** * @return Public caches. */ public Collection<IgniteCacheProxy<?, ?>> caches() { guard(); try { checkClusterState(); return ctx.cache().publicCaches(); } 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 Collection<IgniteInternalCache<?, ?>> cachesx( IgnitePredicate<? super IgniteInternalCache<?, ?>>[] p) { guard(); try { checkClusterState(); return F.retain(ctx.cache().caches(), true, p); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public DataStorageMetrics dataStorageMetrics() { guard(); try { return ctx.cache().context().database().persistentStoreMetrics(); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public Collection<DataRegionMetrics> dataRegionMetrics() { guard(); try { return ctx.cache().context().database().memoryMetrics(); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <K, V> IgniteInternalCache<K, V> cachex(String name) { CU.validateCacheName(name); guard(); try { checkClusterState(); return ctx.cache().cache(name); } finally { unguard(); } }
/** * @param name Cache name. * @return Cache. */ public <K, V> IgniteInternalCache<K, V> getCache(String name) { CU.validateCacheName(name); guard(); try { checkClusterState(); return ctx.cache().publicCache(name); } finally { unguard(); } }
/** * @param cacheNames Collection of cache names. * @param checkThreadTx If {@code true} checks that current thread does not have active transactions. * @return Ignite future. */ public IgniteInternalFuture<?> destroyCachesAsync(Collection<String> cacheNames, boolean checkThreadTx) { CU.validateCacheNames(cacheNames); guard(); try { checkClusterState(); return ctx.cache().dynamicDestroyCaches(cacheNames, checkThreadTx); } finally { unguard(); } }
@Override public <K> Affinity<K> affinity(String cacheName) { CU.validateCacheName(cacheName); checkClusterState(); GridCacheAdapter<K, ?> cache = ctx.cache().internalCache(cacheName); if (cache != null) return cache.affinity(); return ctx.affinity().affinityProxy(cacheName); }
/** * @param cacheName Cache name. * @param sql If the cache needs to be destroyed only if it was created by SQL {@code CREATE TABLE} command. * @param checkThreadTx If {@code true} checks that current thread does not have active transactions. * @return Ignite future. */ public IgniteInternalFuture<Boolean> destroyCacheAsync(String cacheName, boolean sql, boolean checkThreadTx) { CU.validateCacheName(cacheName); guard(); try { checkClusterState(); return ctx.cache().dynamicDestroyCache(cacheName, sql, checkThreadTx, false, null); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public void resetLostPartitions(Collection<String> cacheNames) { CU.validateCacheNames(cacheNames); guard(); try { ctx.cache().resetCacheState(cacheNames).get(); } catch (IgniteCheckedException e) { throw U.convertException(e); } finally { unguard(); } }
/** {@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 <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(); } }