org.apache.ignite.internal.processors.cache.transactions

Class IgniteTxLocalAdapter

java.lang.Object

org.apache.ignite.internal.util.lang.GridMetadataAwareAdapter

org.apache.ignite.internal.processors.cache.transactions.IgniteTxAdapter

org.apache.ignite.internal.processors.cache.transactions.IgniteTxLocalAdapter

All Implemented Interfaces:

Externalizable, Serializable, AutoCloseable, IgniteInternalTx, IgniteTxLocalEx, GridTimeoutObject

Direct Known Subclasses:

GridDhtTxLocalAdapter

public abstract class IgniteTxLocalAdapter
extends IgniteTxAdapter
implements IgniteTxLocalEx

Transaction adapter for cache transactions.

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	IgniteTxLocalAdapter.FinishClosure<T> Post-lock closure.
protected class	IgniteTxLocalAdapter.PLC1<T> Post-lock closure alias.
protected class	IgniteTxLocalAdapter.PLC2<T> Post-lock closure alias.
protected class	IgniteTxLocalAdapter.PMC<T> Post-lock closure alias.
protected class	IgniteTxLocalAdapter.PostLockClosure1<T> Post-lock closure.
protected class	IgniteTxLocalAdapter.PostLockClosure2<T> Post-lock closure.
protected class	IgniteTxLocalAdapter.PostMissClosure<T> Post-lock closure.

Nested classes/interfaces inherited from interface org.apache.ignite.internal.processors.cache.transactions.IgniteInternalTx

IgniteInternalTx.FinalizationStatus

Field Summary

Fields

Modifier and Type	Field and Description
protected Set<Integer>	activeCacheIds Active cache IDs.
protected AtomicReference<Throwable>	commitErr Commit error.
protected AtomicBoolean	doneFlag Flag indicating with TM commit happened.
protected GridCacheReturn	implicitRes Implicit transaction result.
protected GridCacheVersion	minVer Minimal version encountered (either explicit lock or XID of this transaction).
protected boolean	needRetVal Need return value.
protected IgniteTxMap	readView Read view on transaction map.
protected Map<IgniteTxKey,IgniteTxEntry>	txMap Per-transaction read map.
protected IgniteTxMap	writeView Write view on transaction map.

Fields inherited from class org.apache.ignite.internal.processors.cache.transactions.IgniteTxAdapter

cctx, concurrency, endVer, grpLockKey, implicit, implicitSingle, internal, invalidate, isDone, isolation, loc, log, nodeId, onePhaseCommit, startTime, startVer, storeEnabled, subjId, syncCommit, syncRollback, taskName, taskNameHash, threadId, timeout, transform, txNodes, txSize, writeVer, xidVer

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	IgniteTxLocalAdapter() Empty constructor required for Externalizable.
protected	IgniteTxLocalAdapter(GridCacheSharedContext cctx, GridCacheVersion xidVer, boolean implicit, boolean implicitSingle, boolean sys, GridIoPolicy plc, TransactionConcurrency concurrency, TransactionIsolation isolation, long timeout, boolean invalidate, boolean storeEnabled, int txSize, IgniteTxKey grpLockKey, boolean partLock, UUID subjId, int taskNameHash)

Method Summary

Methods

