You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by sb...@apache.org on 2015/01/16 13:11:38 UTC
[12/13] incubator-ignite git commit: ignite-42
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/CacheConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheConfiguration.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheConfiguration.java
index 1d4fdb4..cc51e9b 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/CacheConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheConfiguration.java
@@ -17,15 +17,1705 @@
package org.apache.ignite.cache;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.cache.store.*;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.portables.PortableObject;
+import org.apache.ignite.spi.indexing.*;
+import org.gridgain.grid.cache.*;
+import org.gridgain.grid.cache.affinity.*;
+import org.gridgain.grid.cache.affinity.consistenthash.*;
+import org.gridgain.grid.cache.cloner.*;
+import org.gridgain.grid.cache.datastructures.*;
+import org.gridgain.grid.cache.eviction.*;
+import org.gridgain.grid.cache.query.*;
+import org.gridgain.grid.util.typedef.internal.*;
+import org.jetbrains.annotations.*;
+
import javax.cache.configuration.*;
+import java.util.*;
/**
- * TODO: Add class description.
- *
- * @author @java.author
- * @version @java.version
+ * This class defines grid cache configuration. This configuration is passed to
+ * grid via {@link IgniteConfiguration#getCacheConfiguration()} method. It defines all configuration
+ * parameters required to start a cache within grid instance. You can have multiple caches
+ * configured with different names within one grid.
+ * <p>
+ * Cache configuration is set on {@link
+ * IgniteConfiguration#setCacheConfiguration(CacheConfiguration...)} method. This adapter is a simple bean and
+ * can be configured from Spring XML files (or other DI frameworks). <p> Note that absolutely all configuration
+ * properties are optional, so users should only change what they need.
*/
-// TODO: remove 'abstract'
-public abstract class CacheConfiguration<K, V> implements Configuration<K, V> {
+@SuppressWarnings("RedundantFieldInitialization")
+public class CacheConfiguration extends MutableConfiguration {
+ /** Default atomic sequence reservation size. */
+ public static final int DFLT_ATOMIC_SEQUENCE_RESERVE_SIZE = 1000;
+
+ /** Default size of preload thread pool. */
+ public static final int DFLT_PRELOAD_THREAD_POOL_SIZE = 2;
+
+ /** Default preload timeout (ms).*/
+ public static final long DFLT_PRELOAD_TIMEOUT = 10000;
+
+ /** Time in milliseconds to wait between preload messages to avoid overloading CPU. */
+ public static final long DFLT_PRELOAD_THROTTLE = 0;
+
+ /**
+ * Default time to live. The value is <tt>0</tt> which means that
+ * cached objects never expire based on time.
+ */
+ public static final long DFLT_TIME_TO_LIVE = 0;
+
+ /** Default number of backups. */
+ public static final int DFLT_BACKUPS = 0;
+
+ /** Default caching mode. */
+ public static final GridCacheMode DFLT_CACHE_MODE = GridCacheMode.REPLICATED;
+
+ /** Default atomicity mode. */
+ public static final GridCacheAtomicityMode DFLT_CACHE_ATOMICITY_MODE = GridCacheAtomicityMode.ATOMIC;
+
+ /** Default value for cache distribution mode. */
+ public static final GridCacheDistributionMode DFLT_DISTRIBUTION_MODE = GridCacheDistributionMode.PARTITIONED_ONLY;
+
+ /** Default query timeout. */
+ public static final long DFLT_QUERY_TIMEOUT = 0;
+
+ /** Default lock timeout. */
+ public static final long DFLT_LOCK_TIMEOUT = 0;
+
+ /** Initial default cache size. */
+ public static final int DFLT_START_SIZE = 1500000;
+
+ /** Default cache size to use with eviction policy. */
+ public static final int DFLT_CACHE_SIZE = 100000;
+
+ /** Initial default near cache size. */
+ public static final int DFLT_NEAR_START_SIZE = DFLT_START_SIZE / 4;
+
+ /** Default value for 'invalidate' flag that indicates if this is invalidation-based cache. */
+ public static final boolean DFLT_INVALIDATE = false;
+
+ /** Default value for 'storeValueBytes' flag indicating if value bytes should be stored. */
+ public static final boolean DFLT_STORE_VALUE_BYTES = true;
+
+ /** Default preload mode for distributed cache. */
+ public static final GridCachePreloadMode DFLT_PRELOAD_MODE = GridCachePreloadMode.ASYNC;
+
+ /** Default preload batch size in bytes. */
+ public static final int DFLT_PRELOAD_BATCH_SIZE = 512 * 1024; // 512K
+
+ /** Default maximum eviction queue ratio. */
+ public static final float DFLT_MAX_EVICTION_OVERFLOW_RATIO = 10;
+
+ /** Default eviction synchronized flag. */
+ public static final boolean DFLT_EVICT_SYNCHRONIZED = false;
+
+ /** Default near nodes eviction synchronized flag. */
+ public static final boolean DFLT_EVICT_NEAR_SYNCHRONIZED = true;
+
+ /** Default eviction key buffer size for batching synchronized evicts. */
+ public static final int DFLT_EVICT_KEY_BUFFER_SIZE = 1024;
+
+ /** Default synchronous eviction timeout in milliseconds. */
+ public static final long DFLT_EVICT_SYNCHRONIZED_TIMEOUT = 10000;
+
+ /** Default synchronous eviction concurrency level. */
+ public static final int DFLT_EVICT_SYNCHRONIZED_CONCURRENCY_LEVEL = 4;
+
+ /** Default value for eager ttl flag. */
+ public static final boolean DFLT_EAGER_TTL = true;
+
+ /** Default off-heap storage size is {@code -1} which means that off-heap storage is disabled. */
+ public static final long DFLT_OFFHEAP_MEMORY = -1;
+
+ /** Default value for 'swapEnabled' flag. */
+ public static final boolean DFLT_SWAP_ENABLED = false;
+
+ /** Default value for 'maxConcurrentAsyncOps'. */
+ public static final int DFLT_MAX_CONCURRENT_ASYNC_OPS = 500;
+
+ /** Default value for 'queryIndexEnabled' flag. */
+ public static final boolean DFLT_QUERY_INDEX_ENABLED = false;
+
+ /** Default value for 'writeBehindEnabled' flag. */
+ public static final boolean DFLT_WRITE_BEHIND_ENABLED = false;
+
+ /** Default flush size for write-behind cache store. */
+ public static final int DFLT_WRITE_BEHIND_FLUSH_SIZE = 10240; // 10K
+
+ /** Default critical size used when flush size is not specified. */
+ public static final int DFLT_WRITE_BEHIND_CRITICAL_SIZE = 16384; // 16K
+
+ /** Default flush frequency for write-behind cache store in milliseconds. */
+ public static final long DFLT_WRITE_BEHIND_FLUSH_FREQUENCY = 5000;
+
+ /** Default count of flush threads for write-behind cache store. */
+ public static final int DFLT_WRITE_FROM_BEHIND_FLUSH_THREAD_CNT = 1;
+
+ /** Default batch size for write-behind cache store. */
+ public static final int DFLT_WRITE_BEHIND_BATCH_SIZE = 512;
+
+ /** Default maximum number of query iterators that can be stored. */
+ public static final int DFLT_MAX_QUERY_ITERATOR_CNT = 1024;
+
+ /** Default continuous query buffers queue size. */
+ @SuppressWarnings("UnusedDeclaration")
+ @Deprecated
+ public static final int DFLT_CONT_QUERY_QUEUE_SIZE = 1024 * 1024;
+
+ /** Default memory mode. */
+ public static final GridCacheMemoryMode DFLT_MEMORY_MODE = GridCacheMemoryMode.ONHEAP_TIERED;
+
+ /** Default continuous query max buffer size. */
+ @SuppressWarnings("UnusedDeclaration")
+ @Deprecated
+ public static final int DFLT_CONT_QUERY_MAX_BUF_SIZE = 1024;
+
+ /** Cache name. */
+ private String name;
+
+ /** Default batch size for all cache's sequences. */
+ private int seqReserveSize = DFLT_ATOMIC_SEQUENCE_RESERVE_SIZE;
+
+ /** Preload thread pool size. */
+ private int preloadPoolSize = DFLT_PRELOAD_THREAD_POOL_SIZE;
+
+ /** Preload timeout. */
+ private long preloadTimeout = DFLT_PRELOAD_TIMEOUT;
+
+ /** Default time to live for cache entries. */
+ private long ttl = DFLT_TIME_TO_LIVE;
+
+ /** Cache expiration policy. */
+ private GridCacheEvictionPolicy evictPlc;
+
+ /** Near cache eviction policy. */
+ private GridCacheEvictionPolicy nearEvictPlc;
+
+ /** Flag indicating whether eviction is synchronized. */
+ private boolean evictSync = DFLT_EVICT_SYNCHRONIZED;
+
+ /** Flag indicating whether eviction is synchronized with near nodes. */
+ private boolean evictNearSync = DFLT_EVICT_NEAR_SYNCHRONIZED;
+
+ /** Eviction key buffer size. */
+ private int evictKeyBufSize = DFLT_EVICT_KEY_BUFFER_SIZE;
+
+ /** Synchronous eviction timeout. */
+ private int evictSyncConcurrencyLvl = DFLT_EVICT_SYNCHRONIZED_CONCURRENCY_LEVEL;
+
+ /** Synchronous eviction timeout. */
+ private long evictSyncTimeout = DFLT_EVICT_SYNCHRONIZED_TIMEOUT;
+
+ /** Eviction filter. */
+ private GridCacheEvictionFilter<?, ?> evictFilter;
+
+ /** Maximum eviction overflow ratio. */
+ private float evictMaxOverflowRatio = DFLT_MAX_EVICTION_OVERFLOW_RATIO;
+
+ /** Eager ttl flag. */
+ private boolean eagerTtl = DFLT_EAGER_TTL;
+
+ /** Default lock timeout. */
+ private long dfltLockTimeout = DFLT_LOCK_TIMEOUT;
+
+ /** Default query timeout. */
+ private long dfltQryTimeout = DFLT_QUERY_TIMEOUT;
+
+ /** Default cache start size. */
+ private int startSize = DFLT_START_SIZE;
+
+ /** Default near cache start size. */
+ private int nearStartSize = DFLT_NEAR_START_SIZE;
+
+ /** Cache distribution mode. */
+ private GridCacheDistributionMode distro = DFLT_DISTRIBUTION_MODE;
+
+ /** Write synchronization mode. */
+ private GridCacheWriteSynchronizationMode writeSync;
+
+ /** */
+ private CacheStore<?, ?> store;
+
+ /** Node group resolver. */
+ private GridCacheAffinityFunction aff;
+
+ /** Cache mode. */
+ private GridCacheMode cacheMode = DFLT_CACHE_MODE;
+
+ /** Cache atomicity mode. */
+ private GridCacheAtomicityMode atomicityMode;
+
+ /** Write ordering mode. */
+ private GridCacheAtomicWriteOrderMode atomicWriteOrderMode;
+
+ /** Number of backups for cache. */
+ private int backups = DFLT_BACKUPS;
+
+ /** Flag indicating whether this is invalidation-based cache. */
+ private boolean invalidate = DFLT_INVALIDATE;
+
+ /** Flag indicating if cached values should be additionally stored in serialized form. */
+ private boolean storeValBytes = DFLT_STORE_VALUE_BYTES;
+
+ /** Name of class implementing GridCacheTmLookup. */
+ private String tmLookupClsName;
+
+ /** Distributed cache preload mode. */
+ private GridCachePreloadMode preloadMode = DFLT_PRELOAD_MODE;
+
+ /** Cache preload order. */
+ private int preloadOrder;
+
+ /** Preload batch size. */
+ private int preloadBatchSize = DFLT_PRELOAD_BATCH_SIZE;
+
+ /** Off-heap memory size. */
+ private long offHeapMaxMem = DFLT_OFFHEAP_MEMORY;
+
+ /** */
+ private boolean swapEnabled = DFLT_SWAP_ENABLED;
+
+ /** Maximum number of concurrent asynchronous operations. */
+ private int maxConcurrentAsyncOps = DFLT_MAX_CONCURRENT_ASYNC_OPS;
+
+ /** */
+ private boolean qryIdxEnabled = DFLT_QUERY_INDEX_ENABLED;
+
+ /** Write-behind feature. */
+ private boolean writeBehindEnabled = DFLT_WRITE_BEHIND_ENABLED;
+
+ /** Maximum size of write-behind cache. */
+ private int writeBehindFlushSize = DFLT_WRITE_BEHIND_FLUSH_SIZE;
+
+ /** Write-behind flush frequency in milliseconds. */
+ private long writeBehindFlushFreq = DFLT_WRITE_BEHIND_FLUSH_FREQUENCY;
+
+ /** Flush thread count for write-behind cache store. */
+ private int writeBehindFlushThreadCnt = DFLT_WRITE_FROM_BEHIND_FLUSH_THREAD_CNT;
+
+ /** Maximum batch size for write-behind cache store. */
+ private int writeBehindBatchSize = DFLT_WRITE_BEHIND_BATCH_SIZE;
+
+ /** Maximum number of query iterators that can be stored. */
+ private int maxQryIterCnt = DFLT_MAX_QUERY_ITERATOR_CNT;
+
+ /** Memory mode. */
+ private GridCacheMemoryMode memMode = DFLT_MEMORY_MODE;
+
+ /** */
+ private GridCacheCloner cloner;
+
+ /** */
+ private GridCacheAffinityKeyMapper affMapper;
+
+ /** */
+ private String indexingSpiName;
+
+ /** */
+ private long preloadDelay;
+
+ /** */
+ private long preloadThrottle = DFLT_PRELOAD_THROTTLE;
+
+ /** */
+ private GridCacheInterceptor<?, ?> interceptor;
+
+ /** */
+ private boolean portableEnabled;
+
+ /** */
+ private boolean keepPortableInStore = true;
+
+ /** Query configuration. */
+ private GridCacheQueryConfiguration qryCfg;
+
+ /** Empty constructor (all values are initialized to their defaults). */
+ public CacheConfiguration() {
+ /* No-op. */
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param cfg Configuration to copy.
+ */
+ public CacheConfiguration(CompleteConfiguration cfg) {
+ super(cfg);
+
+ if (!(cfg instanceof CacheConfiguration))
+ return;
+
+ CacheConfiguration cc = (CacheConfiguration)cfg;
+
+ /*
+ * NOTE: MAKE SURE TO PRESERVE ALPHABETIC ORDER!
+ * ==============================================
+ */
+ aff = cc.getAffinity();
+ affMapper = cc.getAffinityMapper();
+ atomicityMode = cc.getAtomicityMode();
+ atomicWriteOrderMode = cc.getAtomicWriteOrderMode();
+ backups = cc.getBackups();
+ cacheLoaderFactory = cc.getCacheLoaderFactory();
+ cacheMode = cc.getCacheMode();
+ cacheWriterFactory = cc.getCacheWriterFactory();
+ cloner = cc.getCloner();
+ dfltLockTimeout = cc.getDefaultLockTimeout();
+ dfltQryTimeout = cc.getDefaultQueryTimeout();
+ distro = cc.getDistributionMode();
+ eagerTtl = cc.isEagerTtl();
+ evictFilter = cc.getEvictionFilter();
+ evictKeyBufSize = cc.getEvictSynchronizedKeyBufferSize();
+ evictMaxOverflowRatio = cc.getEvictMaxOverflowRatio();
+ evictNearSync = cc.isEvictNearSynchronized();
+ evictPlc = cc.getEvictionPolicy();
+ evictSync = cc.isEvictSynchronized();
+ evictSyncConcurrencyLvl = cc.getEvictSynchronizedConcurrencyLevel();
+ evictSyncTimeout = cc.getEvictSynchronizedTimeout();
+ expiryPolicyFactory = cc.getExpiryPolicyFactory();
+ indexingSpiName = cc.getIndexingSpiName();
+ interceptor = cc.getInterceptor();
+ invalidate = cc.isInvalidate();
+ isReadThrough = cc.isReadThrough();
+ isWriteThrough = cc.isWriteThrough();
+ keepPortableInStore = cc.isKeepPortableInStore();
+ offHeapMaxMem = cc.getOffHeapMaxMemory();
+ maxConcurrentAsyncOps = cc.getMaxConcurrentAsyncOperations();
+ maxQryIterCnt = cc.getMaximumQueryIteratorCount();
+ memMode = cc.getMemoryMode();
+ name = cc.getName();
+ nearStartSize = cc.getNearStartSize();
+ nearEvictPlc = cc.getNearEvictionPolicy();
+ portableEnabled = cc.isPortableEnabled();
+ preloadMode = cc.getPreloadMode();
+ preloadBatchSize = cc.getPreloadBatchSize();
+ preloadDelay = cc.getPreloadPartitionedDelay();
+ preloadOrder = cc.getPreloadOrder();
+ preloadPoolSize = cc.getPreloadThreadPoolSize();
+ preloadTimeout = cc.getPreloadTimeout();
+ preloadThrottle = cc.getPreloadThrottle();
+ qryCfg = cc.getQueryConfiguration();
+ qryIdxEnabled = cc.isQueryIndexEnabled();
+ seqReserveSize = cc.getAtomicSequenceReserveSize();
+ startSize = cc.getStartSize();
+ store = cc.getStore();
+ storeValBytes = cc.isStoreValueBytes();
+ swapEnabled = cc.isSwapEnabled();
+ tmLookupClsName = cc.getTransactionManagerLookupClassName();
+ ttl = cc.getDefaultTimeToLive();
+ writeBehindBatchSize = cc.getWriteBehindBatchSize();
+ writeBehindEnabled = cc.isWriteBehindEnabled();
+ writeBehindFlushFreq = cc.getWriteBehindFlushFrequency();
+ writeBehindFlushSize = cc.getWriteBehindFlushSize();
+ writeBehindFlushThreadCnt = cc.getWriteBehindFlushThreadCount();
+ writeSync = cc.getWriteSynchronizationMode();
+ }
+
+ /**
+ * Cache name. If not provided or {@code null}, then this will be considered a default
+ * cache which can be accessed via {@link Ignite#cache(String) Grid.cache(null)} method. Otherwise, if name
+ * is provided, the cache will be accessed via {@link Ignite#cache(String)} method.
+ *
+ * @return Cache name.
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * Sets cache name.
+ *
+ * @param name Cache name. May be <tt>null</tt>, but may not be empty string.
+ */
+ public void setName(String name) {
+ A.ensure(name == null || !name.isEmpty(), "Name cannot be null or empty.");
+
+ this.name = name;
+ }
+
+ /**
+ * Gets time to live for all objects in cache. This value can be overridden for individual objects.
+ * If not set, then value is {@code 0} which means that objects never expire.
+ *
+ * @return Time to live for all objects in cache.
+ */
+ public long getDefaultTimeToLive() {
+ return ttl;
+ }
+
+ /**
+ * Sets time to live for all objects in cache. This value can be override for individual objects.
+ *
+ * @param ttl Time to live for all objects in cache.
+ */
+ public void setDefaultTimeToLive(long ttl) {
+ this.ttl = ttl;
+ }
+
+ /**
+ * Gets cache eviction policy. By default, returns {@code null}
+ * which means that evictions are disabled for cache.
+ *
+ * @return Cache eviction policy or {@code null} if evictions should be disabled.
+ */
+ @SuppressWarnings({"unchecked"})
+ @Nullable public <K, V> GridCacheEvictionPolicy<K, V> getEvictionPolicy() {
+ return evictPlc;
+ }
+
+ /**
+ * Sets cache eviction policy.
+ *
+ * @param evictPlc Cache expiration policy.
+ */
+ public void setEvictionPolicy(@Nullable GridCacheEvictionPolicy evictPlc) {
+ this.evictPlc = evictPlc;
+ }
+
+ /**
+ * Gets cache distribution mode. This parameter is taken into account only if
+ * {@link #getCacheMode()} is set to {@link GridCacheMode#PARTITIONED} or {@link GridCacheMode#REPLICATED} mode.
+ * <p>
+ * If not set, default value is {@link #DFLT_DISTRIBUTION_MODE}.
+ *
+ * @return Cache distribution mode.
+ */
+ public GridCacheDistributionMode getDistributionMode() {
+ return distro;
+ }
+
+ /**
+ * Sets cache distribution mode.
+ *
+ * @param distro Distribution mode.
+ */
+ public void setDistributionMode(GridCacheDistributionMode distro) {
+ this.distro = distro;
+ }
+
+ /**
+ * Gets write synchronization mode. This mode controls whether the main
+ * caller should wait for update on other nodes to complete or not.
+ *
+ * @return Write synchronization mode.
+ */
+ public GridCacheWriteSynchronizationMode getWriteSynchronizationMode() {
+ return writeSync;
+ }
+
+ /**
+ * Sets write synchronization mode.
+ *
+ * @param writeSync Write synchronization mode.
+ */
+ public void setWriteSynchronizationMode(GridCacheWriteSynchronizationMode writeSync) {
+ this.writeSync = writeSync;
+ }
+
+ /**
+ * Gets eviction policy for {@code near} cache which is different from the one used for
+ * {@code partitioned} cache. By default, returns {@code null}
+ * which means that evictions are disabled for near cache.
+ *
+ * @return Cache eviction policy or {@code null} if evictions should be disabled.
+ */
+ @SuppressWarnings({"unchecked"})
+ @Nullable public <K, V> GridCacheEvictionPolicy<K, V> getNearEvictionPolicy() {
+ return nearEvictPlc;
+ }
+
+ /**
+ * Sets eviction policy for near cache. This property is only used for {@link GridCacheMode#PARTITIONED} caching
+ * mode.
+ *
+ * @param nearEvictPlc Eviction policy for near cache.
+ */
+ public void setNearEvictionPolicy(@Nullable GridCacheEvictionPolicy nearEvictPlc) {
+ this.nearEvictPlc = nearEvictPlc;
+ }
+
+ /**
+ * Gets flag indicating whether eviction is synchronized between primary and
+ * backup nodes on partitioned cache. If this parameter is {@code true} and
+ * swap is disabled then {@link GridCacheProjection#evict(Object)}
+ * and all its variations will involve all nodes where an entry is kept -
+ * this is a group of nodes responsible for partition to which
+ * corresponding key belongs. If this property is set to {@code false} then
+ * eviction is done independently on cache nodes.
+ * <p>
+ * Default value is defined by {@link #DFLT_EVICT_SYNCHRONIZED}.
+ * <p>
+ * Note that it's not recommended to set this value to {@code true} if cache
+ * store is configured since it will allow to significantly improve cache
+ * performance.
+ *
+ * @return {@code true} If eviction is synchronized with backup nodes (or the
+ * rest of the nodes in case of replicated cache), {@code false} if not.
+ */
+ public boolean isEvictSynchronized() {
+ return evictSync;
+ }
+
+ /**
+ * Sets flag indicating whether eviction is synchronized with backup nodes (or the rest of the nodes for replicated
+ * cache).
+ *
+ * @param evictSync {@code true} if synchronized, {@code false} if not.
+ */
+ public void setEvictSynchronized(boolean evictSync) {
+ this.evictSync = evictSync;
+ }
+
+ /**
+ * Sets flag indicating whether eviction is synchronized with near nodes.
+ *
+ * @param evictNearSync {@code true} if synchronized, {@code false} if not.
+ */
+ public void setEvictNearSynchronized(boolean evictNearSync) {
+ this.evictNearSync = evictNearSync;
+ }
+
+ /**
+ * Gets flag indicating whether eviction on primary node is synchronized with
+ * near nodes where entry is kept. Default value is {@code true} and
+ * is defined by {@link #DFLT_EVICT_NEAR_SYNCHRONIZED}.
+ * <p>
+ * Note that in most cases this property should be set to {@code true} to keep
+ * cache consistency. But there may be the cases when user may use some
+ * special near eviction policy to have desired control over near cache
+ * entry set.
+ *
+ * @return {@code true} If eviction is synchronized with near nodes in
+ * partitioned cache, {@code false} if not.
+ */
+ public boolean isEvictNearSynchronized() {
+ return evictNearSync;
+ }
+
+ /**
+ * Gets size of the key buffer for synchronized evictions.
+ * <p>
+ * Default value is defined by {@link #DFLT_EVICT_KEY_BUFFER_SIZE}.
+ *
+ * @return Eviction key buffer size.
+ */
+ public int getEvictSynchronizedKeyBufferSize() {
+ return evictKeyBufSize;
+ }
+
+ /**
+ * Sets eviction key buffer size.
+ *
+ * @param evictKeyBufSize Eviction key buffer size.
+ */
+ public void setEvictSynchronizedKeyBufferSize(int evictKeyBufSize) {
+ this.evictKeyBufSize = evictKeyBufSize;
+ }
+
+ /**
+ * Gets concurrency level for synchronized evictions. This flag only makes sense
+ * with {@link #isEvictNearSynchronized()} or {@link #isEvictSynchronized()} set
+ * to {@code true}. When synchronized evictions are enabled, it is possible that
+ * local eviction policy will try to evict entries faster than evictions can be
+ * synchronized with backup or near nodes. This value specifies how many concurrent
+ * synchronous eviction sessions should be allowed before the system is forced to
+ * wait and let synchronous evictions catch up with the eviction policy.
+ * <p>
+ * Note that if synchronous evictions start lagging, it is possible that you have either
+ * too big or too small eviction key buffer size or small eviction timeout. In that case
+ * you will need to adjust {@link #getEvictSynchronizedKeyBufferSize} or
+ * {@link #getEvictSynchronizedTimeout()} values as well.
+ * <p>
+ * Default value is defined by {@link #DFLT_EVICT_SYNCHRONIZED_CONCURRENCY_LEVEL}.
+ *
+ * @return Synchronous eviction concurrency level.
+ */
+ public int getEvictSynchronizedConcurrencyLevel() {
+ return evictSyncConcurrencyLvl;
+ }
+
+ /**
+ * Sets concurrency level for synchronized evictions.
+ *
+ * @param evictSyncConcurrencyLvl Concurrency level for synchronized evictions.
+ */
+ public void setEvictSynchronizedConcurrencyLevel(int evictSyncConcurrencyLvl) {
+ this.evictSyncConcurrencyLvl = evictSyncConcurrencyLvl;
+ }
+
+ /**
+ * Gets timeout for synchronized evictions.
+ * <p>
+ * Node that initiates eviction waits for responses
+ * from remote nodes within this timeout.
+ * <p>
+ * Default value is defined by {@link #DFLT_EVICT_SYNCHRONIZED_TIMEOUT}.
+ *
+ * @return Synchronous eviction timeout.
+ */
+ public long getEvictSynchronizedTimeout() {
+ return evictSyncTimeout;
+ }
+
+ /**
+ * Sets timeout for synchronized evictions.
+ *
+ * @param evictSyncTimeout Timeout for synchronized evictions.
+ */
+ public void setEvictSynchronizedTimeout(long evictSyncTimeout) {
+ this.evictSyncTimeout = evictSyncTimeout;
+ }
+
+ /**
+ * This value denotes the maximum size of eviction queue in percents of cache
+ * size in case of distributed cache (replicated and partitioned) and using
+ * synchronized eviction (that is if {@link #isEvictSynchronized()} returns
+ * {@code true}).
+ * <p>
+ * That queue is used internally as a buffer to decrease network costs for
+ * synchronized eviction. Once queue size reaches specified value all required
+ * requests for all entries in the queue are sent to remote nodes and the queue
+ * is cleared.
+ * <p>
+ * Default value is defined by {@link #DFLT_MAX_EVICTION_OVERFLOW_RATIO} and
+ * equals to {@code 10%}.
+ *
+ * @return Maximum size of eviction queue in percents of cache size.
+ */
+ public float getEvictMaxOverflowRatio() {
+ return evictMaxOverflowRatio;
+ }
+
+ /**
+ * Sets maximum eviction overflow ratio.
+ *
+ * @param evictMaxOverflowRatio Maximum eviction overflow ratio.
+ */
+ public void setEvictMaxOverflowRatio(float evictMaxOverflowRatio) {
+ this.evictMaxOverflowRatio = evictMaxOverflowRatio;
+ }
+
+ /**
+ * Gets eviction filter to specify which entries should not be evicted
+ * (except explicit evict by calling {@link GridCacheEntry#evict()}).
+ * If {@link GridCacheEvictionFilter#evictAllowed(GridCacheEntry)} method returns
+ * {@code false} then eviction policy will not be notified and entry will
+ * never be evicted.
+ * <p>
+ * If not provided, any entry may be evicted depending on
+ * {@link #getEvictionPolicy() eviction policy} configuration.
+ *
+ * @return Eviction filter or {@code null}.
+ */
+ @SuppressWarnings("unchecked")
+ public <K, V> GridCacheEvictionFilter<K, V> getEvictionFilter() {
+ return (GridCacheEvictionFilter<K, V>)evictFilter;
+ }
+
+ /**
+ * Sets eviction filter.
+ *
+ * @param evictFilter Eviction filter.
+ */
+ public <K, V> void setEvictionFilter(GridCacheEvictionFilter<K, V> evictFilter) {
+ this.evictFilter = evictFilter;
+ }
+
+ /**
+ * Gets flag indicating whether expired cache entries will be eagerly removed from cache. When
+ * set to {@code false}, expired entries will be removed on next entry access.
+ * <p>
+ * When not set, default value is {@link #DFLT_EAGER_TTL}.
+ * <p>
+ * <b>Note</b> that this flag only matters for entries expiring based on
+ * {@link GridCacheEntry#timeToLive()} value and should not be confused with entry
+ * evictions based on configured {@link GridCacheEvictionPolicy}.
+ *
+ * @return Flag indicating whether GridGain will eagerly remove expired entries.
+ */
+ public boolean isEagerTtl() {
+ return eagerTtl;
+ }
+
+ /**
+ * Sets eager ttl flag.
+ *
+ * @param eagerTtl {@code True} if GridGain should eagerly remove expired cache entries.
+ * @see #isEagerTtl()
+ */
+ public void setEagerTtl(boolean eagerTtl) {
+ this.eagerTtl = eagerTtl;
+ }
+
+ /**
+ * Gets initial cache size which will be used to pre-create internal
+ * hash table after start. Default value is defined by {@link #DFLT_START_SIZE}.
+ *
+ * @return Initial cache size.
+ */
+ public int getStartSize() {
+ return startSize;
+ }
+
+ /**
+ * Initial size for internal hash map.
+ *
+ * @param startSize Cache start size.
+ */
+ public void setStartSize(int startSize) {
+ this.startSize = startSize;
+ }
+
+ /**
+ * Gets initial cache size for near cache which will be used to pre-create internal
+ * hash table after start. Default value is defined by {@link #DFLT_NEAR_START_SIZE}.
+ *
+ * @return Initial near cache size.
+ */
+ public int getNearStartSize() {
+ return nearStartSize;
+ }
+
+ /**
+ * Start size for near cache. This property is only used for {@link GridCacheMode#PARTITIONED} caching mode.
+ *
+ * @param nearStartSize Start size for near cache.
+ */
+ public void setNearStartSize(int nearStartSize) {
+ this.nearStartSize = nearStartSize;
+ }
+
+ /**
+ * Gets underlying persistent storage for read-through and write-through operations.
+ * If not provided, cache will not exhibit read-through or write-through behavior.
+ *
+ * @return Underlying persistent storage for read-through and write-through operations.
+ */
+ @SuppressWarnings({"unchecked"})
+ public <K, V> CacheStore<K, V> getStore() {
+ return (CacheStore<K, V>)store;
+ }
+
+ /**
+ * Sets persistent storage for cache data.
+ *
+ * @param store Persistent cache store.
+ */
+ public <K, V> void setStore(CacheStore<K, V> store) {
+ this.store = store;
+ }
+
+ /**
+ * Gets key topology resolver to provide mapping from keys to nodes.
+ *
+ * @return Key topology resolver to provide mapping from keys to nodes.
+ */
+ public GridCacheAffinityFunction getAffinity() {
+ return aff;
+ }
+
+ /**
+ * Sets affinity for cache keys.
+ *
+ * @param aff Cache key affinity.
+ */
+ public void setAffinity(GridCacheAffinityFunction aff) {
+ this.aff = aff;
+ }
+
+ /**
+ * Gets caching mode to use. You can configure cache either to be local-only,
+ * fully replicated, partitioned, or near. If not provided, {@link GridCacheMode#REPLICATED}
+ * mode will be used by default (defined by {@link #DFLT_CACHE_MODE} constant).
+ *
+ * @return {@code True} if cache is local.
+ */
+ public GridCacheMode getCacheMode() {
+ return cacheMode;
+ }
+
+ /**
+ * Sets caching mode.
+ *
+ * @param cacheMode Caching mode.
+ */
+ public void setCacheMode(GridCacheMode cacheMode) {
+ this.cacheMode = cacheMode;
+ }
+
+ /**
+ * Gets cache atomicity mode.
+ * <p>
+ * Default value is defined by {@link #DFLT_CACHE_ATOMICITY_MODE}.
+ *
+ * @return Cache atomicity mode.
+ */
+ public GridCacheAtomicityMode getAtomicityMode() {
+ return atomicityMode;
+ }
+
+ /**
+ * Sets cache atomicity mode.
+ *
+ * @param atomicityMode Cache atomicity mode.
+ */
+ public void setAtomicityMode(GridCacheAtomicityMode atomicityMode) {
+ this.atomicityMode = atomicityMode;
+ }
+
+ /**
+ * Gets cache write ordering mode. This property can be enabled only for {@link GridCacheAtomicityMode#ATOMIC}
+ * cache (for other atomicity modes it will be ignored).
+ *
+ * @return Cache write ordering mode.
+ */
+ public GridCacheAtomicWriteOrderMode getAtomicWriteOrderMode() {
+ return atomicWriteOrderMode;
+ }
+
+ /**
+ * Sets cache write ordering mode. This property can be enabled only for {@link GridCacheAtomicityMode#ATOMIC}
+ * cache (for other atomicity modes it will be ignored).
+ *
+ * @param atomicWriteOrderMode Cache write ordering mode.
+ */
+ public void setAtomicWriteOrderMode(GridCacheAtomicWriteOrderMode atomicWriteOrderMode) {
+ this.atomicWriteOrderMode = atomicWriteOrderMode;
+ }
+
+ /**
+ * Gets number of nodes used to back up single partition for {@link GridCacheMode#PARTITIONED} cache.
+ * <p>
+ * If not set, default value is {@link #DFLT_BACKUPS}.
+ *
+ * @return Number of backup nodes for one partition.
+ */
+ public int getBackups() {
+ return backups;
+ }
+
+ /**
+ * Sets number of nodes used to back up single partition for {@link GridCacheMode#PARTITIONED} cache.
+ * <p>
+ * If not set, default value is {@link #DFLT_BACKUPS}.
+ *
+ * @param backups Number of backup nodes for one partition.
+ */
+ public void setBackups(int backups) {
+ this.backups = backups;
+ }
+
+ /**
+ * Gets default lock acquisition timeout. Default value is defined by {@link #DFLT_LOCK_TIMEOUT}
+ * which is {@code 0} and means that lock acquisition will never timeout.
+ *
+ * @return Default lock timeout.
+ */
+ public long getDefaultLockTimeout() {
+ return dfltLockTimeout;
+ }
+
+ /**
+ * Sets default lock timeout in milliseconds. By default this value is defined by {@link #DFLT_LOCK_TIMEOUT}.
+ *
+ * @param dfltLockTimeout Default lock timeout.
+ */
+ public void setDefaultLockTimeout(long dfltLockTimeout) {
+ this.dfltLockTimeout = dfltLockTimeout;
+ }
+
+ /**
+ * Gets default query timeout. Default value is defined by {@link #DFLT_QUERY_TIMEOUT}. {@code 0} (zero)
+ * means that the query will never timeout and will wait for completion.
+ *
+ * @return Default query timeout, {@code 0} for never.
+ */
+ public long getDefaultQueryTimeout() {
+ return dfltQryTimeout;
+ }
+
+ /**
+ * Sets default query timeout, {@code 0} for never. For more information see {@link #getDefaultQueryTimeout()}.
+ *
+ * @param dfltQryTimeout Default query timeout.
+ */
+ public void setDefaultQueryTimeout(long dfltQryTimeout) {
+ this.dfltQryTimeout = dfltQryTimeout;
+ }
+
+ /**
+ * Invalidation flag. If {@code true}, values will be invalidated (nullified) upon commit in near cache.
+ *
+ * @return Invalidation flag.
+ */
+ public boolean isInvalidate() {
+ return invalidate;
+ }
+
+ /**
+ * Sets invalidation flag for near cache entries in this transaction. Default is {@code false}.
+ *
+ * @param invalidate Flag to set this cache into invalidation-based mode. Default value is {@code false}.
+ */
+ public void setInvalidate(boolean invalidate) {
+ this.invalidate = invalidate;
+ }
+
+ /**
+ * Flag indicating if cached values should be additionally stored in serialized form. It's set to true by default.
+ *
+ * @param storeValBytes {@code true} if cached values should be additionally stored in serialized form, {@code
+ * false} otherwise.
+ */
+ public void setStoreValueBytes(boolean storeValBytes) {
+ this.storeValBytes = storeValBytes;
+ }
+
+ /**
+ * Flag indicating if cached values should be additionally stored in serialized form.
+ * It's set to {@code true} by default.
+ *
+ * @return {@code true} if cached values should be additionally stored in
+ * serialized form, {@code false} otherwise.
+ */
+ public boolean isStoreValueBytes() {
+ return storeValBytes;
+ }
+
+ /**
+ * Gets class name of transaction manager finder for integration for JEE app servers.
+ *
+ * @return Transaction manager finder.
+ */
+ public String getTransactionManagerLookupClassName() {
+ return tmLookupClsName;
+ }
+
+ /**
+ * Sets look up mechanism for available {@code TransactionManager} implementation, if any.
+ *
+ * @param tmLookupClsName Name of class implementing GridCacheTmLookup interface that is used to
+ * receive JTA transaction manager.
+ */
+ public void setTransactionManagerLookupClassName(String tmLookupClsName) {
+ this.tmLookupClsName = tmLookupClsName;
+ }
+
+ /**
+ * Sets cache preload mode.
+ *
+ * @param preloadMode Preload mode.
+ */
+ public void setPreloadMode(GridCachePreloadMode preloadMode) {
+ this.preloadMode = preloadMode;
+ }
+
+ /**
+ * Gets preload mode for distributed cache.
+ * <p>
+ * Default is defined by {@link #DFLT_PRELOAD_MODE}.
+ *
+ * @return Preload mode.
+ */
+ public GridCachePreloadMode getPreloadMode() {
+ return preloadMode;
+ }
+
+ /**
+ * Gets cache preload order. Preload order can be set to non-zero value for caches with
+ * {@link GridCachePreloadMode#SYNC SYNC} or {@link GridCachePreloadMode#ASYNC ASYNC} preload modes only.
+ * <p/>
+ * If cache preload order is positive, preloading for this cache will be started only when preloading for
+ * all caches with smaller preload order (except caches with preload order {@code 0}) will be completed.
+ * <p/>
+ * Note that cache with order {@code 0} does not participate in ordering. This means that cache with
+ * preload order {@code 1} will never wait for any other caches. All caches with order {@code 0} will
+ * be preloaded right away concurrently with each other and ordered preload processes.
+ * <p/>
+ * If not set, cache order is 0, i.e. preloading is not ordered.
+ *
+ * @return Cache preload order.
+ */
+ public int getPreloadOrder() {
+ return preloadOrder;
+ }
+
+ /**
+ * Sets cache preload order.
+ *
+ * @param preloadOrder Cache preload order.
+ * @see #getPreloadOrder()
+ */
+ public void setPreloadOrder(int preloadOrder) {
+ this.preloadOrder = preloadOrder;
+ }
+
+ /**
+ * Gets size (in number bytes) to be loaded within a single preload message.
+ * Preloading algorithm will split total data set on every node into multiple
+ * batches prior to sending data. Default value is defined by
+ * {@link #DFLT_PRELOAD_BATCH_SIZE}.
+ *
+ * @return Size in bytes of a single preload message.
+ */
+ public int getPreloadBatchSize() {
+ return preloadBatchSize;
+ }
+
+ /**
+ * Sets preload batch size.
+ *
+ * @param preloadBatchSize Preload batch size.
+ */
+ public void setPreloadBatchSize(int preloadBatchSize) {
+ this.preloadBatchSize = preloadBatchSize;
+ }
+
+ /**
+ * Flag indicating whether GridGain should use swap storage by default. By default
+ * swap is disabled which is defined via {@link #DFLT_SWAP_ENABLED} constant.
+ * <p>
+ * Note that this flag may be overridden for cache projection created with flag
+ * {@link GridCacheFlag#SKIP_SWAP}.
+ *
+ * @return {@code True} if swap storage is enabled.
+ */
+ public boolean isSwapEnabled() {
+ return swapEnabled;
+ }
+
+ /**
+ * Flag indicating whether swap storage is enabled or not.
+ *
+ * @param swapEnabled {@code True} if swap storage is enabled.
+ */
+ public void setSwapEnabled(boolean swapEnabled) {
+ this.swapEnabled = swapEnabled;
+ }
+
+ /**
+ * Gets maximum number of allowed concurrent asynchronous operations. If 0 returned then number
+ * of concurrent asynchronous operations is unlimited.
+ * <p>
+ * If not set, default value is {@link #DFLT_MAX_CONCURRENT_ASYNC_OPS}.
+ * <p>
+ * If user threads do not wait for asynchronous operations to complete, it is possible to overload
+ * a system. This property enables back-pressure control by limiting number of scheduled asynchronous
+ * cache operations.
+ *
+ * @return Maximum number of concurrent asynchronous operations or {@code 0} if unlimited.
+ */
+ public int getMaxConcurrentAsyncOperations() {
+ return maxConcurrentAsyncOps;
+ }
+
+ /**
+ * Sets maximum number of concurrent asynchronous operations.
+ *
+ * @param maxConcurrentAsyncOps Maximum number of concurrent asynchronous operations.
+ * @see #getMaxConcurrentAsyncOperations()
+ */
+ public void setMaxConcurrentAsyncOperations(int maxConcurrentAsyncOps) {
+ this.maxConcurrentAsyncOps = maxConcurrentAsyncOps;
+ }
+
+ /**
+ * Flag indicating whether GridGain should attempt to index value and/or key instances
+ * stored in cache. If this property is {@code false}, then all indexing annotations
+ * inside of any class will be ignored. By default query indexing is disabled and
+ * defined via {@link #DFLT_QUERY_INDEX_ENABLED} constant.
+ *
+ * @return {@code True} if query indexing is enabled.
+ * @see #getMemoryMode()
+ */
+ public boolean isQueryIndexEnabled() {
+ return qryIdxEnabled;
+ }
+
+ /**
+ * Flag indicating whether query indexing is enabled or not.
+ *
+ * @param qryIdxEnabled {@code True} if query indexing is enabled.
+ */
+ public void setQueryIndexEnabled(boolean qryIdxEnabled) {
+ this.qryIdxEnabled = qryIdxEnabled;
+ }
+
+ /**
+ * Flag indicating whether GridGain should use write-behind behaviour for the cache store.
+ * By default write-behind is disabled which is defined via {@link #DFLT_WRITE_BEHIND_ENABLED}
+ * constant.
+ *
+ * @return {@code True} if write-behind is enabled.
+ */
+ public boolean isWriteBehindEnabled() {
+ return writeBehindEnabled;
+ }
+
+ /**
+ * Sets flag indicating whether write-behind is enabled.
+ *
+ * @param writeBehindEnabled {@code true} if write-behind is enabled.
+ */
+ public void setWriteBehindEnabled(boolean writeBehindEnabled) {
+ this.writeBehindEnabled = writeBehindEnabled;
+ }
+
+ /**
+ * Maximum size of the write-behind cache. If cache size exceeds this value,
+ * all cached items are flushed to the cache store and write cache is cleared.
+ * <p/>
+ * If not provided, default value is {@link #DFLT_WRITE_BEHIND_FLUSH_SIZE}.
+ * If this value is {@code 0}, then flush is performed according to the flush frequency interval.
+ * <p/>
+ * Note that you cannot set both, {@code flush} size and {@code flush frequency}, to {@code 0}.
+ *
+ * @return Maximum object count in write-behind cache.
+ */
+ public int getWriteBehindFlushSize() {
+ return writeBehindFlushSize;
+ }
+
+ /**
+ * Sets write-behind flush size.
+ *
+ * @param writeBehindFlushSize Write-behind cache flush size.
+ * @see #getWriteBehindFlushSize()
+ */
+ public void setWriteBehindFlushSize(int writeBehindFlushSize) {
+ this.writeBehindFlushSize = writeBehindFlushSize;
+ }
+
+ /**
+ * Frequency with which write-behind cache is flushed to the cache store in milliseconds.
+ * This value defines the maximum time interval between object insertion/deletion from the cache
+ * ant the moment when corresponding operation is applied to the cache store.
+ * <p>
+ * If not provided, default value is {@link #DFLT_WRITE_BEHIND_FLUSH_FREQUENCY}.
+ * If this value is {@code 0}, then flush is performed according to the flush size.
+ * <p>
+ * Note that you cannot set both, {@code flush} size and {@code flush frequency}, to {@code 0}.
+ *
+ * @return Write-behind flush frequency in milliseconds.
+ */
+ public long getWriteBehindFlushFrequency() {
+ return writeBehindFlushFreq;
+ }
+
+ /**
+ * Sets write-behind flush frequency.
+ *
+ * @param writeBehindFlushFreq Write-behind flush frequency in milliseconds.
+ * @see #getWriteBehindFlushFrequency()
+ */
+ public void setWriteBehindFlushFrequency(long writeBehindFlushFreq) {
+ this.writeBehindFlushFreq = writeBehindFlushFreq;
+ }
+
+ /**
+ * Number of threads that will perform cache flushing. Cache flushing is performed
+ * when cache size exceeds value defined by
+ * {@link #getWriteBehindFlushSize}, or flush interval defined by
+ * {@link #getWriteBehindFlushFrequency} is elapsed.
+ * <p/>
+ * If not provided, default value is {@link #DFLT_WRITE_FROM_BEHIND_FLUSH_THREAD_CNT}.
+ *
+ * @return Count of flush threads.
+ */
+ public int getWriteBehindFlushThreadCount() {
+ return writeBehindFlushThreadCnt;
+ }
+
+ /**
+ * Sets flush thread count for write-behind cache.
+ *
+ * @param writeBehindFlushThreadCnt Count of flush threads.
+ * @see #getWriteBehindFlushThreadCount()
+ */
+ public void setWriteBehindFlushThreadCount(int writeBehindFlushThreadCnt) {
+ this.writeBehindFlushThreadCnt = writeBehindFlushThreadCnt;
+ }
+
+ /**
+ * Maximum batch size for write-behind cache store operations. Store operations (get or remove)
+ * are combined in a batch of this size to be passed to
+ * {@link CacheStore#writeAll(Collection)} or
+ * {@link CacheStore#deleteAll(Collection)} methods.
+ * <p/>
+ * If not provided, default value is {@link #DFLT_WRITE_BEHIND_BATCH_SIZE}.
+ *
+ * @return Maximum batch size for store operations.
+ */
+ public int getWriteBehindBatchSize() {
+ return writeBehindBatchSize;
+ }
+
+ /**
+ * Sets maximum batch size for write-behind cache.
+ *
+ * @param writeBehindBatchSize Maximum batch size.
+ * @see #getWriteBehindBatchSize()
+ */
+ public void setWriteBehindBatchSize(int writeBehindBatchSize) {
+ this.writeBehindBatchSize = writeBehindBatchSize;
+ }
+
+ /**
+ * Cloner to be used for cloning values that are returned to user only if {@link GridCacheFlag#CLONE}
+ * is set on {@link GridCacheProjection}. Cloning values is useful when it is needed to get value from
+ * cache, change it and put it back (if the value was not cloned, then user would be updating the
+ * cached reference which would violate cache integrity).
+ * <p>
+ * <b>NOTE:</b> by default, cache uses {@link GridCacheBasicCloner} implementation which will clone only objects
+ * implementing {@link Cloneable} interface. You can also configure cache to use
+ * {@link GridCacheDeepCloner} which will perform deep-cloning of all objects returned from cache,
+ * regardless of the {@link Cloneable} interface. If none of the above cloners fit your
+ * logic, you can also provide your own implementation of {@link GridCacheCloner} interface.
+ *
+ * @return Cloner to be used if {@link GridCacheFlag#CLONE} flag is set on cache projection.
+ */
+ @SuppressWarnings({"unchecked"})
+ public GridCacheCloner getCloner() {
+ return cloner;
+ }
+
+ /**
+ * Sets cloner to be used if {@link GridCacheFlag#CLONE} flag is set on projection.
+ *
+ * @param cloner Cloner to use.
+ * @see #getCloner()
+ */
+ public void setCloner(GridCacheCloner cloner) {
+ this.cloner = cloner;
+ }
+
+ /**
+ * Gets default number of sequence values reserved for {@link GridCacheAtomicSequence} instances. After
+ * a certain number has been reserved, consequent increments of sequence will happen locally,
+ * without communication with other nodes, until the next reservation has to be made.
+ * <p>
+ * Default value is {@link #DFLT_ATOMIC_SEQUENCE_RESERVE_SIZE}.
+ *
+ * @return Atomic sequence reservation size.
+ */
+ public int getAtomicSequenceReserveSize() {
+ return seqReserveSize;
+ }
+
+ /**
+ * Sets default number of sequence values reserved for {@link GridCacheAtomicSequence} instances. After a certain
+ * number has been reserved, consequent increments of sequence will happen locally, without communication with other
+ * nodes, until the next reservation has to be made.
+ *
+ * @param seqReserveSize Atomic sequence reservation size.
+ * @see #getAtomicSequenceReserveSize()
+ */
+ public void setAtomicSequenceReserveSize(int seqReserveSize) {
+ this.seqReserveSize = seqReserveSize;
+ }
+
+ /**
+ * Gets size of preloading thread pool. Note that size serves as a hint and implementation
+ * may create more threads for preloading than specified here (but never less threads).
+ * <p>
+ * Default value is {@link #DFLT_PRELOAD_THREAD_POOL_SIZE}.
+ *
+ * @return Size of preloading thread pool.
+ */
+ public int getPreloadThreadPoolSize() {
+ return preloadPoolSize;
+ }
+
+ /**
+ * Sets size of preloading thread pool. Note that size serves as a hint and implementation may create more threads
+ * for preloading than specified here (but never less threads).
+ *
+ * @param preloadPoolSize Size of preloading thread pool.
+ */
+ public void setPreloadThreadPoolSize(int preloadPoolSize) {
+ this.preloadPoolSize = preloadPoolSize;
+ }
+
+ /**
+ * Gets preload timeout (ms).
+ * <p>
+ * Default value is {@link #DFLT_PRELOAD_TIMEOUT}.
+ *
+ * @return Preload timeout (ms).
+ */
+ public long getPreloadTimeout() {
+ return preloadTimeout;
+ }
+
+ /**
+ * Sets preload timeout (ms).
+ *
+ * @param preloadTimeout Preload timeout (ms).
+ */
+ public void setPreloadTimeout(long preloadTimeout) {
+ this.preloadTimeout = preloadTimeout;
+ }
+
+ /**
+ * Gets delay in milliseconds upon a node joining or leaving topology (or crash) after which preloading
+ * should be started automatically. Preloading should be delayed if you plan to restart nodes
+ * after they leave topology, or if you plan to start multiple nodes at once or one after another
+ * and don't want to repartition and preload until all nodes are started.
+ * <p>
+ * Delayed preloading is applied to {@link GridCacheMode#PARTITIONED} caches only.
+ * For better efficiency user should usually make sure that new nodes get placed on
+ * the same place of consistent hash ring as the left nodes, and that nodes are
+ * restarted before this delay expires. To place nodes on the same place in consistent hash ring,
+ * use {@link GridCacheConsistentHashAffinityFunction#setHashIdResolver(GridCacheAffinityNodeHashResolver)}
+ * to make sure that a node maps to the same hash ID event if restarted. As an example,
+ * node IP address and port combination may be used in this case.
+ * <p>
+ * Default value is {@code 0} which means that repartitioning and preloading will start
+ * immediately upon node leaving topology. If {@code -1} is returned, then preloading
+ * will only be started manually by calling {@link GridCache#forceRepartition()} method or
+ * from management console.
+ *
+ * @return Preloading delay, {@code 0} to start preloading immediately, {@code -1} to
+ * start preloading manually, or positive value to specify delay in milliseconds
+ * after which preloading should start automatically.
+ */
+ public long getPreloadPartitionedDelay() {
+ return preloadDelay;
+ }
+
+ /**
+ * Sets preload delay (see {@link #getPreloadPartitionedDelay()} for more information).
+ *
+ * @param preloadDelay Preload delay to set.
+ */
+ public void setPreloadPartitionedDelay(long preloadDelay) {
+ this.preloadDelay = preloadDelay;
+ }
+
+ /**
+ * Time in milliseconds to wait between preload messages to avoid overloading of CPU or network.
+ * When preloading large data sets, the CPU or network can get over-consumed with preloading messages,
+ * which consecutively may slow down the application performance. This parameter helps tune
+ * the amount of time to wait between preload messages to make sure that preloading process
+ * does not have any negative performance impact. Note that application will continue to work
+ * properly while preloading is still in progress.
+ * <p>
+ * Value of {@code 0} means that throttling is disabled. By default throttling is disabled -
+ * the default is defined by {@link #DFLT_PRELOAD_THROTTLE} constant.
+ *
+ * @return Time in milliseconds to wait between preload messages to avoid overloading of CPU,
+ * {@code 0} to disable throttling.
+ */
+ public long getPreloadThrottle() {
+ return preloadThrottle;
+ }
+
+ /**
+ * Time in milliseconds to wait between preload messages to avoid overloading of CPU or network. When preloading
+ * large data sets, the CPU or network can get over-consumed with preloading messages, which consecutively may slow
+ * down the application performance. This parameter helps tune the amount of time to wait between preload messages
+ * to make sure that preloading process does not have any negative performance impact. Note that application will
+ * continue to work properly while preloading is still in progress. <p> Value of {@code 0} means that throttling is
+ * disabled. By default throttling is disabled - the default is defined by {@link #DFLT_PRELOAD_THROTTLE} constant.
+ *
+ * @param preloadThrottle Time in milliseconds to wait between preload messages to avoid overloading of CPU, {@code
+ * 0} to disable throttling.
+ */
+ public void setPreloadThrottle(long preloadThrottle) {
+ this.preloadThrottle = preloadThrottle;
+ }
+
+ /**
+ * Affinity key mapper used to provide custom affinity key for any given key.
+ * Affinity mapper is particularly useful when several objects need to be collocated
+ * on the same node (they will also be backed up on the same nodes as well).
+ * <p>
+ * If not provided, then default implementation will be used. The default behavior
+ * is described in {@link GridCacheAffinityKeyMapper} documentation.
+ *
+ * @return Mapper to use for affinity key mapping.
+ */
+ public GridCacheAffinityKeyMapper getAffinityMapper() {
+ return affMapper;
+ }
+
+ /**
+ * Sets custom affinity mapper. If not provided, then default implementation will be used. The default behavior is
+ * described in {@link GridCacheAffinityKeyMapper} documentation.
+ *
+ * @param affMapper Affinity mapper.
+ */
+ public void setAffinityMapper(GridCacheAffinityKeyMapper affMapper) {
+ this.affMapper = affMapper;
+ }
+
+ /**
+ * Gets name of the SPI to use for indexing. If not specified, the default
+ * indexing SPI will be used.
+ * <p>
+ * This property becomes useful in rare cases when more than one indexing
+ * SPI is configured. In majority of the cases default value should be used.
+ *
+ * @return Name of SPI to use for indexing.
+ * @see GridIndexingSpi
+ */
+ public String getIndexingSpiName() {
+ return indexingSpiName;
+ }
+
+ /**
+ * Sets name of the SPI to use for indexing. If not specified, the default
+ * indexing SPI will be used.
+ * <p>
+ * This property becomes useful in rare cases when more than one indexing
+ * SPI is configured. In majority of the cases default value should be used.
+ *
+ * @param indexingSpiName Name.
+ * @see GridIndexingSpi
+ */
+ public void setIndexingSpiName(String indexingSpiName) {
+ this.indexingSpiName = indexingSpiName;
+ }
+
+ /**
+ * Gets maximum amount of memory available to off-heap storage. Possible values are
+ * <ul>
+ * <li>{@code -1} - Means that off-heap storage is disabled.</li>
+ * <li>
+ * {@code 0} - GridGain will not limit off-heap storage (it's up to user to properly
+ * add and remove entries from cache to ensure that off-heap storage does not grow
+ * indefinitely.
+ * </li>
+ * <li>Any positive value specifies the limit of off-heap storage in bytes.</li>
+ * </ul>
+ * Default value is {@code -1}, specified by {@link #DFLT_OFFHEAP_MEMORY} constant
+ * which means that off-heap storage is disabled by default.
+ * <p>
+ * Use off-heap storage to load gigabytes of data in memory without slowing down
+ * Garbage Collection. Essentially in this case you should allocate very small amount
+ * of memory to JVM and GridGain will cache most of the data in off-heap space
+ * without affecting JVM performance at all.
+ * <p>
+ * Note that GridGain will throw an exception if max memory is set to {@code -1} and
+ * {@code offHeapValuesOnly} flag is set to {@code true}.
+ *
+ * @return Maximum memory in bytes available to off-heap memory space.
+ */
+ public long getOffHeapMaxMemory() {
+ return offHeapMaxMem;
+ }
+
+ /**
+ * Sets maximum amount of memory available to off-heap storage. Possible values are <ul> <li>{@code -1} - Means that
+ * off-heap storage is disabled.</li> <li> {@code 0} - GridGain will not limit off-heap storage (it's up to user to
+ * properly add and remove entries from cache to ensure that off-heap storage does not grow infinitely. </li>
+ * <li>Any positive value specifies the limit of off-heap storage in bytes.</li> </ul> Default value is {@code -1},
+ * specified by {@link #DFLT_OFFHEAP_MEMORY} constant which means that off-heap storage is disabled by default. <p>
+ * Use off-heap storage to load gigabytes of data in memory without slowing down Garbage Collection. Essentially in
+ * this case you should allocate very small amount of memory to JVM and GridGain will cache most of the data in
+ * off-heap space without affecting JVM performance at all.
+ *
+ * @param offHeapMaxMem Maximum memory in bytes available to off-heap memory space.
+ */
+ public void setOffHeapMaxMemory(long offHeapMaxMem) {
+ this.offHeapMaxMem = offHeapMaxMem;
+ }
+
+ /**
+ * Gets maximum number of query iterators that can be stored. Iterators are stored to
+ * support query pagination when each page of data is sent to user's node only on demand.
+ * Increase this property if you are running and processing lots of queries in parallel.
+ * <p>
+ * Default value is {@link #DFLT_MAX_QUERY_ITERATOR_CNT}.
+ *
+ * @return Maximum number of query iterators that can be stored.
+ */
+ public int getMaximumQueryIteratorCount() {
+ return maxQryIterCnt;
+ }
+
+ /**
+ * Sets maximum number of query iterators that can be stored.
+ *
+ * @param maxQryIterCnt Maximum number of query iterators that can be stored.
+ */
+ public void setMaximumQueryIteratorCount(int maxQryIterCnt) {
+ this.maxQryIterCnt = maxQryIterCnt;
+ }
+
+ /**
+ * Gets maximum number of entries that can be accumulated before back-pressure
+ * is enabled to postpone cache updates until query listeners are notified.
+ * If your system is configured properly, then this number should never be reached.
+ * <p>
+ * Default value is {@link #DFLT_CONT_QUERY_QUEUE_SIZE}.
+ *
+ * @return Continuous query queue size.
+ * @deprecated Ignored in current version.
+ */
+ @Deprecated
+ public int getContinuousQueryQueueSize() {
+ return 0;
+ }
+
+ /**
+ * Sets continuous query queue size.
+ *
+ * @param contQryQueueSize Continuous query queue size.
+ * @deprecated Ignored in current version.
+ */
+ @Deprecated
+ public void setContinuousQueryQueueSize(int contQryQueueSize) {
+ // No-op.
+ }
+
+ /**
+ * Gets memory mode for cache. Memory mode helps control whether value is stored in on-heap memory,
+ * off-heap memory, or swap space. Refer to {@link GridCacheMemoryMode} for more info.
+ * <p>
+ * Default value is {@link #DFLT_MEMORY_MODE}.
+ *
+ * @return Memory mode.
+ */
+ public GridCacheMemoryMode getMemoryMode() {
+ return memMode;
+ }
+
+ /**
+ * Sets memory mode for cache.
+ *
+ * @param memMode Memory mode.
+ */
+ public void setMemoryMode(GridCacheMemoryMode memMode) {
+ this.memMode = memMode;
+ }
+
+ /**
+ * Gets the maximum buffer size for continuous queries. When the current
+ * number of entries in buffer exceeds the maximum buffer size, the buffer
+ * is flushed to the notification queue. Greater buffer size may improve throughput,
+ * but also may increase latency.
+ * <p>
+ * Default value is either {@link #DFLT_CONT_QUERY_MAX_BUF_SIZE} or
+ * {@code GG_CONT_QUERY_MAX_BUF_SIZE} system property value (if specified).
+ *
+ * @return Maximum buffer size for continuous queries.
+ * @deprecated Ignored in current version.
+ */
+ @Deprecated
+ public int getContinuousQueryMaximumBufferSize() {
+ return 0;
+ }
+
+ /**
+ * Sets maximum buffer size for continuous queries.
+ *
+ * @param contQryMaxBufSize Maximum buffer size for continuous queries.
+ * @deprecated Ignored in current version.
+ */
+ @Deprecated
+ public void setContinuousQueryMaximumBufferSize(int contQryMaxBufSize) {
+ // No-op.
+ }
+
+ /**
+ * Gets cache interceptor.
+ *
+ * @return Cache interceptor.
+ */
+ @SuppressWarnings({"unchecked"})
+ @Nullable public <K, V> GridCacheInterceptor<K, V> getInterceptor() {
+ return (GridCacheInterceptor<K, V>)interceptor;
+ }
+
+ /**
+ * Sets cache interceptor.
+ *
+ * @param interceptor Cache interceptor.
+ */
+ public <K, V> void setInterceptor(GridCacheInterceptor<K, V> interceptor) {
+ this.interceptor = interceptor;
+ }
+
+ /**
+ * Flag indicating whether GridGain should store portable keys and values
+ * as instances of {@link PortableObject}.
+ *
+ * @return Portable enabled flag.
+ */
+ public boolean isPortableEnabled() {
+ return portableEnabled;
+ }
+
+ /**
+ * Gets portable enabled flag value.
+ *
+ * @param portableEnabled Portable enabled flag value.
+ */
+ public void setPortableEnabled(boolean portableEnabled) {
+ this.portableEnabled = portableEnabled;
+ }
+
+ /**
+ * Flag indicating that {@link CacheStore} implementation
+ * is working with portable objects instead of Java objects
+ * if portable mode for this cache is enabled ({@link #isPortableEnabled()}
+ * flag is {@code true}). Default value of this flag is {@code true},
+ * because this is recommended behavior from performance standpoint.
+ * <p>
+ * If set to {@code false}, GridGain will deserialize keys and
+ * values stored in portable format before they are passed
+ * to cache store.
+ * <p>
+ * Note that setting this flag to {@code false} can simplify
+ * store implementation in some cases, but it can cause performance
+ * degradation due to additional serializations and deserializations
+ * of portable objects. You will also need to have key and value
+ * classes on all nodes since portables will be deserialized when
+ * store is called.
+ * <p>
+ * This flag is ignored if portable mode is disabled for this
+ * cache ({@link #isPortableEnabled()} flag is {@code false}).
+ *
+ * @return Keep portables in store flag.
+ */
+ public boolean isKeepPortableInStore() {
+ return keepPortableInStore;
+ }
+
+ /**
+ * Sets keep portables in store flag.
+ *
+ * @param keepPortableInStore Keep portables in store flag.
+ */
+ public void setKeepPortableInStore(boolean keepPortableInStore) {
+ this.keepPortableInStore = keepPortableInStore;
+ }
+
+ /**
+ * Gets query configuration. Query configuration defines which fields should be indexed for objects
+ * without annotations or portable objects.
+ *
+ * @return Cache query configuration.
+ */
+ public GridCacheQueryConfiguration getQueryConfiguration() {
+ return qryCfg;
+ }
+
+ /**
+ * Sets query configuration.
+ *
+ * @param qryCfg Query configuration.
+ * @see GridCacheQueryConfiguration
+ */
+ public void setQueryConfiguration(GridCacheQueryConfiguration qryCfg) {
+ this.qryCfg = qryCfg;
+ }
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ return S.toString(CacheConfiguration.class, this);
+ }
}
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/CacheFlag.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheFlag.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheFlag.java
index 1e5076f..bd44880 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/CacheFlag.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheFlag.java
@@ -45,7 +45,7 @@ public enum CacheFlag {
* messages will be sent to set the values to {@code null}.
*
* @see IgniteTx#isInvalidate()
- * @see org.gridgain.grid.cache.GridCacheConfiguration#isInvalidate()
+ * @see CacheConfiguration#isInvalidate()
*/
INVALIDATE,
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStore.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStore.java b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStore.java
index 4cdfe5a..f44d79a 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStore.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStore.java
@@ -35,7 +35,7 @@ import static javax.cache.Cache.*;
/**
* API for cache persistent storage for read-through and write-through behavior.
- * Persistent store is configured via {@link GridCacheConfiguration#getStore()}
+ * Persistent store is configured via {@link org.apache.ignite.cache.CacheConfiguration#getStore()}
* configuration property. If not provided, values will be only kept in cache memory
* or swap storage without ever being persisted to a persistent storage.
* <p>
@@ -70,7 +70,7 @@ import static javax.cache.Cache.*;
* }
* </pre>
* <h1 class="header">Working With Portable Objects</h1>
- * When portables are enabled for cache by setting {@link GridCacheConfiguration#isPortableEnabled()} to
+ * When portables are enabled for cache by setting {@link org.apache.ignite.cache.CacheConfiguration#isPortableEnabled()} to
* {@code true}), all portable keys and values are converted to instances of {@link PortableObject}.
* Therefore, all cache store methods will take parameters in portable format. To avoid class
* cast exceptions, store must have signature compatible with portables. E.g., if you use {@link Integer}
@@ -85,7 +85,7 @@ import static javax.cache.Cache.*;
* ...
* }
* </pre>
- * This behavior can be overridden by setting {@link GridCacheConfiguration#setKeepPortableInStore(boolean)}
+ * This behavior can be overridden by setting {@link org.apache.ignite.cache.CacheConfiguration#setKeepPortableInStore(boolean)}
* flag value to {@code false}. In this case, GridGain will deserialize keys and values stored in portable
* format before they are passed to cache store, so that you can use the following cache store signature instead:
* <pre name="code" class="java">
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreBalancingWrapper.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreBalancingWrapper.java b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreBalancingWrapper.java
index c76d4ec..e8430aa 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreBalancingWrapper.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreBalancingWrapper.java
@@ -109,6 +109,8 @@ public class CacheStoreBalancingWrapper<K, V> implements CacheStore<K, V> {
/** {@inheritDoc} */
@Override public Map<K, V> loadAll(Iterable<? extends K> keys) throws CacheLoaderException {
+ assert false;
+
return delegate.loadAll(keys);
}
@@ -117,7 +119,7 @@ public class CacheStoreBalancingWrapper<K, V> implements CacheStore<K, V> {
* @param c Closure for loaded values.
*/
public void loadAll(Collection<? extends K> keys, final IgniteBiInClosure<K, V> c) {
- assert keys.size() < loadAllThreshold;
+ assert keys.size() <= loadAllThreshold : loadAllThreshold;
Collection<K> needLoad = null;
Map<K, LoadFuture> pending = null;
@@ -161,8 +163,10 @@ public class CacheStoreBalancingWrapper<K, V> implements CacheStore<K, V> {
try {
Map<K, V> loaded = delegate.loadAll(needLoad);
- for (Map.Entry<K, V> e : loaded.entrySet())
- c.apply(e.getKey(), e.getValue());
+ if (loaded != null) {
+ for (Map.Entry<K, V> e : loaded.entrySet())
+ c.apply(e.getKey(), e.getValue());
+ }
span.onComplete(needLoad, loaded);
}
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreSession.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreSession.java b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreSession.java
index 2331e02..0fb5c47 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreSession.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/store/CacheStoreSession.java
@@ -34,5 +34,5 @@ public interface CacheStoreSession {
/**
* @return Session properties.
*/
- public Map<Object, Object> properties();
+ public <K, V> Map<K, V> properties();
}
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheJdbcBlobStore.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheJdbcBlobStore.java b/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheJdbcBlobStore.java
index 8c13db9..394a5ed 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheJdbcBlobStore.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheJdbcBlobStore.java
@@ -29,6 +29,7 @@ import org.gridgain.grid.util.typedef.internal.*;
import org.jdk8.backport.*;
import org.jetbrains.annotations.*;
+import javax.cache.*;
import javax.cache.integration.*;
import javax.sql.*;
import java.sql.*;
@@ -239,11 +240,14 @@ public class CacheJdbcBlobStore<K, V> extends CacheStoreAdapter<K, V> {
}
/** {@inheritDoc} */
- @Override public void put(K key, V val) {
+ @Override public void write(Cache.Entry<? extends K, ? extends V> entry) {
init();
IgniteTx tx = transaction();
+ K key = entry.getKey();
+ V val = entry.getValue();
+
if (log.isDebugEnabled())
log.debug("Store put [key=" + key + ", val=" + val + ", tx=" + tx + ']');
@@ -279,7 +283,7 @@ public class CacheJdbcBlobStore<K, V> extends CacheStoreAdapter<K, V> {
}
/** {@inheritDoc} */
- @Override public void remove(K key) {
+ @Override public void delete(Object key) {
init();
IgniteTx tx = transaction();
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
index 345f8d7..0c56c51 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
@@ -18,6 +18,7 @@
package org.apache.ignite.configuration;
import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
import org.apache.ignite.events.*;
import org.apache.ignite.fs.*;
import org.apache.ignite.lang.*;
@@ -30,7 +31,6 @@ import org.apache.ignite.spi.authentication.*;
import org.apache.ignite.spi.indexing.*;
import org.apache.ignite.streamer.*;
import org.gridgain.client.ssl.*;
-import org.gridgain.grid.cache.*;
import org.gridgain.grid.dotnet.*;
import org.gridgain.grid.hadoop.*;
import org.gridgain.grid.kernal.managers.eventstorage.*;
@@ -384,7 +384,7 @@ public class IgniteConfiguration {
private IgniteAddressResolver addrRslvr;
/** Cache configurations. */
- private GridCacheConfiguration[] cacheCfg;
+ private CacheConfiguration[] cacheCfg;
/** Transactions configuration. */
private TransactionsConfiguration txCfg = new TransactionsConfiguration();
@@ -2241,7 +2241,7 @@ public class IgniteConfiguration {
*
* @return Array of fully initialized cache descriptors.
*/
- public GridCacheConfiguration[] getCacheConfiguration() {
+ public CacheConfiguration[] getCacheConfiguration() {
return cacheCfg;
}
@@ -2251,8 +2251,8 @@ public class IgniteConfiguration {
* @param cacheCfg Cache configurations.
*/
@SuppressWarnings({"ZeroLengthArrayAllocation"})
- public void setCacheConfiguration(GridCacheConfiguration... cacheCfg) {
- this.cacheCfg = cacheCfg == null ? new GridCacheConfiguration[0] : cacheCfg;
+ public void setCacheConfiguration(CacheConfiguration... cacheCfg) {
+ this.cacheCfg = cacheCfg == null ? new CacheConfiguration[0] : cacheCfg;
}
/**
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
index f95cd2a..cca2946 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
@@ -99,7 +99,7 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements
/** {@inheritDoc} */
@Override public <C extends Configuration<K, V>> C getConfiguration(Class<C> clazz) {
- GridCacheConfiguration cfg = ctx.config();
+ CacheConfiguration cfg = ctx.config();
if (!clazz.isAssignableFrom(cfg.getClass()))
throw new IllegalArgumentException();
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/resources/IgniteCacheNameResource.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/resources/IgniteCacheNameResource.java b/modules/core/src/main/java/org/apache/ignite/resources/IgniteCacheNameResource.java
index 8b843f3..3f16f2e 100644
--- a/modules/core/src/main/java/org/apache/ignite/resources/IgniteCacheNameResource.java
+++ b/modules/core/src/main/java/org/apache/ignite/resources/IgniteCacheNameResource.java
@@ -18,13 +18,12 @@
package org.apache.ignite.resources;
import java.lang.annotation.*;
-import org.gridgain.grid.cache.*;
/**
* Annotates a field or a setter method for injection of grid cache name.
- * Grid cache name is provided to cache via {@link GridCacheConfiguration#getName()} method.
+ * Grid cache name is provided to cache via {@link org.apache.ignite.cache.CacheConfiguration#getName()} method.
* <p>
- * Cache name can be injected into components provided in the {@link GridCacheConfiguration},
+ * Cache name can be injected into components provided in the {@link org.apache.ignite.cache.CacheConfiguration},
* if {@link IgniteCacheNameResource} annotation is used in another classes it is no-op.
* <p>
* Here is how injection would typically happen:
@@ -50,7 +49,7 @@ import org.gridgain.grid.cache.*;
* }
* </pre>
* <p>
- * See {@link GridCacheConfiguration#getName()} for cache configuration details.
+ * See {@link org.apache.ignite.cache.CacheConfiguration#getName()} for cache configuration details.
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java b/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
index 80409f4..263747a 100644
--- a/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
+++ b/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
@@ -19,7 +19,6 @@ package org.apache.ignite.transactions;
import org.apache.ignite.*;
import org.apache.ignite.lang.*;
-import org.gridgain.grid.*;
import org.gridgain.grid.cache.*;
import java.util.*;
@@ -67,7 +66,7 @@ import java.util.*;
* all nodes reply {@code 'OK'} (i.e. {@code Phase 1} completes successfully), a one-way' {@code 'COMMIT'}
* message is sent without waiting for reply. If it is necessary to know whenever remote nodes have committed
* as well, synchronous commit or synchronous rollback should be enabled via
- * {@link GridCacheConfiguration#setWriteSynchronizationMode}
+ * {@link org.apache.ignite.cache.CacheConfiguration#setWriteSynchronizationMode}
* or by setting proper flags on cache projection, such as {@link GridCacheFlag#SYNC_COMMIT}.
* <p>
* Note that in this mode, optimistic failures are only possible in conjunction with
@@ -114,7 +113,7 @@ import java.util.*;
* }
* </pre>
*/
-public interface IgniteTx extends GridMetadataAware, AutoCloseable, IgniteAsyncSupport {
+public interface IgniteTx extends AutoCloseable, IgniteAsyncSupport {
/**
* Gets unique identifier for this transaction.
*
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/gridgain/grid/GridBasicWarmupClosure.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/gridgain/grid/GridBasicWarmupClosure.java b/modules/core/src/main/java/org/gridgain/grid/GridBasicWarmupClosure.java
index 8639b5f..40b94e8 100644
--- a/modules/core/src/main/java/org/gridgain/grid/GridBasicWarmupClosure.java
+++ b/modules/core/src/main/java/org/gridgain/grid/GridBasicWarmupClosure.java
@@ -18,6 +18,7 @@
package org.gridgain.grid;
import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
import org.apache.ignite.configuration.*;
import org.apache.ignite.lang.*;
import org.apache.ignite.logger.*;
@@ -341,14 +342,14 @@ public class GridBasicWarmupClosure implements IgniteInClosure<IgniteConfigurati
cp.setClientConnectionConfiguration(null);
- Collection<GridCacheConfiguration> reduced = new ArrayList<>();
+ Collection<CacheConfiguration> reduced = new ArrayList<>();
- for (GridCacheConfiguration ccfg : gridCfg.getCacheConfiguration()) {
+ for (CacheConfiguration ccfg : gridCfg.getCacheConfiguration()) {
if (CU.isSystemCache(ccfg.getName()))
continue;
if (!matches(reduced, ccfg)) {
- GridCacheConfiguration ccfgCp = new GridCacheConfiguration(ccfg);
+ CacheConfiguration ccfgCp = new CacheConfiguration(ccfg);
if (ccfgCp.getDistributionMode() == GridCacheDistributionMode.CLIENT_ONLY)
ccfgCp.setDistributionMode(GridCacheDistributionMode.PARTITIONED_ONLY);
@@ -365,7 +366,7 @@ public class GridBasicWarmupClosure implements IgniteInClosure<IgniteConfigurati
if (F.isEmpty(reduced))
return null;
- GridCacheConfiguration[] res = new GridCacheConfiguration[reduced.size()];
+ CacheConfiguration[] res = new CacheConfiguration[reduced.size()];
reduced.toArray(res);
@@ -381,8 +382,8 @@ public class GridBasicWarmupClosure implements IgniteInClosure<IgniteConfigurati
* @param ccfg Cache configuration to match.
* @return {@code True} if matching configuration is found, {@code false} otherwise.
*/
- private boolean matches(Iterable<GridCacheConfiguration> reduced, GridCacheConfiguration ccfg) {
- for (GridCacheConfiguration ccfg0 : reduced) {
+ private boolean matches(Iterable<CacheConfiguration> reduced, CacheConfiguration ccfg) {
+ for (CacheConfiguration ccfg0 : reduced) {
if (matches(ccfg0, ccfg))
return true;
}
@@ -397,7 +398,7 @@ public class GridBasicWarmupClosure implements IgniteInClosure<IgniteConfigurati
* @param ccfg1 Second configuration.
* @return {@code True} if configurations match.
*/
- private boolean matches(GridCacheConfiguration ccfg0, GridCacheConfiguration ccfg1) {
+ private boolean matches(CacheConfiguration ccfg0, CacheConfiguration ccfg1) {
return
F.eq(ccfg0.getCacheMode(), ccfg1.getCacheMode()) &&
F.eq(ccfg0.getBackups(), ccfg1.getBackups()) &&
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/gridgain/grid/cache/GridCache.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/gridgain/grid/cache/GridCache.java b/modules/core/src/main/java/org/gridgain/grid/cache/GridCache.java
index 95a002b..d003bf1 100644
--- a/modules/core/src/main/java/org/gridgain/grid/cache/GridCache.java
+++ b/modules/core/src/main/java/org/gridgain/grid/cache/GridCache.java
@@ -18,6 +18,7 @@
package org.gridgain.grid.cache;
import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
import org.apache.ignite.lang.*;
import org.apache.ignite.transactions.*;
import org.gridgain.grid.cache.affinity.*;
@@ -65,7 +66,7 @@ public interface GridCache<K, V> extends GridCacheProjection<K, V> {
*
* @return Configuration bean for this cache.
*/
- public GridCacheConfiguration configuration();
+ public CacheConfiguration configuration();
/**
* Registers transactions synchronizations for all transactions started by this cache.
@@ -251,7 +252,7 @@ public interface GridCache<K, V> extends GridCacheProjection<K, V> {
/**
* Forces this cache node to re-balance its partitions. This method is usually used when
- * {@link GridCacheConfiguration#getPreloadPartitionedDelay()} configuration parameter has non-zero value.
+ * {@link org.apache.ignite.cache.CacheConfiguration#getPreloadPartitionedDelay()} configuration parameter has non-zero value.
* When many nodes are started or stopped almost concurrently, it is more efficient to delay
* preloading until the node topology is stable to make sure that no redundant re-partitioning
* happens.
@@ -259,12 +260,12 @@ public interface GridCache<K, V> extends GridCacheProjection<K, V> {
* In case of{@link GridCacheMode#PARTITIONED} caches, for better efficiency user should
* usually make sure that new nodes get placed on the same place of consistent hash ring as
* the left nodes, and that nodes are restarted before
- * {@link GridCacheConfiguration#getPreloadPartitionedDelay() preloadDelay} expires. To place nodes
+ * {@link org.apache.ignite.cache.CacheConfiguration#getPreloadPartitionedDelay() preloadDelay} expires. To place nodes
* on the same place in consistent hash ring, use
* {@link GridCacheConsistentHashAffinityFunction#setHashIdResolver(GridCacheAffinityNodeHashResolver)} to make sure that
* a node maps to the same hash ID if re-started.
* <p>
- * See {@link GridCacheConfiguration#getPreloadPartitionedDelay()} for more information on how to configure
+ * See {@link org.apache.ignite.cache.CacheConfiguration#getPreloadPartitionedDelay()} for more information on how to configure
* preload re-partition delay.
* <p>
* @return Future that will be completed when preloading is finished.
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b0d8a67a/modules/core/src/main/java/org/gridgain/grid/cache/GridCacheAtomicityMode.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/gridgain/grid/cache/GridCacheAtomicityMode.java b/modules/core/src/main/java/org/gridgain/grid/cache/GridCacheAtomicityMode.java
index 8098409..21cf540 100644
--- a/modules/core/src/main/java/org/gridgain/grid/cache/GridCacheAtomicityMode.java
+++ b/modules/core/src/main/java/org/gridgain/grid/cache/GridCacheAtomicityMode.java
@@ -26,7 +26,7 @@ import org.jetbrains.annotations.*;
* used whenever transactions and explicit locking are not needed. Note that in {@link #ATOMIC}
* mode cache will still maintain full data consistency across all cache nodes.
* <p>
- * Cache atomicity may be set via {@link GridCacheConfiguration#getAtomicityMode()}
+ * Cache atomicity may be set via {@link org.apache.ignite.cache.CacheConfiguration#getAtomicityMode()}
* configuration property.
*/
public enum GridCacheAtomicityMode {