org.apache.ignite.internal.processors.cache.distributed.dht.colocated

Class GridDhtColocatedCache<K,V>

java.lang.Object

org.apache.ignite.internal.processors.cache.GridCacheAdapter<K,V>

org.apache.ignite.internal.processors.cache.distributed.GridDistributedCacheAdapter<K,V>

org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtCacheAdapter<K,V>

org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter<K,V>

org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache<K,V>

All Implemented Interfaces:

Externalizable, Serializable, Iterable<javax.cache.Cache.Entry<K,V>>, GridCache<K,V>, CacheProjection<K,V>, GridCacheProjectionEx<K,V>

public class GridDhtColocatedCache<K,V>
extends GridDhtTransactionalCacheAdapter<K,V>

Colocated cache.

See Also:

Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter

GridCacheAdapter.AsyncOp<T>, GridCacheAdapter.CacheExpiryPolicy, GridCacheAdapter.FutureHolder, GridCacheAdapter.UpdateGetTimeStatClosure<T>, GridCacheAdapter.UpdatePutAndGetTimeStatClosure<T>, GridCacheAdapter.UpdatePutTimeStatClosure<T>, GridCacheAdapter.UpdateRemoveTimeStatClosure<T>, GridCacheAdapter.UpdateTimeStatClosure<T>

Field Summary

Fields inherited from class org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtCacheAdapter

preldr

Fields inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter

cacheCfg, CLEAR_ALL_SPLIT_THRESHOLD, ctx, gridCfg, keyCheck, lastFut, locNodeId, log, map, metrics, mxBean, RET2NULL

Constructor Summary

Constructors

Constructor and Description
GridDhtColocatedCache() Empty constructor required for Externalizable
GridDhtColocatedCache(GridCacheContext<K,V> ctx)
GridDhtColocatedCache(GridCacheContext<K,V> ctx, GridCacheConcurrentMap map) Creates colocated cache with specified map.

Method Summary

Methods

Modifier and Type	Method and Description
javax.cache.Cache.Entry<K,V>	entry(K key) Gets entry from cache with the specified key.
protected GridCacheEntryEx	entryExSafe(KeyCacheObject key, long topVer)
GridDistributedCacheEntry	entryExx(KeyCacheObject key, long topVer, boolean allowDetached) Gets or creates entry for given key and given topology version.
IgniteInternalFuture<Map<K,V>>	getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx entry, UUID subjId, String taskName, boolean deserializePortable, boolean skipVals) This method is used internally.
protected void	init() Post constructor initialization for subclasses.
boolean	isColocated()
boolean	isLocked(K key) Checks if any node owns a lock for this key.
boolean	isLockedByThread(K key) Checks if current thread owns a lock on this key.
IgniteInternalFuture<Map<K,V>>	loadAsync(Collection<KeyCacheObject> keys, boolean readThrough, boolean reload, boolean forcePrimary, long topVer, UUID subjId, String taskName, boolean deserializePortable, IgniteCacheExpiryPolicy expiryPlc, boolean skipVals)
IgniteInternalFuture<Boolean>	lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isInvalidate, boolean isRead, boolean retval, TransactionIsolation isolation, long accessTtl, CacheEntryPredicate[] filter) This is an entry point to pessimistic locking within transaction.
GridNearTransactionalCache<K,V>	near()
V	peek(K key, Collection<GridCachePeekMode> modes) Peeks at cached value using optional set of peek modes.
void	removeLocks(long threadId, GridCacheVersion ver, Collection<KeyCacheObject> keys) Removes locks regardless of whether they are owned or not for given version and keys.
void	start() Starts this cache.
String	toString()
void	unlockAll(Collection<? extends K> keys, CacheEntryPredicate[] filter) Unlocks given keys only if current thread owns the locks.

Methods inherited from class org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter

lockAllAsync, lockAllAsyncInternal, processDhtLockRequest, processDhtLockRequest0, processDhtUnlockRequest, removeLocks