Modifier and Type	Method and Description
protected IgniteCacheExpiryPolicy	accessPolicy(GridCacheContext ctx, IgniteTxKey key, javax.cache.expiry.ExpiryPolicy expiryPlc)
Collection<Integer>	activeCacheIds() Gets collection of active cache IDs for this transaction.
protected void	addActiveCache(GridCacheContext cacheCtx) Adds cache to the list of active caches in transaction.
protected IgniteTxEntry	addEntry(GridCacheOperation op, CacheObject val, javax.cache.processor.EntryProcessor entryProcessor, Object[] invokeArgs, GridCacheEntryEx entry, javax.cache.expiry.ExpiryPolicy expiryPlc, CacheEntryPredicate[] filter, boolean filtersSet, long drTtl, long drExpireTime, GridCacheVersion drVer)
protected void	addGroupTxMapping(Collection<IgniteTxKey> keys) Adds key mapping to transaction.
Collection<IgniteTxEntry>	allEntries()
Collection<GridCacheVersion>	alternateVersions()
protected void	batchStoreCommit(Iterable<IgniteTxEntry> writeEntries) Performs batch database operations.
protected void	checkValid() Checks transaction expiration.
void	commit() Commits this transaction by initiating two-phase-commit process.
protected boolean	commitAfterLock()
Throwable	commitError()
void	commitError(Throwable e)
Collection<GridCacheVersion>	committedVersions()
GridCacheVersion	completedBase()
void	completedVersions(GridCacheVersion completedBase, Collection<GridCacheVersion> committedVers, Collection<GridCacheVersion> rolledbackVers)
boolean	empty()
protected <K,V> IgniteInternalFuture<Set<KeyCacheObject>>	enlistWrite(GridCacheContext cacheCtx, Collection<?> keys, GridCacheEntryEx cached, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean implicit, Map<?,?> lookup, Map<?,javax.cache.processor.EntryProcessor<K,V,Object>> invokeMap, Object[] invokeArgs, boolean retval, boolean lockOnly, CacheEntryPredicate[] filter, GridCacheReturn ret, Collection<KeyCacheObject> enlisted, Map<KeyCacheObject,GridCacheDrInfo> drPutMap, Map<KeyCacheObject,GridCacheVersion> drRmvMap) Internal routine for putAll(..)
IgniteTxEntry	entry(IgniteTxKey key)
protected GridCacheEntryEx	entryEx(GridCacheContext cacheCtx, IgniteTxKey key) Gets cache entry for given key.
protected GridCacheEntryEx	entryEx(GridCacheContext cacheCtx, IgniteTxKey key, long topVer) Gets cache entry for given key and topology version.
long	entryExpireTime(IgniteTxKey key)
long	entryTtl(IgniteTxKey key)
UUID	eventNodeId()
<K,V> IgniteInternalFuture<Map<K,V>>	getAllAsync(GridCacheContext cacheCtx, Collection<KeyCacheObject> keys, GridCacheEntryEx cached, boolean deserializePortable, boolean skipVals, boolean keepCacheObjects)
<K> IgniteInternalFuture<?>	groupLockAsync(GridCacheContext cacheCtx, Collection<K> keys) Performs keys locking for affinity-based group lock transactions.
boolean	hasWriteKey(IgniteTxKey key)
GridCacheReturn	implicitSingleResult()
void	implicitSingleResult(GridCacheReturn ret)
boolean	init() Initializes read map.
protected void	initResult() Creates result instance.
<K,V,T> IgniteInternalFuture<GridCacheReturn>	invokeAsync(GridCacheContext cacheCtx, Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,Object>> map, Object... invokeArgs)
boolean	isStarted()
IgniteInternalFuture<Boolean>	loadMissing(GridCacheContext cacheCtx, boolean readThrough, boolean async, Collection<KeyCacheObject> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<KeyCacheObject,Object> c)
Collection<UUID>	masterNodeIds()
GridCacheVersion	minVersion() Gets minimum version present in transaction.
boolean	needReturnValue()
void	needReturnValue(boolean needRetVal)
boolean	onOwnerChanged(GridCacheEntryEx entry, GridCacheMvccCandidate owner) Callback invoked whenever there is a lock that has been acquired by this transaction for any of the participating entries.
UUID	originatingNodeId() Gets node ID which directly started this transaction.
boolean	partitionLock()
<K,V> GridTuple<CacheObject>	peek(GridCacheContext cacheCtx, boolean failFast, KeyCacheObject key, CacheEntryPredicate[] filter)
protected Set<KeyCacheObject>	postLockWrite(GridCacheContext cacheCtx, Iterable<KeyCacheObject> keys, Set<KeyCacheObject> failed, GridCacheReturn ret, boolean rmv, boolean retval, boolean read, long accessTtl, CacheEntryPredicate[] filter, boolean computeInvoke) Post lock processing for put or remove.
void	prepare() Prepare state.
<K,V> IgniteInternalFuture<GridCacheReturn>	putAllAsync(GridCacheContext cacheCtx, Map<? extends K,? extends V> map, boolean retval, GridCacheEntryEx cached, long ttl, CacheEntryPredicate[] filter)
IgniteInternalFuture<?>	putAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheDrInfo> drMap)
Collection<IgniteTxEntry>	readEntries()
Map<IgniteTxKey,IgniteTxEntry>	readMap()
Set<IgniteTxKey>	readSet()
<K,V> IgniteInternalFuture<GridCacheReturn>	removeAllAsync(GridCacheContext cacheCtx, Collection<? extends K> keys, GridCacheEntryEx cached, boolean retval, CacheEntryPredicate[] filter)
IgniteInternalFuture<?>	removeAllDrAsync(GridCacheContext cacheCtx, Map<KeyCacheObject,GridCacheVersion> drMap)
boolean	removed(IgniteTxKey key) Checks whether given key has been removed within transaction.
Collection<GridCacheVersion>	rolledbackVersions()
void	seal() Seals transaction for updates.
void	sendTransformedValues(boolean snd)
void	tmCommit() Commits transaction to transaction manager.
String	toString()
protected void	updateExplicitVersion(IgniteTxEntry txEntry, GridCacheEntryEx entry) Updates explicit version for tx entry based on current entry lock owner.
void	userCommit()
void	userPrepare()
void	userRollback()
Collection<IgniteTxEntry>	writeEntries()
Map<IgniteTxKey,IgniteTxEntry>	writeMap()
Set<IgniteTxKey>	writeSet()

