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

Class IgniteTxLocalAdapter<K,V>

java.lang.Object

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

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

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

All Implemented Interfaces:

Externalizable, Serializable, AutoCloseable, IgniteInternalTx<K,V>, IgniteTxLocalEx<K,V>, GridTimeoutObject

Direct Known Subclasses:

GridDhtTxLocalAdapter

public abstract class IgniteTxLocalAdapter<K,V>
extends IgniteTxAdapter<K,V>
implements IgniteTxLocalEx<K,V>

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<V>	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<K,V>	readView Read view on transaction map.
protected Map<IgniteTxKey<K>,IgniteTxEntry<K,V>>	txMap Per-transaction read map.
protected IgniteTxMap<K,V>	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<K,V> cctx, GridCacheVersion xidVer, boolean implicit, boolean implicitSingle, boolean sys, 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<K> key, javax.cache.expiry.ExpiryPolicy expiryPlc)
Collection<Integer>	activeCacheIds() Gets collection of active cache IDs for this transaction.
protected void	addActiveCache(GridCacheContext<K,V> cacheCtx) Adds cache to the list of active caches in transaction.
protected IgniteTxEntry<K,V>	addEntry(GridCacheOperation op, V val, javax.cache.processor.EntryProcessor entryProcessor, Object[] invokeArgs, GridCacheEntryEx<K,V> entry, javax.cache.expiry.ExpiryPolicy expiryPlc, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter, boolean filtersSet, long drTtl, long drExpireTime, GridCacheVersion drVer)
protected void	addGroupTxMapping(Collection<IgniteTxKey<K>> keys) Adds key mapping to transaction.
Collection<IgniteTxEntry<K,V>>	allEntries()
Collection<GridCacheVersion>	alternateVersions()
protected void	batchStoreCommit(Iterable<IgniteTxEntry<K,V>> 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 IgniteInternalFuture<Set<K>>	enlistWrite(GridCacheContext<K,V> cacheCtx, Collection<? extends K> keys, GridCacheEntryEx<K,V> cached, javax.cache.expiry.ExpiryPolicy expiryPlc, boolean implicit, Map<? extends K,? extends V> lookup, Map<? extends K,javax.cache.processor.EntryProcessor<K,V,Object>> invokeMap, Object[] invokeArgs, boolean retval, boolean lockOnly, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter, GridCacheReturn<V> ret, Collection<K> enlisted, Map<? extends K,GridCacheDrInfo<V>> drPutMap, Map<? extends K,GridCacheVersion> drRmvMap) Internal routine for putAll(..)
IgniteTxEntry<K,V>	entry(IgniteTxKey<K> key)
protected GridCacheEntryEx<K,V>	entryEx(GridCacheContext<K,V> cacheCtx, IgniteTxKey<K> key) Gets cache entry for given key.
protected GridCacheEntryEx<K,V>	entryEx(GridCacheContext<K,V> cacheCtx, IgniteTxKey<K> key, long topVer) Gets cache entry for given key and topology version.
long	entryExpireTime(IgniteTxKey<K> key)
long	entryTtl(IgniteTxKey<K> key)
boolean	entryTtl(IgniteTxKey<K> key, long ttl)
UUID	eventNodeId()
IgniteInternalFuture<Map<K,V>>	getAllAsync(GridCacheContext<K,V> cacheCtx, Collection<? extends K> keys, GridCacheEntryEx<K,V> cached, boolean deserializePortable, boolean skipVals)
IgniteInternalFuture<?>	groupLockAsync(GridCacheContext<K,V> cacheCtx, Collection<K> keys) Performs keys locking for affinity-based group lock transactions.
boolean	hasWriteKey(IgniteTxKey<K> key)
GridCacheReturn<V>	implicitSingleResult()
void	implicitSingleResult(GridCacheReturn<V> ret)
boolean	init() Initializes read map.
<T> IgniteInternalFuture<GridCacheReturn<Map<K,javax.cache.processor.EntryProcessorResult<T>>>>	invokeAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,Object>> map, Object... invokeArgs)
boolean	isStarted()
IgniteInternalFuture<Boolean>	loadMissing(GridCacheContext<K,V> cacheCtx, boolean readThrough, boolean async, Collection<? extends K> keys, boolean deserializePortable, boolean skipVals, IgniteBiInClosure<K,V> c)
Collection<UUID>	masterNodeIds()
GridCacheVersion	minVersion() Gets minimum version present in transaction.
boolean	needReturnValue()
void	needReturnValue(boolean needRetVal)
boolean	onOwnerChanged(GridCacheEntryEx<K,V> entry, GridCacheMvccCandidate<K> 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()
GridTuple<V>	peek(GridCacheContext<K,V> cacheCtx, boolean failFast, K key, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)
protected Set<K>	postLockWrite(GridCacheContext<K,V> cacheCtx, Iterable<? extends K> keys, Set<K> failed, GridCacheReturn ret, boolean rmv, boolean retval, boolean read, long accessTtl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter, boolean computeInvoke) Post lock processing for put or remove.
void	prepare() Prepare state.
IgniteInternalFuture<GridCacheReturn<V>>	putAllAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,? extends V> map, boolean retval, GridCacheEntryEx<K,V> cached, long ttl, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)
IgniteInternalFuture<?>	putAllDrAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,GridCacheDrInfo<V>> drMap)
Collection<IgniteTxEntry<K,V>>	readEntries()
Map<IgniteTxKey<K>,IgniteTxEntry<K,V>>	readMap()
Set<IgniteTxKey<K>>	readSet()
IgniteInternalFuture<GridCacheReturn<V>>	removeAllAsync(GridCacheContext<K,V> cacheCtx, Collection<? extends K> keys, GridCacheEntryEx<K,V> cached, boolean retval, IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)
IgniteInternalFuture<?>	removeAllDrAsync(GridCacheContext<K,V> cacheCtx, Map<? extends K,GridCacheVersion> drMap)
boolean	removed(IgniteTxKey<K> 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<K,V> txEntry, GridCacheEntryEx<K,V> entry) Updates explicit version for tx entry based on current entry lock owner.
void	userCommit()
void	userPrepare()
void	userRollback()
Collection<IgniteTxEntry<K,V>>	writeEntries()
Map<IgniteTxKey<K>,IgniteTxEntry<K,V>>	writeMap()
Set<IgniteTxKey<K>>	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, 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, 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, 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<K>,IgniteTxEntry<K,V>> txMap