Methods inherited from class org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtCacheAdapter

beginMultiUpdate, dhtPreloader, endMultiUpdate, entryEx, entryEx, entryExx, entryExx, entryExx, entrySet, getDhtAsync, localEntriesIterator, localLoad, localLoadCache, multiUpdateFinishFuture, multiUpdateTopologyFuture, onDeferredDelete, onKernalStart, onKernalStop, peekExx, preloader, primarySize, printMemoryStats, processNearGetRequest, reload, sendTtlUpdateRequest, splitClearLocally, stop, topology

Methods inherited from class org.apache.ignite.internal.processors.cache.distributed.GridDistributedCacheAdapter

lockAllAsync, removeAll, removeAllAsync, removeVersionedEntry, txLockAsync

Methods inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter

affinity, allEntries, asyncOp, asyncOpAcquire, asyncOpRelease, awaitLastFut, cache, checkJta, clear, clear, clear, clearAll, clearAsync, clearAsync, clearAsync, clearLocally, clearLocally, clearLocally, clearLocally0, clearLocally0, clearLocallyAll, commitTxAsync, configuration, containsKey, containsKeyAsync, containsKeys, containsKeysAsync, containsValue, context, entries, entryEx, entryEx, entrySet, entrySet, entrySetx, evict, evict, evictAll, evictAll, evictAll, expiry, expiryPolicy, flags, flagsOff, flagsOn, forceRepartition, forSubjectId, get, get, get, getAll, getAll, getAllAsync, getAllAsync, getAllAsync, getAllAsync0, getAllOutTx, getAllOutTxAsync, getAsync, getAsync, getForcePrimary, getForcePrimaryAsync, globalPrimarySize, globalSize, gridProjection, igfsDataSpaceMax, igfsDataSpaceUsed, igniteIterator, invoke, invokeAll, invokeAll, invokeAllAsync, invokeAllAsync, invokeAsync, isDht, isDhtAtomic, isEmpty, isIgfsDataCache, isLocal, isMongoDataCache, isMongoMetaCache, isNear, iterator, iterator, keepPortable, keepPortable0, keySet, keySet, loadAll, localEntries, localLoadCacheAsync, localPeek, localRemoveAll, localRemoveAll, localSize, lock, lockAll, lockAsync, log, map, metrics, metrics0, mxBean, name, nearSize, offHeapAllocatedSize, offHeapEntriesCount, offHeapIterator, onIgfsDataSizeChanged, onUndeploy, overflowSize, peek, peek, peek0, peek0, peek0, peekAll0, peekEx, peekEx, predicate, primaryEntrySet, primaryEntrySet, primaryEntrySetx, primaryKeySet, primaryKeySet, primaryValues, primaryValues, projection, projection, promote, promote, promoteAll, put, put, putAll, putAllAsync, putAllConflict, putAllConflictAsync, putAsync, putAsync, putIfAbsent, putIfAbsentAsync, putx, putx, putxAsync, putxAsync, putxIfAbsent, putxIfAbsentAsync, queries, randomEntry, readExternal, readResolve, readThroughAllAsync, reloadAllAsync0, reloadAsync, remove, remove, remove, removeAll, removeAllAsync, removeAllConflict, removeAllConflictAsync, removeAsync, removeAsync, removeAsync, removeEntry, removeIfObsolete, removex, removex, removex, removexAsync, removexAsync, removexAsync, replace, replace, replaceAsync, replaceAsync, replacex, replacex, replacexAsync, replacexAsync, saveFuture, size, size, sizeAsync, startInfo, stopInfo, swapIterator, swapKeys, swapSize, toMap, tx, txStart, txStart, txStart, txStartEx, txSynchronizations, txSynchronize, txUnsynchronize, unlock, validateCacheKey, validateCacheKeys, values, values, withExpiryPolicy, writeExternal

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