Methods inherited from class org.apache.ignite.internal.processors.cache.transactions.IgniteTxAdapter

addInvalidPartition, applyTransformClosures, awaitCompletion, awaitSignal, checkInternal, close, colocated, commitVersion, commitVersion, concurrency, conflictResolve, dht, done, endTime, endVersion, endVersion, enforceSerializable, equals, evictNearEntry, finalizationStatus, finishFuture, groupLock, groupLockEntry, groupLockKey, hashCode, hasTransforms, implicit, implicitSingle, initCommitVersion, internal, invalidate, invalidPartitions, ioPolicy, isInvalidate, isNearLocallyMapped, isolation, isRollbackOnly, isSystemInvalidate, local, localResult, lock, lockTimeout, log, markFinalizing, markPreparing, near, nearXidVersion, needsCompletedVersions, nodeId, onePhaseCommit, onePhaseCommit, onTimeout, optimistic, optimisticLockEntries, otherNodeId, ownedVersion, ownsLock, ownsLockUnsafe, pessimistic, proxy, readCommitted, readExternal, readResolve, remainingTime, repeatableRead, replicated, resolveTaskName, serializable, setRollbackOnly, signalAll, size, startTime, startVersion, state, state, store, storeEnabled, storeEnabled, storeUsed, subjectId, syncCommit, syncCommit, syncRollback, syncRollback, system, systemInvalidate, taskNameHash, threadId, timedOut, timeout, timeout, timeoutId, topologyVersion, topologyVersion, transactionNodes, transactionNodes, uncommit, unlock, updateNearCache, user, writeExternal, writeVersion, writeVersion, xid, xidVersion

Methods inherited from class org.apache.ignite.internal.util.lang.GridMetadataAwareAdapter

addMeta, addMetaIfAbsent, addMetaIfAbsent, allMeta, clone, copyMeta, copyMeta, hasMeta, hasMeta, meta, putMetaIfAbsent, readExternalMeta, removeMeta, removeMeta, replaceMeta, writeExternalMeta

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.ignite.internal.processors.cache.transactions.IgniteTxLocalEx

finish, groupLockEntry

Methods inherited from interface org.apache.ignite.internal.processors.cache.transactions.IgniteInternalTx

addInvalidPartition, addMeta, close, colocated, commitAsync, commitVersion, commitVersion, concurrency, dht, done, endVersion, endVersion, enforceSerializable, finishFuture, groupLock, groupLockKey, hasTransforms, implicit, implicitSingle, internal, invalidate, invalidPartitions, ioPolicy, isInvalidate, isolation, isRollbackOnly, isSystemInvalidate, local, localResult, markFinalizing, markPreparing, meta, near, nearXidVersion, needsCompletedVersions, nodeId, onePhaseCommit, optimistic, optimisticLockEntries, otherNodeId, ownedVersion, ownsLock, ownsLockUnsafe, pessimistic, prepareAsync, proxy, readCommitted, remainingTime, removeMeta, repeatableRead, replicated, rollback, rollbackAsync, serializable, setRollbackOnly, size, startTime, startVersion, state, state, storeEnabled, storeUsed, subjectId, syncCommit, syncRollback, system, systemInvalidate, taskNameHash, threadId, timedOut, timeout, timeout, topologyVersion, topologyVersion, transactionNodes, user, writeVersion, writeVersion, xid, xidVersion

