GridCacheTxAdapter (gridgain-core 6.1.9 API)

java.lang.Object
- org.gridgain.grid.util.lang.GridMetadataAwareAdapter
- - org.gridgain.grid.kernal.processors.cache.GridCacheTxAdapter<K,V>

All Implemented Interfaces:

Externalizable, Serializable, AutoCloseable, GridCacheTx, GridMetadataAware, GridCacheTxEx<K,V>, GridTimeoutObject

Direct Known Subclasses:

GridCacheTxLocalAdapter, GridDistributedTxRemoteAdapter
```
public abstract class GridCacheTxAdapter<K,V>
extends GridMetadataAwareAdapter
implements GridCacheTxEx<K,V>, Externalizable
```
Managed transaction adapter.

See Also:
Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface org.gridgain.grid.kernal.processors.cache.GridCacheTxEx
  GridCacheTxEx.FinalizationStatus

Field Summary

Fields
Modifier and Type	Field and Description
`protected GridCacheContext<K,V>`	`cctx` Cache registry.
`protected GridCacheTxConcurrency`	`concurrency` Concurrency.
`protected GridCacheVersion`	`endVer` End version (a.k.a.
`protected Object`	`grpLockKey` Group lock key, if any.
`protected boolean`	`implicit` Implicit flag.
`protected boolean`	`implicitSingle` Implicit with one key flag.
`protected boolean`	`internal` Internal flag.
`protected boolean`	`invalidate` Invalidate flag.
`protected AtomicBoolean`	`isDone` Done marker.
`protected GridCacheTxIsolation`	`isolation` Isolation.
`protected boolean`	`loc` Local flag.
`protected static GridLogger`	`log` Logger.
`protected UUID`	`nodeId` Node ID.
`protected boolean`	`onePhaseCommit`
`protected long`	`startTime` Transaction start time.
`protected GridCacheVersion`	`startVer` Transaction counter value at the start of transaction.
`protected boolean`	`storeEnabled`
`protected UUID`	`subjId` Subject ID initiated this transaction.
`protected boolean`	`swapOrOffheapEnabled`
`protected long`	`threadId` Thread ID.
`protected long`	`timeout` Transaction timeout.
`protected int`	`txSize`
`protected GridCacheVersion`	`writeVer` Entries write version.
`protected GridCacheVersion`	`xidVer` Transaction ID.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`GridCacheTxAdapter()` Empty constructor required for `Externalizable`.
`protected`	`GridCacheTxAdapter(GridCacheContext<K,V> cctx, GridCacheVersion xidVer, boolean implicit, boolean implicitSingle, boolean loc, GridCacheTxConcurrency concurrency, GridCacheTxIsolation isolation, long timeout, boolean invalidate, boolean swapOrOffheapEnabled, boolean storeEnabled, int txSize, Object grpLockKey, UUID subjId)`
`protected`	`GridCacheTxAdapter(GridCacheContext<K,V> cctx, UUID nodeId, GridCacheVersion xidVer, GridCacheVersion startVer, long threadId, GridCacheTxConcurrency concurrency, GridCacheTxIsolation isolation, long timeout, boolean invalidate, boolean swapOrOffheapEnabled, boolean storeEnabled, int txSize, Object grpLockKey, UUID subjId)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addInvalidPartition(int part)`
`protected GridTuple3<GridCacheOperation,V,byte[]>`	`applyTransformClosures(GridCacheTxEntry<K,V> txEntry, boolean metrics)`
`protected void`	`awaitCompletion()` Awaits transaction completion.
`protected void`	`awaitSignal()` Waits for signal.
`protected boolean`	`awaitSignal(long ms)` Waits for signal.
`protected boolean`	`checkInternal(K key)`
`void`	`close()` Ends the transaction.
`boolean`	`colocated()`
`GridCacheVersion`	`commitVersion()`
`boolean`	`commitVersion(GridCacheVersion commitVer)`
`void`	`completedVersions(GridCacheVersion base, Collection<GridCacheVersion> committed, Collection<GridCacheVersion> txs)`
`GridCacheTxConcurrency`	`concurrency()` Cache transaction concurrency mode.
`boolean`	`dht()`
`boolean`	`done()`
`protected GridBiTuple<GridCacheOperation,GridDrReceiverConflictContextImpl<K,V>>`	`drResolveConflict(GridCacheOperation op, K key, V newVal, byte[] newValBytes, long newTtl, long newDrExpireTime, GridCacheVersion newVer, GridCacheEntryEx<K,V> old)` Resolve DR conflict.
`long`	`endTime()`
`GridCacheVersion`	`endVersion()`
`void`	`endVersion(GridCacheVersion endVer)`
`boolean`	`enforceSerializable()` For Partitioned caches, this flag is `false` for remote DHT and remote NEAR transactions because serializability of transaction is enforced on primary node.
`boolean`	`equals(Object o)`
`protected boolean`	`evictNearEntry(GridCacheTxEntry<K,V> e, boolean primaryOnly)`
`protected GridCacheTxEx.FinalizationStatus`	`finalizationStatus()`
`GridFuture<GridCacheTx>`	`finishFuture()`
`boolean`	`groupLock()`
`GridCacheTxEntry<K,V>`	`groupLockEntry()` This method uses unchecked assignment to cast group lock key entry to transaction generic signature.
`Object`	`groupLockKey()`
`int`	`hashCode()`
`boolean`	`implicit()` Flag indicating whether transaction was started automatically by the system or not.
`boolean`	`implicitSingle()`
`void`	`initCommitVersion()`
`boolean`	`internal()`
`void`	`invalidate(boolean invalidate)`
`Set<Integer>`	`invalidPartitions()`
`boolean`	`isInvalidate()` Get invalidation flag for this transaction.
`protected boolean`	`isNearLocallyMapped(GridCacheTxEntry<K,V> e, boolean primaryOnly)`
`GridCacheTxIsolation`	`isolation()` Cache transaction isolation level.
`boolean`	`isRollbackOnly()` If transaction was marked as rollback-only.
`abstract boolean`	`isStarted()`
`boolean`	`isSystemInvalidate()`
`boolean`	`local()`
`protected void`	`lock()` Acquires lock.
`protected long`	`lockTimeout()`
`protected GridLogger`	`log()`
`boolean`	`markFinalizing(GridCacheTxEx.FinalizationStatus status)`
`boolean`	`markPreparing()`
`boolean`	`near()`
`GridCacheVersion`	`nearXidVersion()`
`boolean`	`needsCompletedVersions()`
`UUID`	`nodeId()` ID of the node on which this transaction started.
`boolean`	`onePhaseCommit()`
`void`	`onePhaseCommit(boolean onePhaseCommit)`
`void`	`onTimeout()` Timeout callback.
`boolean`	`optimistic()`
`Collection<GridCacheTxEntry<K,V>>`	`optimisticLockEntries()` Gets a list of entries that needs to be locked on the next step of prepare stage of optimistic transaction.
`UUID`	`otherNodeId()` Gets ID of additional node involved.
`GridCacheVersion`	`ownedVersion(K key)` Gets owned version for near remote transaction.
`boolean`	`ownsLock(GridCacheEntryEx<K,V> entry)`
`boolean`	`ownsLockUnsafe(GridCacheEntryEx<K,V> entry)`
`boolean`	`pessimistic()`
`boolean`	`readCommitted()`
`void`	`readExternal(ObjectInput in)`
`protected Object`	`readResolve()` Reconstructs object on demarshalling.
`Collection<GridCacheTxEntry<K,V>>`	`recoveryWrites()` Gets pessimistic recovery writes, i.e.
`void`	`recoveryWrites(Collection<GridCacheTxEntry<K,V>> recoveryWrites)`
`long`	`remainingTime()` Gets remaining allowed transaction time.
`boolean`	`repeatableRead()`
`boolean`	`replicated()`
`boolean`	`serializable()`
`boolean`	`setRollbackOnly()` Modify the transaction associated with the current thread such that the only possible outcome of the transaction is to roll back the transaction.
`protected void`	`signalAll()` Signals all waiters.
`int`	`size()`
`long`	`startTime()` Start time of this transaction.
`GridCacheVersion`	`startVersion()`
`GridCacheTxState`	`state()` Gets current transaction state value.
`boolean`	`state(GridCacheTxState state)`
`UUID`	`subjectId()`
`boolean`	`syncCommit()`
`boolean`	`syncRollback()`
`void`	`systemInvalidate(boolean sysInvalidate)`
`long`	`threadId()` ID of the thread in which this transaction started.
`boolean`	`timedOut()`
`long`	`timeout()` Gets timeout value in milliseconds for this transaction.
`long`	`timeout(long timeout)` Sets transaction timeout value.
`GridUuid`	`timeoutId()`
`long`	`topologyVersion()`
`long`	`topologyVersion(long topVer)` Attempts to set topology version and returns the current value.
`String`	`toString()`
`Map<UUID,Collection<UUID>>`	`transactionNodes()`
`protected void`	`unlock()` Releases lock.
`protected boolean`	`updateNearCache()` Checks whether near cache should be updated.
`boolean`	`user()`
`void`	`writeExternal(ObjectOutput out)`
`GridCacheVersion`	`writeVersion()`
`void`	`writeVersion(GridCacheVersion writeVer)` Sets write version.
`GridUuid`	`xid()` Gets unique identifier for this transaction.
`GridCacheVersion`	`xidVersion()`

Methods inherited from class org.gridgain.grid.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.gridgain.grid.kernal.processors.cache.GridCacheTxEx
addLocalCandidates, allEntries, alternateVersions, empty, entry, eventNodeId, hasReadKey, hasWriteKey, localCandidates, masterNodeIds, onOwnerChanged, originatingNodeId, peek, prepare, prepareAsync, readEntries, readMap, readSet, removed, rollbackAsync, seal, writeEntries, writeMap, writeSet

Methods inherited from interface org.gridgain.grid.cache.GridCacheTx
commit, commitAsync, rollback

Methods inherited from interface org.gridgain.grid.GridMetadataAware
addMeta, addMetaIfAbsent, addMetaIfAbsent, allMeta, copyMeta, copyMeta, hasMeta, hasMeta, meta, putMetaIfAbsent, putMetaIfAbsent, removeMeta, removeMeta, replaceMeta

- Field Detail
  - log
```
protected static GridLogger log
```
    Logger.
  - xidVer
```
@GridToStringInclude
protected GridCacheVersion xidVer
```
    Transaction ID.
  - writeVer
```
@GridToStringInclude
protected GridCacheVersion writeVer
```
    Entries write version.
  - implicit
```
@GridToStringInclude
protected boolean implicit
```
    Implicit flag.
  - implicitSingle
```
@GridToStringInclude
protected boolean implicitSingle
```
    Implicit with one key flag.
  - loc
```
@GridToStringInclude
protected boolean loc
```
    Local flag.
  - threadId
```
@GridToStringInclude
protected long threadId
```
    Thread ID.
  - startTime
```
@GridToStringInclude
protected long startTime
```
    Transaction start time.
  - nodeId
```
@GridToStringInclude
protected UUID nodeId
```
    Node ID.
  - startVer
```
@GridToStringInclude
protected GridCacheVersion startVer
```
    Transaction counter value at the start of transaction.
  - cctx
```
@GridToStringExclude
protected GridCacheContext<K,V> cctx
```
    Cache registry.
  - endVer
```
@GridToStringInclude
protected GridCacheVersion endVer
```
    End version (a.k.a. 'tnc' or 'transaction number counter') assigned to this transaction at the end of write phase.
  - isolation
```
@GridToStringInclude
protected GridCacheTxIsolation isolation
```
    Isolation.
  - concurrency
```
@GridToStringInclude
protected GridCacheTxConcurrency concurrency
```
    Concurrency.
  - timeout
```
@GridToStringInclude
protected long timeout
```
    Transaction timeout.
  - invalidate
```
protected volatile boolean invalidate
```
    Invalidate flag.
  - swapOrOffheapEnabled
```
protected boolean swapOrOffheapEnabled
```
  - storeEnabled
```
protected boolean storeEnabled
```
  - internal
```
protected boolean internal
```
    Internal flag.
  - onePhaseCommit
```
protected boolean onePhaseCommit
```
  - isDone
```
protected final AtomicBoolean isDone
```
    Done marker.
  - txSize
```
protected int txSize
```
  - grpLockKey
```
protected Object grpLockKey
```
    Group lock key, if any.
  - subjId
```
protected UUID subjId
```
    Subject ID initiated this transaction.
- Constructor Detail
  - GridCacheTxAdapter
```
protected GridCacheTxAdapter()
```
    Empty constructor required for Externalizable.
  - GridCacheTxAdapter
```
protected GridCacheTxAdapter(GridCacheContext<K,V> cctx,
                  GridCacheVersion xidVer,
                  boolean implicit,
                  boolean implicitSingle,
                  boolean loc,
                  GridCacheTxConcurrency concurrency,
                  GridCacheTxIsolation isolation,
                  long timeout,
                  boolean invalidate,
                  boolean swapOrOffheapEnabled,
                  boolean storeEnabled,
                  int txSize,
                  @Nullable
                  Object grpLockKey,
                  @Nullable
                  UUID subjId)
```
    Parameters:
    cctx - Cache registry.
    xidVer - Transaction ID.
    implicit - Implicit flag.
    implicitSingle - Implicit with one key flag.
    loc - Local flag.
    concurrency - Concurrency.
    isolation - Isolation.
    timeout - Timeout.
    invalidate - Invalidation policy.
    swapOrOffheapEnabled - Whether to use swap storage.
    storeEnabled - Whether to use read/write through.
    txSize - Transaction size.
    grpLockKey - Group lock key if this is group-lock transaction.
  - GridCacheTxAdapter
```
protected GridCacheTxAdapter(GridCacheContext<K,V> cctx,
                  UUID nodeId,
                  GridCacheVersion xidVer,
                  GridCacheVersion startVer,
                  long threadId,
                  GridCacheTxConcurrency concurrency,
                  GridCacheTxIsolation isolation,
                  long timeout,
                  boolean invalidate,
                  boolean swapOrOffheapEnabled,
                  boolean storeEnabled,
                  int txSize,
                  @Nullable
                  Object grpLockKey,
                  @Nullable
                  UUID subjId)
```
    Parameters:
    cctx - Cache registry.
    nodeId - Node ID.
    xidVer - Transaction ID.
    startVer - Start version mark.
    threadId - Thread ID.
    concurrency - Concurrency.
    isolation - Isolation.
    timeout - Timeout.
    invalidate - Invalidation policy.
    swapOrOffheapEnabled - Swap enabled flag.
    storeEnabled - Store enabled (read/write through) flag.
    txSize - Transaction size.
    grpLockKey - Group lock key if this is group-lock transaction.
- Method Detail
  - lock
```
protected final void lock()
```
    Acquires lock.
  - unlock
```
protected final void unlock()
```
    Releases lock.
  - signalAll
```
protected final void signalAll()
```
    Signals all waiters.
  - awaitSignal
```
protected final void awaitSignal()
                          throws InterruptedException
```
    Waits for signal.
    
    Throws:
    
    InterruptedException - If interrupted.
  - awaitSignal
```
protected final boolean awaitSignal(long ms)
                             throws InterruptedException
```
    Waits for signal.
    
    Parameters:
    ms - Time to wait.
    
    Returns:
    True if signal occurred.
    
    Throws:
    
    InterruptedException - If interrupted.
  - updateNearCache
```
protected boolean updateNearCache()
```
    Checks whether near cache should be updated.
    
    Returns:
    Flag indicating whether near cache should be updated.
  - optimisticLockEntries
```
public Collection<GridCacheTxEntry<K,V>> optimisticLockEntries()
```
    Gets a list of entries that needs to be locked on the next step of prepare stage of optimistic transaction.
    
    Specified by:
    
    optimisticLockEntries in interface GridCacheTxEx<K,V>
    
    Returns:
    List of tx entries for optimistic locking.
  - recoveryWrites
```
public void recoveryWrites(Collection<GridCacheTxEntry<K,V>> recoveryWrites)
```
    Parameters:
    recoveryWrites - Recover write entries.
  - recoveryWrites
```
public Collection<GridCacheTxEntry<K,V>> recoveryWrites()
```
    Description copied from interface: GridCacheTxEx
    
    Gets pessimistic recovery writes, i.e. values that have never been sent to remote nodes with lock requests.
    
    Specified by:
    
    recoveryWrites in interface GridCacheTxEx<K,V>
    
    Returns:
    Recover write entries.
  - groupLockEntry
```
public GridCacheTxEntry<K,V> groupLockEntry()
```
    This method uses unchecked assignment to cast group lock key entry to transaction generic signature.
    
    Returns:
    Group lock tx entry.
  - otherNodeId
```
public UUID otherNodeId()
```
    Gets ID of additional node involved. For example, in DHT case, other node is near node ID.
    
    Specified by:
    
    otherNodeId in interface GridCacheTxEx<K,V>
    
    Returns:
    Parent node IDs.
  - subjectId
```
public UUID subjectId()
```
    Specified by:
    
    subjectId in interface GridCacheTxEx<K,V>
    
    Returns:
    Subject ID initiated this transaction.
  - topologyVersion
```
public long topologyVersion()
```
    Specified by:
    
    topologyVersion in interface GridCacheTxEx<K,V>
    
    Returns:
    Last recorded topology version.
  - topologyVersion
```
public long topologyVersion(long topVer)
```
    Attempts to set topology version and returns the current value. If topology version was previously set, then it's value will be returned (but not updated).
    
    Specified by:
    
    topologyVersion in interface GridCacheTxEx<K,V>
    
    Parameters:
    topVer - Topology version.
    
    Returns:
    Recorded topology version.
  - markPreparing
```
public boolean markPreparing()
```
    Specified by:
    
    markPreparing in interface GridCacheTxEx<K,V>
    
    Returns:
    True if preparing flag was set with this call.
  - markFinalizing
```
public boolean markFinalizing(GridCacheTxEx.FinalizationStatus status)
```
    Specified by:
    
    markFinalizing in interface GridCacheTxEx<K,V>
    
    Parameters:
    status - Finalization status to set.
    
    Returns:
    True if marked.
  - finalizationStatus
```
protected GridCacheTxEx.FinalizationStatus finalizationStatus()
```
    Returns:
    Finalization status.
  - isStarted
```
public abstract boolean isStarted()
```
    Returns:
    True if transaction has at least one key enlisted.
  - groupLock
```
public boolean groupLock()
```
    Specified by:
    
    groupLock in interface GridCacheTxEx<K,V>
    
    Returns:
    True if transaction group-locked.
  - groupLockKey
```
public Object groupLockKey()
```
    Specified by:
    
    groupLockKey in interface GridCacheTxEx<K,V>
    
    Returns:
    Group lock key if GridCacheTxEx.groupLock() is true.
  - size
```
public int size()
```
    Specified by:
    
    size in interface GridCacheTxEx<K,V>
    
    Returns:
    Size of the transaction.
  - log
```
protected GridLogger log()
```
    Returns:
    Logger.
  - near
```
public boolean near()
```
    Specified by:
    
    near in interface GridCacheTxEx<K,V>
    
    Returns:
    True if near transaction.
  - implicit
```
public boolean implicit()
```
    Flag indicating whether transaction was started automatically by the system or not. System will start transactions implicitly whenever any cache put(..) or remove(..) operation is invoked outside of transaction.
    
    Specified by:
    
    implicit in interface GridCacheTx
    
    Returns:
    True if transaction was started implicitly.
  - implicitSingle
```
public boolean implicitSingle()
```
    Specified by:
    
    implicitSingle in interface GridCacheTxEx<K,V>
    
    Returns:
    Flag indicating whether transaction is implicit with only one key.
  - local
```
public boolean local()
```
    Specified by:
    
    local in interface GridCacheTxEx<K,V>
    
    Returns:
    True if transaction is local, false if it's remote.
  - user
```
public final boolean user()
```
    Specified by:
    
    user in interface GridCacheTxEx<K,V>
    
    Returns:
    True if transaction is user transaction, which means:
    
    Explicit
    
    Local
    
    Not DHT
  - dht
```
public boolean dht()
```
    Specified by:
    
    dht in interface GridCacheTxEx<K,V>
    
    Returns:
    True if DHT transaction.
  - colocated
```
public boolean colocated()
```
    Specified by:
    
    colocated in interface GridCacheTxEx<K,V>
    
    Returns:
    True if dht colocated transaction.
  - replicated
```
public boolean replicated()
```
    Specified by:
    
    replicated in interface GridCacheTxEx<K,V>
    
    Returns:
    True if transaction is replicated.
  - enforceSerializable
```
public boolean enforceSerializable()
```
    For Partitioned caches, this flag is false for remote DHT and remote NEAR transactions because serializability of transaction is enforced on primary node. All other transaction types must enforce it.
    
    Specified by:
    
    enforceSerializable in interface GridCacheTxEx<K,V>
    
    Returns:
    Enforce serializable flag.
  - syncCommit
```
public boolean syncCommit()
```
    Specified by:
    
    syncCommit in interface GridCacheTxEx<K,V>
    
    Returns:
    True if transaction is configured with synchronous commit flag.
  - syncRollback
```
public boolean syncRollback()
```
    Specified by:
    
    syncRollback in interface GridCacheTxEx<K,V>
    
    Returns:
    True if transaction is configured with synchronous rollback flag.
  - xid
```
public GridUuid xid()
```
    Gets unique identifier for this transaction.
    
    Specified by:
    
    xid in interface GridCacheTx
    
    Returns:
    Transaction UID.
  - invalidPartitions
```
public Set<Integer> invalidPartitions()
```
    Specified by:
    
    invalidPartitions in interface GridCacheTxEx<K,V>
    
    Returns:
    Invalid partitions.
  - addInvalidPartition
```
public void addInvalidPartition(int part)
```
    Specified by:
    
    addInvalidPartition in interface GridCacheTxEx<K,V>
    
    Parameters:
    part - Invalid partition.
  - ownedVersion
```
public GridCacheVersion ownedVersion(K key)
```
    Gets owned version for near remote transaction.
    
    Specified by:
    
    ownedVersion in interface GridCacheTxEx<K,V>
    
    Parameters:
    key - Key to get version for.
    
    Returns:
    Owned version, if any.
  - startTime
```
public long startTime()
```
    Start time of this transaction.
    
    Specified by:
    
    startTime in interface GridCacheTx
    
    Returns:
    Start time of this transaction on this node.
  - remainingTime
```
public long remainingTime()
```
    Gets remaining allowed transaction time.
    
    Specified by:
    
    remainingTime in interface GridCacheTxEx<K,V>
    
    Returns:
    Remaining transaction time.
  - lockTimeout
```
protected long lockTimeout()
```
    Returns:
    Lock timeout.
  - xidVersion
```
public GridCacheVersion xidVersion()
```
    Specified by:
    
    xidVersion in interface GridCacheTxEx<K,V>
    
    Returns:
    Transaction version.
  - threadId
```
public long threadId()
```
    ID of the thread in which this transaction started.
    
    Specified by:
    
    threadId in interface GridCacheTx
    
    Returns:
    Thread ID.
  - nodeId
```
public UUID nodeId()
```
    ID of the node on which this transaction started.
    
    Specified by:
    
    nodeId in interface GridCacheTx
    
    Returns:
    Originating node ID.
  - isolation
```
public GridCacheTxIsolation isolation()
```
    Cache transaction isolation level.
    
    Specified by:
    
    isolation in interface GridCacheTx
    
    Returns:
    Isolation level.
  - concurrency
```
public GridCacheTxConcurrency concurrency()
```
    Cache transaction concurrency mode.
    
    Specified by:
    
    concurrency in interface GridCacheTx
    
    Returns:
    Concurrency mode.
  - timeout
```
public long timeout()
```
    Gets timeout value in milliseconds for this transaction. If transaction times out prior to it's completion, GridCacheTxTimeoutException will be thrown.
    
    Specified by:
    
    timeout in interface GridCacheTx
    
    Returns:
    Transaction timeout value.
  - timeout
```
public long timeout(long timeout)
```
    Sets transaction timeout value. This value can be set only before a first operation on transaction has been performed.
    
    Specified by:
    
    timeout in interface GridCacheTx
    
    Parameters:
    timeout - Transaction timeout value.
    
    Returns:
    Previous timeout.
  - ownsLock
```
public boolean ownsLock(GridCacheEntryEx<K,V> entry)
                 throws GridCacheEntryRemovedException
```
    Specified by:
    
    ownsLock in interface GridCacheTxEx<K,V>
    
    Parameters:
    entry - Entry to check.
    
    Returns:
    True if lock is owned.
    
    Throws:
    
    GridCacheEntryRemovedException - If entry has been removed.
  - ownsLockUnsafe
```
public boolean ownsLockUnsafe(GridCacheEntryEx<K,V> entry)
```
    Specified by:
    
    ownsLockUnsafe in interface GridCacheTxEx<K,V>
    
    Parameters:
    entry - Entry to check.
    
    Returns:
    True if lock is owned.
  - state
```
public GridCacheTxState state()
```
    Gets current transaction state value.
    
    Specified by:
    
    state in interface GridCacheTx
    
    Returns:
    Current transaction state.
  - setRollbackOnly
```
public boolean setRollbackOnly()
```
    Modify the transaction associated with the current thread such that the only possible outcome of the transaction is to roll back the transaction.
    
    Specified by:
    
    setRollbackOnly in interface GridCacheTx
    
    Returns:
    True if rollback-only flag was set as a result of this operation, false if it was already set prior to this call or could not be set because transaction is already finishing up committing or rolling back.
  - isRollbackOnly
```
public boolean isRollbackOnly()
```
    Description copied from interface: GridCacheTx
    
    If transaction was marked as rollback-only.
    
    Specified by:
    
    isRollbackOnly in interface GridCacheTx
    
    Returns:
    True if rollback only flag is set.
  - done
```
public boolean done()
```
    Specified by:
    
    done in interface GridCacheTxEx<K,V>
    
    Returns:
    True if transaction had completed successfully or unsuccessfully.
  - commitVersion
```
public GridCacheVersion commitVersion()
```
    Specified by:
    
    commitVersion in interface GridCacheTxEx<K,V>
    
    Returns:
    Commit version.
  - commitVersion
```
public boolean commitVersion(GridCacheVersion commitVer)
```
    Specified by:
    
    commitVersion in interface GridCacheTxEx<K,V>
    
    Parameters:
    commitVer - Commit version.
    
    Returns:
    True if set to not null value.
  - initCommitVersion
```
public void initCommitVersion()
```
  - close
```
public void close()
           throws GridException
```
    Description copied from interface: GridCacheTx
    
    Ends the transaction. Transaction will be rolled back if it has not been committed.
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface GridCacheTx
    
    Throws:
    
    GridException - If transaction could not be gracefully ended.
  - needsCompletedVersions
```
public boolean needsCompletedVersions()
```
    Specified by:
    
    needsCompletedVersions in interface GridCacheTxEx<K,V>
    
    Returns:
    True if transaction needs completed versions for processing.
  - completedVersions
```
public void completedVersions(GridCacheVersion base,
                     Collection<GridCacheVersion> committed,
                     Collection<GridCacheVersion> txs)
```
    Specified by:
    
    completedVersions in interface GridCacheTxEx<K,V>
    
    Parameters:
    base - Base for committed versions.
    committed - Committed transactions relative to base.
    txs - Rolled back transactions relative to base.
  - awaitCompletion
```
protected void awaitCompletion()
                        throws GridException
```
    Awaits transaction completion.
    
    Throws:
    
    GridException - If waiting failed.
  - internal
```
public boolean internal()
```
    Specified by:
    
    internal in interface GridCacheTxEx<K,V>
    
    Returns:
    True if transaction has at least one internal entry.
  - checkInternal
```
protected boolean checkInternal(K key)
```
    Parameters:
    key - Key.
    
    Returns:
    True if key is internal.
  - onePhaseCommit
```
public void onePhaseCommit(boolean onePhaseCommit)
```
    Parameters:
    onePhaseCommit - True if transaction commit should be performed in short-path way.
  - onePhaseCommit
```
public boolean onePhaseCommit()
```
    Specified by:
    
    onePhaseCommit in interface GridCacheTxEx<K,V>
    
    Returns:
    Fast commit flag.
  - optimistic
```
public boolean optimistic()
```
    Specified by:
    
    optimistic in interface GridCacheTxEx<K,V>
    
    Returns:
    True for OPTIMISTIC transactions.
  - pessimistic
```
public boolean pessimistic()
```
    Specified by:
    
    pessimistic in interface GridCacheTxEx<K,V>
    
    Returns:
    True for PESSIMISTIC transactions.
  - serializable
```
public boolean serializable()
```
    Specified by:
    
    serializable in interface GridCacheTxEx<K,V>
    
    Returns:
    True if serializable.
  - repeatableRead
```
public boolean repeatableRead()
```
    Specified by:
    
    repeatableRead in interface GridCacheTxEx<K,V>
    
    Returns:
    True if repeatable-read.
  - readCommitted
```
public boolean readCommitted()
```
    Specified by:
    
    readCommitted in interface GridCacheTxEx<K,V>
    
    Returns:
    True if read-committed.
  - state
```
public boolean state(GridCacheTxState state)
```
    Specified by:
    
    state in interface GridCacheTxEx<K,V>
    
    Parameters:
    state - Transaction state.
    
    Returns:
    True if transition was valid, false otherwise.
  - finishFuture
```
public GridFuture<GridCacheTx> finishFuture()
```
    Specified by:
    
    finishFuture in interface GridCacheTxEx<K,V>
    
    Returns:
    Future for transaction completion.
  - startVersion
```
public GridCacheVersion startVersion()
```
    Specified by:
    
    startVersion in interface GridCacheTxEx<K,V>
    
    Returns:
    Start version.
  - endVersion
```
public GridCacheVersion endVersion()
```
    Specified by:
    
    endVersion in interface GridCacheTxEx<K,V>
    
    Returns:
    End version (a.k.a. 'tnc' or 'transaction number counter') assigned to this transaction at the end of write phase.
  - endVersion
```
public void endVersion(GridCacheVersion endVer)
```
    Specified by:
    
    endVersion in interface GridCacheTxEx<K,V>
    
    Parameters:
    endVer - End version (a.k.a. 'tnc' or 'transaction number counter') assigned to this transaction at the end of write phase.
  - writeVersion
```
public GridCacheVersion writeVersion()
```
    Specified by:
    
    writeVersion in interface GridCacheTxEx<K,V>
    
    Returns:
    Transaction write version. For all transactions except DHT transactions, will be equal to GridCacheTxEx.xidVersion().
  - writeVersion
```
public void writeVersion(GridCacheVersion writeVer)
```
    Sets write version.
    
    Specified by:
    
    writeVersion in interface GridCacheTxEx<K,V>
    
    Parameters:
    writeVer - Write version.
  - timeoutId
```
public GridUuid timeoutId()
```
    Specified by:
    
    timeoutId in interface GridTimeoutObject
    
    Returns:
    ID of the object.
  - endTime
```
public long endTime()
```
    Specified by:
    
    endTime in interface GridTimeoutObject
    
    Returns:
    End time.
  - onTimeout
```
public void onTimeout()
```
    Timeout callback.
    
    Specified by:
    
    onTimeout in interface GridTimeoutObject
  - timedOut
```
public boolean timedOut()
```
    Specified by:
    
    timedOut in interface GridCacheTxEx<K,V>
    
    Returns:
    True if transaction timed out.
  - invalidate
```
public void invalidate(boolean invalidate)
```
    Specified by:
    
    invalidate in interface GridCacheTxEx<K,V>
    
    Parameters:
    invalidate - Invalidate flag.
  - isInvalidate
```
public boolean isInvalidate()
```
    Get invalidation flag for this transaction. If set to true, then remote values will be invalidated (set to null) instead of updated.
    Invalidation messages don't carry new values, so they are a lot lighter than update messages. However, when a value is accessed on a node after it's been invalidated, it must be loaded from persistent store.
    
    Specified by:
    
    isInvalidate in interface GridCacheTx
    
    Returns:
    Invalidation flag.
  - isSystemInvalidate
```
public boolean isSystemInvalidate()
```
    Specified by:
    
    isSystemInvalidate in interface GridCacheTxEx<K,V>
    
    Returns:
    System invalidate flag.
  - systemInvalidate
```
public void systemInvalidate(boolean sysInvalidate)
```
    Specified by:
    
    systemInvalidate in interface GridCacheTxEx<K,V>
    
    Parameters:
    sysInvalidate - System invalidate flag.
  - transactionNodes
```
@Nullable
public Map<UUID,Collection<UUID>> transactionNodes()
```
    Specified by:
    
    transactionNodes in interface GridCacheTxEx<K,V>
    
    Returns:
    Transaction nodes mapping (primary node -> related backup nodes).
  - nearXidVersion
```
@Nullable
public GridCacheVersion nearXidVersion()
```
    Specified by:
    
    nearXidVersion in interface GridCacheTxEx<K,V>
    
    Returns:
    Near transaction ID.
  - applyTransformClosures
```
protected GridTuple3<GridCacheOperation,V,byte[]> applyTransformClosures(GridCacheTxEntry<K,V> txEntry,
                                                             boolean metrics)
                                                                  throws GridCacheEntryRemovedException,
                                                                         GridException
```
    Parameters:
    txEntry - Entry to process.
    metrics - True if metrics should be updated.
    
    Returns:
    Tuple containing transformation results.
    
    Throws:
    
    GridException - If failed to get previous value for transform.
    
    GridCacheEntryRemovedException - If entry was concurrently deleted.
  - drResolveConflict
```
protected GridBiTuple<GridCacheOperation,GridDrReceiverConflictContextImpl<K,V>> drResolveConflict(GridCacheOperation op,
                                                                                       K key,
                                                                                       V newVal,
                                                                                       byte[] newValBytes,
                                                                                       long newTtl,
                                                                                       long newDrExpireTime,
                                                                                       GridCacheVersion newVer,
                                                                                       GridCacheEntryEx<K,V> old)
                                                                                            throws GridException,
                                                                                                   GridCacheEntryRemovedException
```
    Resolve DR conflict.
    
    Parameters:
    op - Initially proposed operation.
    key - Key.
    newVal - New value.
    newValBytes - New value bytes.
    newTtl - New TTL.
    newDrExpireTime - New explicit DR expire time.
    newVer - New version.
    old - Old entry.
    
    Returns:
    Tuple with adjusted operation type and conflict context.
    
    Throws:
    
    GridException - In case of eny exception.
    
    GridCacheEntryRemovedException - If entry got removed.
  - isNearLocallyMapped
```
protected boolean isNearLocallyMapped(GridCacheTxEntry<K,V> e,
                          boolean primaryOnly)
```
    Parameters:
    e - Transaction entry.
    primaryOnly - Flag to include backups into check or not.
    
    Returns:
    True if entry is locally mapped as a primary or back up node.
  - evictNearEntry
```
protected boolean evictNearEntry(GridCacheTxEntry<K,V> e,
                     boolean primaryOnly)
                          throws GridException
```
    Parameters:
    e - Entry to evict if it qualifies for eviction.
    primaryOnly - Flag to try to evict only on primary node.
    
    Returns:
    True if attempt was made to evict the entry.
    
    Throws:
    
    GridException - If failed.
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
    
    ClassNotFoundException
  - readResolve
```
protected Object readResolve()
                      throws ObjectStreamException
```
    Reconstructs object on demarshalling.
    
    Returns:
    Reconstructed object.
    
    Throws:
    
    ObjectStreamException - Thrown in case of demarshalling error.
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class GridCacheTxAdapter<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface org.gridgain.grid.kernal.processors.cache.GridCacheTxEx

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.gridgain.grid.util.lang.GridMetadataAwareAdapter

Methods inherited from class java.lang.Object

Methods inherited from interface org.gridgain.grid.kernal.processors.cache.GridCacheTxEx

Methods inherited from interface org.gridgain.grid.cache.GridCacheTx

Methods inherited from interface org.gridgain.grid.GridMetadataAware

Field Detail

log

xidVer

writeVer

implicit

implicitSingle

loc

threadId

startTime

nodeId

startVer

cctx

endVer

isolation

concurrency

timeout

invalidate

swapOrOffheapEnabled

storeEnabled

internal

onePhaseCommit

isDone

txSize

grpLockKey

subjId

Constructor Detail

GridCacheTxAdapter

GridCacheTxAdapter

GridCacheTxAdapter

Method Detail

lock

unlock

signalAll

awaitSignal

awaitSignal

updateNearCache

optimisticLockEntries

recoveryWrites

recoveryWrites

groupLockEntry

otherNodeId

subjectId

topologyVersion

topologyVersion

markPreparing

markFinalizing

finalizationStatus

isStarted

groupLock

groupLockKey

size

log

near

implicit

implicitSingle

local

user

dht

colocated

replicated

enforceSerializable

syncCommit

syncRollback

xid

invalidPartitions

addInvalidPartition

ownedVersion

startTime

remainingTime