GridDhtColocatedCache

public GridDhtColocatedCache()

Empty constructor required for Externalizable

GridDhtColocatedCache

public GridDhtColocatedCache(GridCacheContext<K,V> ctx)

Parameters:

ctx - Cache context.

GridDhtColocatedCache

public GridDhtColocatedCache(GridCacheContext<K,V> ctx,
                     GridCacheConcurrentMap map)

Creates colocated cache with specified map.

Parameters:

ctx - Cache context.

map - Cache map.

Method Detail

isColocated

public boolean isColocated()

Overrides:

isColocated in class GridCacheAdapter<K,V>

Returns:

True if cache is colocated.

init

protected void init()

Post constructor initialization for subclasses.

Overrides:

init in class GridDhtCacheAdapter<K,V>

start

public void start()
           throws IgniteCheckedException

Starts this cache. Child classes should override this method to provide custom start-up behavior.

Overrides:

start in class GridDhtTransactionalCacheAdapter<K,V>

Throws:

IgniteCheckedException - If start failed.

entryExx

public GridDistributedCacheEntry entryExx(KeyCacheObject key,
                                 long topVer,
                                 boolean allowDetached)

Gets or creates entry for given key and given topology version.

Parameters:

key - Key for entry.

topVer - Topology version.

allowDetached - Whether to allow detached entries. If true and node is not primary for given key, a new detached entry will be created. Otherwise, entry will be obtained from dht cache map.

Returns:

Cache entry.

Throws:

GridDhtInvalidPartitionException - If allowDetached is false and node is not primary for given key.

peek

public V peek(K key,
     @Nullable
     Collection<GridCachePeekMode> modes)
       throws IgniteCheckedException

Peeks at cached value using optional set of peek modes. This method will sequentially iterate over given peek modes in the order passed in, and try to peek at value using each peek mode. Once a non-null value is found, it will be immediately returned.

Note that if modes are not provided this method works exactly the same way as CacheProjection.peek(Object), implicitly using GridCachePeekMode.SMART mode.

Transactions

This method does not participate in any transactions, however, it may peek at transactional value depending on the peek modes used.

Specified by:

peek in interface CacheProjection<K,V>

Overrides:

peek in class GridCacheAdapter<K,V>

Parameters:

key - Entry key.

modes - Optional set of peek modes.

Returns:

Peeked value.

Throws:

IgniteCheckedException - If peek operation failed.

isLocked

public boolean isLocked(K key)

Checks if any node owns a lock for this key.

This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.

Specified by:

isLocked in interface CacheProjection<K,V>

Overrides:

isLocked in class GridCacheAdapter<K,V>

Parameters:

key - Key to check.

Returns:

True if lock is owned by some node.

isLockedByThread

public boolean isLockedByThread(K key)

Checks if current thread owns a lock on this key.

This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.

Specified by:

isLockedByThread in interface CacheProjection<K,V>

Overrides:

isLockedByThread in class GridCacheAdapter<K,V>

Parameters:

key - Key to check.

Returns:

True if key is locked by current thread.

getAllAsync

public IgniteInternalFuture<Map<K,V>> getAllAsync(@Nullable
                                         Collection<? extends K> keys,
                                         boolean forcePrimary,
                                         boolean skipTx,
                                         @Nullable
                                         GridCacheEntryEx entry,
                                         @Nullable
                                         UUID subjId,
                                         String taskName,
                                         boolean deserializePortable,
                                         boolean skipVals)

This method is used internally. Use #getDhtAsync(UUID, long, LinkedHashMap, boolean, boolean, long, UUID, int, boolean, IgniteCacheExpiryPolicy, boolean) method instead to retrieve DHT value.

Overrides:

getAllAsync in class GridDhtCacheAdapter<K,V>

Parameters:

keys -

forcePrimary -

skipTx -

Returns:

entryExSafe

protected GridCacheEntryEx entryExSafe(KeyCacheObject key,
                           long topVer)