Methods inherited from interface org.apache.ignite.internal.processors.timeout.GridTimeoutObject

endTime, onTimeout, timeoutId

Field Detail

txMap

@GridToStringExclude
protected Map<IgniteTxKey,IgniteTxEntry> txMap

Per-transaction read map.

readView

@GridToStringExclude
protected IgniteTxMap readView

Read view on transaction map.

writeView

@GridToStringExclude
protected IgniteTxMap writeView

Write view on transaction map.

minVer

protected GridCacheVersion minVer

Minimal version encountered (either explicit lock or XID of this transaction).

doneFlag

protected AtomicBoolean doneFlag

Flag indicating with TM commit happened.

commitErr

protected AtomicReference<Throwable> commitErr

Commit error.

activeCacheIds

protected Set<Integer> activeCacheIds

Active cache IDs.

needRetVal

protected boolean needRetVal

Need return value.

implicitRes

protected GridCacheReturn implicitRes

Implicit transaction result.

Constructor Detail

IgniteTxLocalAdapter

protected IgniteTxLocalAdapter()

Empty constructor required for Externalizable.

IgniteTxLocalAdapter

protected IgniteTxLocalAdapter(GridCacheSharedContext cctx,
                    GridCacheVersion xidVer,
                    boolean implicit,
                    boolean implicitSingle,
                    boolean sys,
                    GridIoPolicy plc,
                    TransactionConcurrency concurrency,
                    TransactionIsolation isolation,
                    long timeout,
                    boolean invalidate,
                    boolean storeEnabled,
                    int txSize,
                    @Nullable
                    IgniteTxKey grpLockKey,
                    boolean partLock,
                    @Nullable
                    UUID subjId,
                    int taskNameHash)

Parameters:

cctx - Cache registry.

xidVer - Transaction ID.

implicit - True if transaction was implicitly started by the system, false if it was started explicitly by user.

implicitSingle - True if transaction is implicit with only one key.

sys - System flag.

plc - IO policy.

concurrency - Concurrency.

isolation - Isolation.

timeout - Timeout.

txSize - Expected transaction size.

grpLockKey - Group lock key if this is a group-lock transaction.

partLock - True if this is a group-lock transaction and lock is acquired for whole partition.

Method Detail

initResult

protected void initResult()

Creates result instance.

eventNodeId

public UUID eventNodeId()

Specified by:

eventNodeId in interface IgniteInternalTx

Returns:

Event node ID.

originatingNodeId

public UUID originatingNodeId()

Gets node ID which directly started this transaction. In case of DHT local transaction it will be near node ID, in case of DHT remote transaction it will be primary node ID, in case of replicated remote transaction it will be starter node ID.

Specified by:

originatingNodeId in interface IgniteInternalTx

Returns:

Originating node ID.

empty

public boolean empty()

Specified by:

empty in interface IgniteInternalTx

Returns:

True if transaction is empty.

masterNodeIds

public Collection<UUID> masterNodeIds()

Specified by:

masterNodeIds in interface IgniteInternalTx

Returns:

Master node IDs.

partitionLock

public boolean partitionLock()

Specified by:

partitionLock in interface IgniteTxLocalEx

Returns:

True if keys from the same partition are allowed to be enlisted in group-lock transaction.

commitError

public Throwable commitError()

Specified by:

commitError in interface IgniteTxLocalEx

Returns:

Commit error.

commitError

public void commitError(Throwable e)

Specified by:

commitError in interface IgniteTxLocalEx

Parameters:

e - Commit error.

onOwnerChanged

public boolean onOwnerChanged(GridCacheEntryEx entry,
                     GridCacheMvccCandidate owner)

Callback invoked whenever there is a lock that has been acquired by this transaction for any of the participating entries.

Specified by:

onOwnerChanged in interface IgniteInternalTx