Per-transaction read map.

readView

@GridToStringExclude
protected IgniteTxMap<K,V> readView

Read view on transaction map.

writeView

@GridToStringExclude
protected IgniteTxMap<K,V> 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<V> implicitRes

Implicit transaction result.

Constructor Detail

IgniteTxLocalAdapter

protected IgniteTxLocalAdapter()

Empty constructor required for Externalizable.

IgniteTxLocalAdapter

protected IgniteTxLocalAdapter(GridCacheSharedContext<K,V> cctx,
                    GridCacheVersion xidVer,
                    boolean implicit,
                    boolean implicitSingle,
                    boolean sys,
                    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.

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

eventNodeId

public UUID eventNodeId()

Specified by:

eventNodeId in interface IgniteInternalTx<K,V>

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<K,V>

Returns:

Originating node ID.

empty

public boolean empty()

Specified by:

empty in interface IgniteInternalTx<K,V>

Returns:

True if transaction is empty.

masterNodeIds

public Collection<UUID> masterNodeIds()

Specified by:

masterNodeIds in interface IgniteInternalTx<K,V>

Returns:

Master node IDs.

partitionLock

public boolean partitionLock()

Specified by:

partitionLock in interface IgniteTxLocalEx<K,V>

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<K,V>

Returns:

Commit error.

commitError

public void commitError(Throwable e)

Specified by:

commitError in interface IgniteTxLocalEx<K,V>

Parameters:

e - Commit error.

onOwnerChanged

public boolean onOwnerChanged(GridCacheEntryEx<K,V> entry,
                     GridCacheMvccCandidate<K> 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<K,V>

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<K,V>

Returns:

Collection of active cache IDs.

isStarted

public boolean isStarted()

Specified by:

isStarted in class IgniteTxAdapter<K,V>

Returns:

True if transaction has at least one key enlisted.

hasWriteKey

public boolean hasWriteKey(IgniteTxKey<K> key)

Specified by:

hasWriteKey in interface IgniteInternalTx<K,V>

Parameters:

key - Key to check.

Returns:

True if key is present.

readSet

public Set<IgniteTxKey<K>> readSet()

Specified by:

readSet in interface IgniteInternalTx<K,V>

Returns:

Transaction read set.

writeSet

public Set<IgniteTxKey<K>> writeSet()

Specified by:

writeSet in interface IgniteInternalTx<K,V>

Returns:

Transaction write set.

removed

public boolean removed(IgniteTxKey<K> key)

Checks whether given key has been removed within transaction.

Specified by:

removed in interface IgniteInternalTx<K,V>

Parameters:

key - Key to check.

Returns:

True if key has been removed.

readMap

public Map<IgniteTxKey<K>,IgniteTxEntry<K,V>> readMap()

Specified by:

readMap in interface IgniteInternalTx<K,V>

Returns:

Transaction read map.

writeMap

public Map<IgniteTxKey<K>,IgniteTxEntry<K,V>> writeMap()

Specified by:

writeMap in interface IgniteInternalTx<K,V>

Returns:

Transaction write map.

allEntries

public Collection<IgniteTxEntry<K,V>> allEntries()

Specified by:

allEntries in interface IgniteInternalTx<K,V>

Returns:

All transaction entries.

readEntries

public Collection<IgniteTxEntry<K,V>> readEntries()

Specified by:

readEntries in interface IgniteInternalTx<K,V>

Returns:

Read entries.

writeEntries

public Collection<IgniteTxEntry<K,V>> writeEntries()

Specified by:

writeEntries in interface IgniteInternalTx<K,V>

Returns:

Write entries.

entry

@Nullable
public IgniteTxEntry<K,V> entry(IgniteTxKey<K> key)

Specified by:

entry in interface IgniteInternalTx<K,V>

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<K,V>

implicitSingleResult

public GridCacheReturn<V> implicitSingleResult()

Specified by:

implicitSingleResult in interface IgniteTxLocalEx<K,V>

Returns:

Return value for

implicitSingleResult

public void implicitSingleResult(GridCacheReturn<V> 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 GridTuple<V> peek(GridCacheContext<K,V> cacheCtx,
                         boolean failFast,
                         K key,
                         IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)
                  throws GridCacheFilterFailedException

Specified by:

peek in interface IgniteInternalTx<K,V>

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<K,V> cacheCtx,
                                        boolean readThrough,
                                        boolean async,
                                        Collection<? extends K> keys,
                                        boolean deserializePortable,
                                        boolean skipVals,
                                        IgniteBiInClosure<K,V> c)

Specified by:

loadMissing in interface IgniteTxLocalEx<K,V>

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<K,V>

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<K,V>

Throws:

IgniteCheckedException - If commit failed.

prepare

public void prepare()
             throws IgniteCheckedException

Prepare state.

Specified by:

prepare in interface IgniteInternalTx<K,V>

Throws:

IgniteCheckedException - If failed.

entryEx

protected GridCacheEntryEx<K,V> entryEx(GridCacheContext<K,V> cacheCtx,
                            IgniteTxKey<K> key)

Gets cache entry for given key.

Parameters:

cacheCtx - Cache context.

key - Key.

Returns:

Cache entry.

entryEx

protected GridCacheEntryEx<K,V> entryEx(GridCacheContext<K,V> cacheCtx,
                            IgniteTxKey<K> 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<K,V>> 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<K,V>

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<K,V>

Overrides:

completedVersions in class IgniteTxAdapter<K,V>

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<K,V>

Throws:

IgniteCheckedException - If rollback failed.

accessPolicy

protected IgniteCacheExpiryPolicy accessPolicy(GridCacheContext ctx,
                                   IgniteTxKey<K> 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 IgniteInternalFuture<Map<K,V>> getAllAsync(GridCacheContext<K,V> cacheCtx,
                                         Collection<? extends K> keys,
                                         @Nullable
                                         GridCacheEntryEx<K,V> cached,
                                         boolean deserializePortable,
                                         boolean skipVals)

Specified by:

getAllAsync in interface IgniteTxLocalEx<K,V>

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.

Returns:

Future for this get.

putAllAsync

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

Specified by:

putAllAsync in interface IgniteTxLocalEx<K,V>

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<K,V> cacheCtx,
                                    Map<? extends K,GridCacheDrInfo<V>> drMap)

Specified by:

putAllDrAsync in interface IgniteTxLocalEx<K,V>

Parameters:

cacheCtx - Cache context.

drMap - DR map to put.

Returns:

Future for DR put operation.

invokeAsync

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

Specified by:

invokeAsync in interface IgniteTxLocalEx<K,V>

Parameters:

cacheCtx - Cache context.

map - Entry processors map.

invokeArgs - Optional arguments for entry processor.

Returns:

Transform operation future.

removeAllDrAsync

public IgniteInternalFuture<?> removeAllDrAsync(GridCacheContext<K,V> cacheCtx,
                                       Map<? extends K,GridCacheVersion> drMap)

Specified by:

removeAllDrAsync in interface IgniteTxLocalEx<K,V>

Parameters:

cacheCtx - Cache context.

drMap - DR map.

Returns:

Future for asynchronous remove.

enlistWrite

protected IgniteInternalFuture<Set<K>> enlistWrite(GridCacheContext<K,V> cacheCtx,
                                       Collection<? extends K> keys,
                                       @Nullable
                                       GridCacheEntryEx<K,V> cached,
                                       @Nullable
                                       javax.cache.expiry.ExpiryPolicy expiryPlc,
                                       boolean implicit,
                                       @Nullable
                                       Map<? extends K,? extends V> lookup,
                                       @Nullable
                                       Map<? extends K,javax.cache.processor.EntryProcessor<K,V,Object>> invokeMap,
                                       @Nullable
                                       Object[] invokeArgs,
                                       boolean retval,
                                       boolean lockOnly,
                                       IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter,
                                       GridCacheReturn<V> ret,
                                       Collection<K> enlisted,
                                       @Nullable
                                       Map<? extends K,GridCacheDrInfo<V>> drPutMap,
                                       @Nullable
                                       Map<? extends K,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<K> postLockWrite(GridCacheContext<K,V> cacheCtx,
                   Iterable<? extends K> keys,
                   Set<K> failed,
                   GridCacheReturn ret,
                   boolean rmv,
                   boolean retval,
                   boolean read,
                   long accessTtl,
                   IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] 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 IgniteInternalFuture<GridCacheReturn<V>> removeAllAsync(GridCacheContext<K,V> cacheCtx,
                                                      Collection<? extends K> keys,
                                                      @Nullable
                                                      GridCacheEntryEx<K,V> cached,
                                                      boolean retval,
                                                      IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] filter)

Specified by:

removeAllAsync in interface IgniteTxLocalEx<K,V>

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<K>> keys)

Adds key mapping to transaction.

Parameters:

keys - Keys to add.

groupLockAsync

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

Performs keys locking for affinity-based group lock transactions.

Specified by:

groupLockAsync in interface IgniteTxLocalEx<K,V>

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<K,V> 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<K,V>

Returns:

Alternate transaction versions.

addEntry

protected final IgniteTxEntry<K,V> addEntry(GridCacheOperation op,
                          @Nullable
                          V val,
                          @Nullable
                          javax.cache.processor.EntryProcessor entryProcessor,
                          Object[] invokeArgs,
                          GridCacheEntryEx<K,V> entry,
                          @Nullable
                          javax.cache.expiry.ExpiryPolicy expiryPlc,
                          IgnitePredicate<javax.cache.Cache.Entry<K,V>>[] 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<K,V> txEntry,
                         GridCacheEntryEx<K,V> 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<K,V>

entryTtl

public boolean entryTtl(IgniteTxKey<K> key,
               long ttl)

Parameters:

key - Key.

ttl - Time to live.

Returns:

true if tx entry exists for this key, false otherwise.

entryTtl

public long entryTtl(IgniteTxKey<K> key)

Parameters:

key - Key.

Returns:

Tx entry time to live.

entryExpireTime

public long entryExpireTime(IgniteTxKey<K> key)

Parameters:

key - Key.

Returns:

Tx entry expire time.