Overrides:

entryExSafe in class GridCacheAdapter<K,V>

Parameters:

key - Key.

topVer - Topology version.

Returns:

Entry.

loadAsync

public IgniteInternalFuture<Map<K,V>> loadAsync(@Nullable
                                       Collection<KeyCacheObject> keys,
                                       boolean readThrough,
                                       boolean reload,
                                       boolean forcePrimary,
                                       long topVer,
                                       @Nullable
                                       UUID subjId,
                                       String taskName,
                                       boolean deserializePortable,
                                       @Nullable
                                       IgniteCacheExpiryPolicy expiryPlc,
                                       boolean skipVals)

Parameters:

keys - Keys to load.

readThrough - Read through flag.

reload - Reload flag.

forcePrimary - Force get from primary node flag.

topVer - Topology version.

subjId - Subject ID.

taskName - Task name.

deserializePortable - Deserialize portable flag.

expiryPlc - Expiry policy.

skipVals - Skip values flag.

Returns:

Loaded values.

lockAllAsync

public IgniteInternalFuture<Boolean> lockAllAsync(Collection<KeyCacheObject> keys,
                                         long timeout,
                                         @Nullable
                                         IgniteTxLocalEx tx,
                                         boolean isInvalidate,
                                         boolean isRead,
                                         boolean retval,
                                         @Nullable
                                         TransactionIsolation isolation,
                                         long accessTtl,
                                         CacheEntryPredicate[] filter)

This is an entry point to pessimistic locking within transaction.

Overrides:

lockAllAsync in class GridDhtTransactionalCacheAdapter<K,V>

Parameters:

keys - Keys to lock.

timeout - Timeout.

tx - Transaction

isInvalidate - Invalidation flag.

isRead - Indicates whether value is read or written.

retval - Flag to return value.

isolation - Transaction isolation.

accessTtl - TTL for read operation.

filter - Optional filter.

Returns:

Future for locks.

near

public GridNearTransactionalCache<K,V> near()

Specified by:

near in class GridDhtTransactionalCacheAdapter<K,V>

Returns:

Near cache.

entry

public javax.cache.Cache.Entry<K,V> entry(K key)
                                   throws GridDhtInvalidPartitionException

Gets entry from cache with the specified key. The returned entry can be used even after entry key has been removed from cache. In that case, every operation on returned entry will result in creation of a new entry.

Note that this method can return null if projection is configured as pre-filtered and entry key and value don't pass key-value filter of the projection.

Specified by:

entry in interface CacheProjection<K,V>

Overrides:

entry in class GridDhtCacheAdapter<K,V>

Parameters:

key - Entry key.

Returns:

Cache entry or null if projection pre-filtering was not passed.

Throws:

GridDhtInvalidPartitionException - If partition for the key is no longer valid.

unlockAll

public void unlockAll(Collection<? extends K> keys,
             CacheEntryPredicate[] filter)

Unlocks given keys only if current thread owns the locks. Only the keys that have been locked by calling thread and pass through the filter (if any) will be unlocked. If none of the key locks is owned by current thread, then this method will do nothing.

Transactions

Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use TransactionConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.

Cache Flags

This method is not available if any of the following flags are set on projection: CacheFlag.LOCAL, CacheFlag.READ.

Specified by:

unlockAll in interface CacheProjection<K,V>

Overrides:

unlockAll in class GridDhtCacheAdapter<K,V>

Parameters:

keys - Keys to unlock.

filter - Optional filter which needs to pass for individual entries to be unlocked.

removeLocks

public void removeLocks(long threadId,
               GridCacheVersion ver,
               Collection<KeyCacheObject> keys)

Removes locks regardless of whether they are owned or not for given version and keys.

Parameters:

threadId - Thread ID.

ver - Lock version.

keys - Keys.

toString

public String toString()

Overrides:

toString in class GridDhtCacheAdapter<K,V>