Parameters:

entry - Cache entry.

owner - Lock candidate that won ownership of the lock.

Returns:

True if transaction cared about notification.

activeCacheIds

public Collection<Integer> activeCacheIds()

Gets collection of active cache IDs for this transaction.

Specified by:

activeCacheIds in interface IgniteInternalTx

Returns:

Collection of active cache IDs.

isStarted

public boolean isStarted()

Specified by:

isStarted in class IgniteTxAdapter

Returns:

True if transaction has at least one key enlisted.

hasWriteKey

public boolean hasWriteKey(IgniteTxKey key)

Specified by:

hasWriteKey in interface IgniteInternalTx

Parameters:

key - Key to check.

Returns:

True if key is present.

readSet

public Set<IgniteTxKey> readSet()

Specified by:

readSet in interface IgniteInternalTx

Returns:

Transaction read set.

writeSet

public Set<IgniteTxKey> writeSet()

Specified by:

writeSet in interface IgniteInternalTx

Returns:

Transaction write set.

removed

public boolean removed(IgniteTxKey key)

Checks whether given key has been removed within transaction.

Specified by:

removed in interface IgniteInternalTx

Parameters:

key - Key to check.

Returns:

True if key has been removed.

readMap

public Map<IgniteTxKey,IgniteTxEntry> readMap()

Specified by:

readMap in interface IgniteInternalTx

Returns:

Transaction read map.

writeMap

public Map<IgniteTxKey,IgniteTxEntry> writeMap()

Specified by:

writeMap in interface IgniteInternalTx

Returns:

Transaction write map.

allEntries

public Collection<IgniteTxEntry> allEntries()

Specified by:

allEntries in interface IgniteInternalTx

Returns:

All transaction entries.

readEntries

public Collection<IgniteTxEntry> readEntries()

Specified by:

readEntries in interface IgniteInternalTx

Returns:

Read entries.

writeEntries

public Collection<IgniteTxEntry> writeEntries()

Specified by:

writeEntries in interface IgniteInternalTx

Returns:

Write entries.

entry

@Nullable
public IgniteTxEntry entry(IgniteTxKey key)

Specified by:

entry in interface IgniteInternalTx

Parameters:

key - Key for the entry.

Returns:

Entry for the key (either from write set or read set).

seal

public void seal()

Seals transaction for updates.

Specified by:

seal in interface IgniteInternalTx

implicitSingleResult

public GridCacheReturn implicitSingleResult()

Specified by:

implicitSingleResult in interface IgniteTxLocalEx

Returns:

Return value for

implicitSingleResult

public void implicitSingleResult(GridCacheReturn ret)

Parameters:

ret - Result.

needReturnValue

public boolean needReturnValue()

Returns:

Flag indicating whether transaction needs return value.

needReturnValue

public void needReturnValue(boolean needRetVal)

Parameters:

needRetVal - Need return value flag.

sendTransformedValues

public void sendTransformedValues(boolean snd)

Parameters:

snd - True if values in tx entries should be replaced with transformed values and sent to remote nodes.

commitAfterLock

protected boolean commitAfterLock()

Returns:

True if should be committed after lock is acquired.

peek

@Nullable
public <K,V> GridTuple<CacheObject> peek(GridCacheContext cacheCtx,
                                         boolean failFast,
                                         KeyCacheObject key,
                                         CacheEntryPredicate[] filter)
                            throws GridCacheFilterFailedException

Specified by:

peek in interface IgniteInternalTx

Parameters:

cacheCtx - Cache context.

failFast - Fail-fast flag.

key - Key to look up.

filter - Filter to check.

Returns:

Current value for the key within transaction.

Throws:

GridCacheFilterFailedException - If filter failed and failFast is true.

loadMissing

public IgniteInternalFuture<Boolean> loadMissing(GridCacheContext cacheCtx,
                                        boolean readThrough,
                                        boolean async,
                                        Collection<KeyCacheObject> keys,
                                        boolean deserializePortable,
                                        boolean skipVals,
                                        IgniteBiInClosure<KeyCacheObject,Object> c)

Specified by:

loadMissing in interface IgniteTxLocalEx

Parameters:

cacheCtx - Cache context.

readThrough - Read through flag.

async - if True, then loading will happen in a separate thread.

keys - Keys.

deserializePortable - Deserialize portable flag.

skipVals - Skip values flag.

c - Closure.

Returns:

Future with True value if loading took place.

minVersion

public GridCacheVersion minVersion()

Gets minimum version present in transaction.

Specified by:

minVersion in interface IgniteTxLocalEx

Returns:

Minimum versions.

userPrepare

public void userPrepare()
                 throws IgniteCheckedException

Throws:

IgniteCheckedException - If prepare step failed.

commit

public void commit()
            throws IgniteCheckedException

Commits this transaction by initiating two-phase-commit process.

Specified by:

commit in interface IgniteInternalTx

Throws:

IgniteCheckedException - If commit failed.

prepare

public void prepare()
             throws IgniteCheckedException

Prepare state.

Specified by:

prepare in interface IgniteInternalTx

Throws:

IgniteCheckedException - If failed.

entryEx

protected GridCacheEntryEx entryEx(GridCacheContext cacheCtx,
                       IgniteTxKey key)

Gets cache entry for given key.

Parameters:

cacheCtx - Cache context.

key - Key.

Returns:

Cache entry.

entryEx

protected GridCacheEntryEx entryEx(GridCacheContext cacheCtx,
                       IgniteTxKey key,
                       long topVer)

Gets cache entry for given key and topology version.

Parameters:

cacheCtx - Cache context.

key - Key.

topVer - Topology version.

Returns:

Cache entry.

batchStoreCommit

protected void batchStoreCommit(Iterable<IgniteTxEntry> writeEntries)
                         throws IgniteCheckedException

Performs batch database operations. This commit must be called before userCommit(). This way if there is a DB failure, cache transaction can still be rolled back.

Parameters:

writeEntries - Transaction write set.

Throws:

IgniteCheckedException - If batch update failed.

userCommit

public void userCommit()
                throws IgniteCheckedException

Specified by:

userCommit in interface IgniteTxLocalEx

Throws:

IgniteCheckedException - If commit failed.

tmCommit

public void tmCommit()

Commits transaction to transaction manager. Used for one-phase commit transactions only.

completedVersions

public void completedVersions(GridCacheVersion completedBase,
                     Collection<GridCacheVersion> committedVers,
                     Collection<GridCacheVersion> rolledbackVers)

Specified by:

completedVersions in interface IgniteInternalTx

Overrides:

completedVersions in class IgniteTxAdapter

Parameters:

completedBase - Base for committed versions.

committedVers - Committed transactions relative to base.

rolledbackVers - Rolled back transactions relative to base.

completedBase

public GridCacheVersion completedBase()

Returns:

Completed base for ordering.

committedVersions

public Collection<GridCacheVersion> committedVersions()

Returns:

Committed versions.

rolledbackVersions

public Collection<GridCacheVersion> rolledbackVersions()

Returns:

Rolledback versions.

userRollback

public void userRollback()
                  throws IgniteCheckedException

Specified by:

userRollback in interface IgniteTxLocalEx

Throws:

IgniteCheckedException - If rollback failed.

accessPolicy

protected IgniteCacheExpiryPolicy accessPolicy(GridCacheContext ctx,
                                   IgniteTxKey key,
                                   @Nullable
                                   javax.cache.expiry.ExpiryPolicy expiryPlc)

Parameters:

ctx - Cache context.

key - Key.

expiryPlc - Expiry policy.

Returns:

Expiry policy wrapper for entries accessed locally in optimistic transaction.

getAllAsync

public <K,V> IgniteInternalFuture<Map<K,V>> getAllAsync(GridCacheContext cacheCtx,
                                               Collection<KeyCacheObject> keys,
                                               @Nullable
                                               GridCacheEntryEx cached,
                                               boolean deserializePortable,
                                               boolean skipVals,
                                               boolean keepCacheObjects)

Specified by:

getAllAsync in interface IgniteTxLocalEx

Parameters:

cacheCtx - Cache context.

keys - Keys to get.

cached - Cached entry if this method is called from entry wrapper. Cached entry is passed if and only if there is only one key in collection of keys.

deserializePortable - Deserialize portable flag.

skipVals - Skip values flag.

keepCacheObjects - Keep cache objects

Returns:

Future for this get.

putAllAsync

public <K,V> IgniteInternalFuture<GridCacheReturn> putAllAsync(GridCacheContext cacheCtx,
                                                      Map<? extends K,? extends V> map,
                                                      boolean retval,
                                                      @Nullable
                                                      GridCacheEntryEx cached,
                                                      long ttl,
                                                      CacheEntryPredicate[] filter)

Specified by:

putAllAsync in interface IgniteTxLocalEx

Parameters:

cacheCtx - Cache context.

map - Map to put.

retval - Flag indicating whether a value should be returned.

cached - Cached entry, if any. Will be provided only if map has size 1.

ttl - Time to live for entry. If negative, leave unchanged.

filter - Filter.

Returns:

Future for put operation.

putAllDrAsync

public IgniteInternalFuture<?> putAllDrAsync(GridCacheContext cacheCtx,
                                    Map<KeyCacheObject,GridCacheDrInfo> drMap)

Specified by:

putAllDrAsync in interface IgniteTxLocalEx

Parameters:

cacheCtx - Cache context.

drMap - DR map to put.

Returns:

Future for DR put operation.

invokeAsync

public <K,V,T> IgniteInternalFuture<GridCacheReturn> invokeAsync(GridCacheContext cacheCtx,
                                                        @Nullable
                                                        Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,Object>> map,
                                                        Object... invokeArgs)

Specified by:

invokeAsync in interface IgniteTxLocalEx

Parameters:

cacheCtx - Cache context.

map - Entry processors map.

invokeArgs - Optional arguments for entry processor.

Returns:

Transform operation future.

removeAllDrAsync

public IgniteInternalFuture<?> removeAllDrAsync(GridCacheContext cacheCtx,
                                       Map<KeyCacheObject,GridCacheVersion> drMap)

Specified by:

removeAllDrAsync in interface IgniteTxLocalEx

Parameters:

cacheCtx - Cache context.

drMap - DR map.

Returns:

Future for asynchronous remove.

enlistWrite

protected <K,V> IgniteInternalFuture<Set<KeyCacheObject>> enlistWrite(GridCacheContext cacheCtx,
                                                          Collection<?> keys,
                                                          @Nullable
                                                          GridCacheEntryEx cached,
                                                          @Nullable
                                                          javax.cache.expiry.ExpiryPolicy expiryPlc,
                                                          boolean implicit,
                                                          @Nullable
                                                          Map<?,?> lookup,
                                                          @Nullable
                                                          Map<?,javax.cache.processor.EntryProcessor<K,V,Object>> invokeMap,
                                                          @Nullable
                                                          Object[] invokeArgs,
                                                          boolean retval,
                                                          boolean lockOnly,
                                                          CacheEntryPredicate[] filter,
                                                          GridCacheReturn ret,
                                                          Collection<KeyCacheObject> enlisted,
                                                          @Nullable
                                                          Map<KeyCacheObject,GridCacheDrInfo> drPutMap,
                                                          @Nullable
                                                          Map<KeyCacheObject,GridCacheVersion> drRmvMap)

Internal routine for putAll(..)

Parameters:

cacheCtx - Cache context.

keys - Keys to enlist.

cached - Cached entry.

expiryPlc - Explicitly specified expiry policy for entry.

implicit - Implicit flag.

lookup - Value lookup map (null for remove).

invokeMap - Map with entry processors for invoke operation.

invokeArgs - Optional arguments for EntryProcessor.

retval - Flag indicating whether a value should be returned.

lockOnly - If true, then entry will be enlisted as noop.

filter - User filters.

ret - Return value.

enlisted - Collection of keys enlisted into this transaction.

drPutMap - DR put map (optional).

drRmvMap - DR remove map (optional).

Returns:

Future with skipped keys (the ones that didn't pass filter for pessimistic transactions).

postLockWrite

protected Set<KeyCacheObject> postLockWrite(GridCacheContext cacheCtx,
                                Iterable<KeyCacheObject> keys,
                                Set<KeyCacheObject> failed,
                                GridCacheReturn ret,
                                boolean rmv,
                                boolean retval,
                                boolean read,
                                long accessTtl,
                                CacheEntryPredicate[] filter,
                                boolean computeInvoke)
                                     throws IgniteCheckedException

Post lock processing for put or remove.

Parameters:

cacheCtx - Context.

keys - Keys.

failed - Collection of potentially failed keys (need to populate in this method).

ret - Return value.

rmv - True if remove.

retval - Flag to return value or not.

read - True if read.

accessTtl - TTL for read operation.

filter - Filter to check entries.

computeInvoke - If true computes return value for invoke operation.

Returns:

Failed keys.

Throws:

IgniteCheckedException - If error.

removeAllAsync

public <K,V> IgniteInternalFuture<GridCacheReturn> removeAllAsync(GridCacheContext cacheCtx,
                                                         Collection<? extends K> keys,
                                                         @Nullable
                                                         GridCacheEntryEx cached,
                                                         boolean retval,
                                                         CacheEntryPredicate[] filter)

Specified by:

removeAllAsync in interface IgniteTxLocalEx

Parameters:

cacheCtx - Cache context.

keys - Keys to remove.

cached - Cached entry, if any. Will be provided only if size of keys collection is 1.

retval - Flag indicating whether a value should be returned.

filter - Filter.

Returns:

Future for asynchronous remove.

addGroupTxMapping

protected void addGroupTxMapping(Collection<IgniteTxKey> keys)

Adds key mapping to transaction.

Parameters:

keys - Keys to add.

groupLockAsync

public <K> IgniteInternalFuture<?> groupLockAsync(GridCacheContext cacheCtx,
                                         Collection<K> keys)

Performs keys locking for affinity-based group lock transactions.

Specified by:

groupLockAsync in interface IgniteTxLocalEx

Parameters:

cacheCtx - Cache context.

keys - Keys to lock.

Returns:

Lock future.

init

public boolean init()

Initializes read map.

Returns:

True if transaction was successfully started.

addActiveCache

protected void addActiveCache(GridCacheContext cacheCtx)
                       throws IgniteCheckedException

Adds cache to the list of active caches in transaction.

Parameters:

cacheCtx - Cache context to add.

Throws:

IgniteCheckedException - If caches already enlisted in this transaction are not compatible with given cache (e.g. they have different stores).

checkValid

protected void checkValid()
                   throws IgniteCheckedException

Checks transaction expiration.

Throws:

IgniteCheckedException - If transaction check failed.

alternateVersions

public Collection<GridCacheVersion> alternateVersions()

Specified by:

alternateVersions in interface IgniteInternalTx

Returns:

Alternate transaction versions.

addEntry

protected final IgniteTxEntry addEntry(GridCacheOperation op,
                     @Nullable
                     CacheObject val,
                     @Nullable
                     javax.cache.processor.EntryProcessor entryProcessor,
                     Object[] invokeArgs,
                     GridCacheEntryEx entry,
                     @Nullable
                     javax.cache.expiry.ExpiryPolicy expiryPlc,
                     CacheEntryPredicate[] filter,
                     boolean filtersSet,
                     long drTtl,
                     long drExpireTime,
                     @Nullable
                     GridCacheVersion drVer)

Parameters:

op - Cache operation.

val - Value.

expiryPlc - Explicitly specified expiry policy.

invokeArgs - Optional arguments for EntryProcessor.

entryProcessor - Entry processor.

entry - Cache entry.

filter - Filter.

filtersSet - True if filter should be marked as set.

drTtl - DR TTL (if any).

drExpireTime - DR expire time (if any).

drVer - DR version.

Returns:

Transaction entry.

updateExplicitVersion

protected void updateExplicitVersion(IgniteTxEntry txEntry,
                         GridCacheEntryEx entry)
                              throws GridCacheEntryRemovedException

Updates explicit version for tx entry based on current entry lock owner.

Parameters:

txEntry - Tx entry to update.

entry - Entry.

Throws:

GridCacheEntryRemovedException - If entry was concurrently removed.

toString

public String toString()

Overrides:

toString in class IgniteTxAdapter

entryTtl

public long entryTtl(IgniteTxKey key)

Parameters:

key - Key.

Returns:

Tx entry time to live.

entryExpireTime

public long entryExpireTime(IgniteTxKey key)

Parameters:

key - Key.

Returns:

Tx entry expire time.