IgniteTxAdapter (Ignite 1.0.0-RC1)

java.lang.Object
- org.apache.ignite.internal.util.lang.GridMetadataAwareAdapter
- - org.apache.ignite.internal.processors.cache.transactions.IgniteTxAdapter<K,V>

All Implemented Interfaces:

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

Direct Known Subclasses:

GridDistributedTxRemoteAdapter, IgniteTxLocalAdapter
```
public abstract class IgniteTxAdapter<K,V>
extends GridMetadataAwareAdapter
implements IgniteInternalTx<K,V>, Externalizable
```
Managed transaction adapter.

See Also:
Serialized Form

Nested Class Summary
- 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 GridCacheSharedContext<K,V>`	`cctx` Cache registry.
`protected TransactionConcurrency`	`concurrency` Concurrency.
`protected GridCacheVersion`	`endVer` End version (a.k.a.
`protected IgniteTxKey`	`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 TransactionIsolation`	`isolation` Isolation.
`protected boolean`	`loc` Local flag.
`protected static IgniteLogger`	`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` Store used flag.
`protected UUID`	`subjId` Subject ID initiated this transaction.
`protected boolean`	`syncCommit`
`protected boolean`	`syncRollback`
`protected String`	`taskName` Task name.
`protected int`	`taskNameHash` Task name hash code.
`protected long`	`threadId` Thread ID.
`protected long`	`timeout` Transaction timeout.
`protected boolean`	`transform` If this transaction contains transform entries.
`protected Map<UUID,Collection<UUID>>`	`txNodes`
`protected int`	`txSize`
`protected GridCacheVersion`	`writeVer` Entries write version.
`protected GridCacheVersion`	`xidVer` Transaction ID.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`IgniteTxAdapter()` Empty constructor required for `Externalizable`.
`protected`	`IgniteTxAdapter(GridCacheSharedContext<K,V> cctx, GridCacheVersion xidVer, boolean implicit, boolean implicitSingle, boolean loc, boolean sys, TransactionConcurrency concurrency, TransactionIsolation isolation, long timeout, boolean invalidate, boolean storeEnabled, int txSize, IgniteTxKey grpLockKey, UUID subjId, int taskNameHash)`
`protected`	`IgniteTxAdapter(GridCacheSharedContext<K,V> cctx, UUID nodeId, GridCacheVersion xidVer, GridCacheVersion startVer, long threadId, boolean sys, TransactionConcurrency concurrency, TransactionIsolation isolation, long timeout, int txSize, IgniteTxKey grpLockKey, UUID subjId, int taskNameHash)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addInvalidPartition(GridCacheContext<K,V> cacheCtx, int part)`
`protected GridTuple3<GridCacheOperation,V,byte[]>`	`applyTransformClosures(IgniteTxEntry<K,V> txEntry, boolean metrics)`
`protected void`	`awaitCompletion()` Awaits transaction completion.
`protected void`	`awaitSignal()` Waits for signal.
`protected boolean`	`checkInternal(IgniteTxKey<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)`
`TransactionConcurrency`	`concurrency()` Cache transaction concurrency mode.
`protected IgniteBiTuple<GridCacheOperation,GridCacheVersionConflictContext<K,V>>`	`conflictResolve(GridCacheOperation op, K key, V newVal, byte[] newValBytes, long newTtl, long newDrExpireTime, GridCacheVersion newVer, GridCacheEntryEx<K,V> old)` Resolve DR conflict.
`boolean`	`dht()`
`boolean`	`done()`
`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(IgniteTxEntry<K,V> e, boolean primaryOnly)`
`protected IgniteInternalTx.FinalizationStatus`	`finalizationStatus()`
`IgniteInternalFuture<IgniteInternalTx>`	`finishFuture()`
`boolean`	`groupLock()`
`IgniteTxEntry<K,V>`	`groupLockEntry()` This method uses unchecked assignment to cast group lock key entry to transaction generic signature.
`IgniteTxKey`	`groupLockKey()`
`int`	`hashCode()`
`boolean`	`hasTransforms()`
`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()`
`GridIoPolicy`	`ioPolicy()`
`boolean`	`isInvalidate()` Get invalidation flag for this transaction.
`protected boolean`	`isNearLocallyMapped(IgniteTxEntry<K,V> e, boolean primaryOnly)`
`TransactionIsolation`	`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 IgniteLogger`	`log()`
`boolean`	`markFinalizing(IgniteInternalTx.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<IgniteTxEntry<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(IgniteTxKey<K> key)` Gets owned version for near remote transaction.
`boolean`	`ownsLock(GridCacheEntryEx<K,V> entry)`
`boolean`	`ownsLockUnsafe(GridCacheEntryEx<K,V> entry)`
`boolean`	`pessimistic()`
`TransactionProxy`	`proxy()`
`boolean`	`readCommitted()`
`void`	`readExternal(ObjectInput in)`
`protected Object`	`readResolve()` Reconstructs object on unmarshalling.
`long`	`remainingTime()` Gets remaining allowed transaction time.
`boolean`	`repeatableRead()`
`boolean`	`replicated()`
`String`	`resolveTaskName()`
`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()`
`TransactionState`	`state()` Gets current transaction state value.
`boolean`	`state(TransactionState state)`
`protected GridCacheStoreManager<K,V>`	`store()` Store manager for current transaction.
`boolean`	`storeEnabled()`
`void`	`storeEnabled(boolean storeEnabled)`
`boolean`	`storeUsed()`
`UUID`	`subjectId()`
`boolean`	`syncCommit()`
`void`	`syncCommit(boolean syncCommit)`
`boolean`	`syncRollback()`
`void`	`syncRollback(boolean syncRollback)`
`boolean`	`system()` Checks if this is system cache transaction.
`void`	`systemInvalidate(boolean sysInvalidate)`
`int`	`taskNameHash()` Task name hash in case if transaction was initiated within task execution.
`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.
`IgniteUuid`	`timeoutId()`
`long`	`topologyVersion()`
`long`	`topologyVersion(long topVer)` Attempts to set topology version and returns the current value.
`String`	`toString()`
`Map<UUID,Collection<UUID>>`	`transactionNodes()`
`void`	`transactionNodes(Map<UUID,Collection<UUID>> txNodes)`
`protected void`	`uncommit()` Uncommits transaction by invalidating all of its entries.
`protected void`	`unlock()` Releases lock.
`protected boolean`	`updateNearCache(GridCacheContext<K,V> cacheCtx, K key, long topVer)` Checks whether near cache should be updated.
`boolean`	`user()`
`void`	`writeExternal(ObjectOutput out)`
`GridCacheVersion`	`writeVersion()`
`void`	`writeVersion(GridCacheVersion writeVer)` Sets write version.
`IgniteUuid`	`xid()` Gets unique identifier for this transaction.
`GridCacheVersion`	`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.IgniteInternalTx
activeCacheIds, addMeta, allEntries, alternateVersions, commit, commitAsync, empty, entry, eventNodeId, hasWriteKey, masterNodeIds, meta, onOwnerChanged, originatingNodeId, peek, prepare, prepareAsync, readEntries, readMap, readSet, removed, removeMeta, rollback, rollbackAsync, seal, writeEntries, writeMap, writeSet

- Field Detail
  - log
```
protected static IgniteLogger 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 GridCacheSharedContext<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 TransactionIsolation isolation
```
    Isolation.
  - concurrency
```
@GridToStringInclude
protected TransactionConcurrency concurrency
```
    Concurrency.
  - timeout
```
@GridToStringInclude
protected long timeout
```
    Transaction timeout.
  - invalidate
```
protected volatile boolean invalidate
```
    Invalidate flag.
  - internal
```
protected boolean internal
```
    Internal flag.
  - onePhaseCommit
```
protected boolean onePhaseCommit
```
  - syncCommit
```
protected boolean syncCommit
```
  - syncRollback
```
protected boolean syncRollback
```
  - transform
```
protected boolean transform
```
    If this transaction contains transform entries.
  - isDone
```
protected final AtomicBoolean isDone
```
    Done marker.
  - txSize
```
protected int txSize
```
  - grpLockKey
```
protected IgniteTxKey grpLockKey
```
    Group lock key, if any.
  - txNodes
```
protected Map<UUID,Collection<UUID>> txNodes
```
  - subjId
```
protected UUID subjId
```
    Subject ID initiated this transaction.
  - taskNameHash
```
protected int taskNameHash
```
    Task name hash code.
  - taskName
```
protected String taskName
```
    Task name.
  - storeEnabled
```
protected boolean storeEnabled
```
    Store used flag.
- Constructor Detail
  - IgniteTxAdapter
```
protected IgniteTxAdapter()
```
    Empty constructor required for Externalizable.
  - IgniteTxAdapter
```
protected IgniteTxAdapter(GridCacheSharedContext<K,V> cctx,
               GridCacheVersion xidVer,
               boolean implicit,
               boolean implicitSingle,
               boolean loc,
               boolean sys,
               TransactionConcurrency concurrency,
               TransactionIsolation isolation,
               long timeout,
               boolean invalidate,
               boolean storeEnabled,
               int txSize,
               @Nullable
               IgniteTxKey grpLockKey,
               @Nullable
               UUID subjId,
               int taskNameHash)
```
    Parameters:
    cctx - Cache registry.
    xidVer - Transaction ID.
    implicit - Implicit flag.
    implicitSingle - Implicit with one key flag.
    loc - Local flag.
    sys - System transaction flag.
    concurrency - Concurrency.
    isolation - Isolation.
    timeout - Timeout.
    txSize - Transaction size.
    grpLockKey - Group lock key if this is group-lock transaction.
  - IgniteTxAdapter
```
protected IgniteTxAdapter(GridCacheSharedContext<K,V> cctx,
               UUID nodeId,
               GridCacheVersion xidVer,
               GridCacheVersion startVer,
               long threadId,
               boolean sys,
               TransactionConcurrency concurrency,
               TransactionIsolation isolation,
               long timeout,
               int txSize,
               @Nullable
               IgniteTxKey grpLockKey,
               @Nullable
               UUID subjId,
               int taskNameHash)
```
    Parameters:
    cctx - Cache registry.
    nodeId - Node ID.
    xidVer - Transaction ID.
    startVer - Start version mark.
    threadId - Thread ID.
    sys - System transaction flag.
    concurrency - Concurrency.
    isolation - Isolation.
    timeout - Timeout.
    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.
  - updateNearCache
```
protected boolean updateNearCache(GridCacheContext<K,V> cacheCtx,
                      K key,
                      long topVer)
```
    Checks whether near cache should be updated.
    
    Returns:
    Flag indicating whether near cache should be updated.
  - optimisticLockEntries
```
public Collection<IgniteTxEntry<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 IgniteInternalTx<K,V>
    
    Returns:
    List of tx entries for optimistic locking.
  - storeEnabled
```
public boolean storeEnabled()
```
    Specified by:
    
    storeEnabled in interface IgniteInternalTx<K,V>
    
    Returns:
    True if transaction is allowed to use store.
  - storeEnabled
```
public void storeEnabled(boolean storeEnabled)
```
    Parameters:
    storeEnabled - Store enabled flag.
  - system
```
public boolean system()
```
    Checks if this is system cache transaction. System transactions are isolated from user transactions because some of the public API methods may be invoked inside user transactions and internally start system cache transactions.
    
    Specified by:
    
    system in interface IgniteInternalTx<K,V>
    
    Returns:
    True if transaction is started for system cache.
  - ioPolicy
```
public GridIoPolicy ioPolicy()
```
    Specified by:
    
    ioPolicy in interface IgniteInternalTx<K,V>
    
    Returns:
    Pool where message for the given transaction must be processed.
  - storeUsed
```
public boolean storeUsed()
```
    Specified by:
    
    storeUsed in interface IgniteInternalTx<K,V>
    
    Returns:
    True if transaction is allowed to use store and transactions spans one or more caches with store enabled.
  - store
```
protected GridCacheStoreManager<K,V> store()
```
    Store manager for current transaction.
    
    Returns:
    Store manager.
  - uncommit
```
protected void uncommit()
```
    Uncommits transaction by invalidating all of its entries. Courtesy to minimize inconsistency.
  - groupLockEntry
```
public IgniteTxEntry<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 IgniteInternalTx<K,V>
    
    Returns:
    Parent node IDs.
  - subjectId
```
public UUID subjectId()
```
    Specified by:
    
    subjectId in interface IgniteInternalTx<K,V>
    
    Returns:
    Subject ID initiated this transaction.
  - taskNameHash
```
public int taskNameHash()
```
    Task name hash in case if transaction was initiated within task execution.
    
    Specified by:
    
    taskNameHash in interface IgniteInternalTx<K,V>
    
    Returns:
    Task name hash.
  - topologyVersion
```
public long topologyVersion()
```
    Specified by:
    
    topologyVersion in interface IgniteInternalTx<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 IgniteInternalTx<K,V>
    
    Parameters:
    topVer - Topology version.
    
    Returns:
    Recorded topology version.
  - hasTransforms
```
public boolean hasTransforms()
```
    Specified by:
    
    hasTransforms in interface IgniteInternalTx<K,V>
    
    Returns:
    True if transaction has transform entries. This flag will be only set for local transactions.
  - markPreparing
```
public boolean markPreparing()
```
    Specified by:
    
    markPreparing in interface IgniteInternalTx<K,V>
    
    Returns:
    True if preparing flag was set with this call.
  - markFinalizing
```
public boolean markFinalizing(IgniteInternalTx.FinalizationStatus status)
```
    Specified by:
    
    markFinalizing in interface IgniteInternalTx<K,V>
    
    Parameters:
    status - Finalization status to set.
    
    Returns:
    True if marked.
  - finalizationStatus
```
protected IgniteInternalTx.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 IgniteInternalTx<K,V>
    
    Returns:
    True if transaction group-locked.
  - groupLockKey
```
public IgniteTxKey groupLockKey()
```
    Specified by:
    
    groupLockKey in interface IgniteInternalTx<K,V>
    
    Returns:
    Group lock key if IgniteInternalTx.groupLock() is true.
  - size
```
public int size()
```
    Specified by:
    
    size in interface IgniteInternalTx<K,V>
    
    Returns:
    Size of the transaction.
  - log
```
protected IgniteLogger log()
```
    Returns:
    Logger.
  - near
```
public boolean near()
```
    Specified by:
    
    near in interface IgniteInternalTx<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 IgniteInternalTx<K,V>
    
    Returns:
    True if transaction was started implicitly.
  - implicitSingle
```
public boolean implicitSingle()
```
    Specified by:
    
    implicitSingle in interface IgniteInternalTx<K,V>
    
    Returns:
    Flag indicating whether transaction is implicit with only one key.
  - local
```
public boolean local()
```
    Specified by:
    
    local in interface IgniteInternalTx<K,V>
    
    Returns:
    True if transaction is local, false if it's remote.
  - user
```
public final boolean user()
```
    Specified by:
    
    user in interface IgniteInternalTx<K,V>
    
    Returns:
    True if transaction is user transaction, which means:
    
    Explicit
    
    Local
    
    Not DHT
  - dht
```
public boolean dht()
```
    Specified by:
    
    dht in interface IgniteInternalTx<K,V>
    
    Returns:
    True if DHT transaction.
  - colocated
```
public boolean colocated()
```
    Specified by:
    
    colocated in interface IgniteInternalTx<K,V>
    
    Returns:
    True if dht colocated transaction.
  - replicated
```
public boolean replicated()
```
    Specified by:
    
    replicated in interface IgniteInternalTx<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 IgniteInternalTx<K,V>
    
    Returns:
    Enforce serializable flag.
  - syncCommit
```
public boolean syncCommit()
```
    Specified by:
    
    syncCommit in interface IgniteInternalTx<K,V>
    
    Returns:
    True if transaction is configured with synchronous commit flag.
  - syncRollback
```
public boolean syncRollback()
```
    Specified by:
    
    syncRollback in interface IgniteInternalTx<K,V>
    
    Returns:
    True if transaction is configured with synchronous rollback flag.
  - syncCommit
```
public void syncCommit(boolean syncCommit)
```
    Parameters:
    syncCommit - Synchronous commit flag.
  - syncRollback
```
public void syncRollback(boolean syncRollback)
```
    Parameters:
    syncRollback - Synchronous rollback flag.
  - xid
```
public IgniteUuid xid()
```
    Gets unique identifier for this transaction.
    
    Specified by:
    
    xid in interface IgniteInternalTx<K,V>
    
    Returns:
    Transaction UID.
  - invalidPartitions
```
public Set<Integer> invalidPartitions()
```
    Specified by:
    
    invalidPartitions in interface IgniteInternalTx<K,V>
    
    Returns:
    Invalid partitions.
  - addInvalidPartition
```
public void addInvalidPartition(GridCacheContext<K,V> cacheCtx,
                       int part)
```
    Specified by:
    
    addInvalidPartition in interface IgniteInternalTx<K,V>
    
    Parameters:
    cacheCtx - Cache context.
    part - Invalid partition.
  - ownedVersion
```
public GridCacheVersion ownedVersion(IgniteTxKey<K> key)
```
    Gets owned version for near remote transaction.
    
    Specified by:
    
    ownedVersion in interface IgniteInternalTx<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 IgniteInternalTx<K,V>
    
    Returns:
    Start time of this transaction on this node.
  - remainingTime
```
public long remainingTime()
```
    Gets remaining allowed transaction time.
    
    Specified by:
    
    remainingTime in interface IgniteInternalTx<K,V>
    
    Returns:
    Remaining transaction time.
  - lockTimeout
```
protected long lockTimeout()
```
    Returns:
    Lock timeout.
  - xidVersion
```
public GridCacheVersion xidVersion()
```
    Specified by:
    
    xidVersion in interface IgniteInternalTx<K,V>
    
    Returns:
    Transaction version.
  - threadId
```
public long threadId()
```
    ID of the thread in which this transaction started.
    
    Specified by:
    
    threadId in interface IgniteInternalTx<K,V>
    
    Returns:
    Thread ID.
  - nodeId
```
public UUID nodeId()
```
    ID of the node on which this transaction started.
    
    Specified by:
    
    nodeId in interface IgniteInternalTx<K,V>
    
    Returns:
    Originating node ID.
  - isolation
```
public TransactionIsolation isolation()
```
    Cache transaction isolation level.
    
    Specified by:
    
    isolation in interface IgniteInternalTx<K,V>
    
    Returns:
    Isolation level.
  - concurrency
```
public TransactionConcurrency concurrency()
```
    Cache transaction concurrency mode.
    
    Specified by:
    
    concurrency in interface IgniteInternalTx<K,V>
    
    Returns:
    Concurrency mode.
  - timeout
```
public long timeout()
```
    Gets timeout value in milliseconds for this transaction. If transaction times out prior to it's completion, IgniteTxTimeoutCheckedException will be thrown.
    
    Specified by:
    
    timeout in interface IgniteInternalTx<K,V>
    
    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 IgniteInternalTx<K,V>
    
    Parameters:
    timeout - Transaction timeout value.
    
    Returns:
    Previous timeout.
  - ownsLock
```
public boolean ownsLock(GridCacheEntryEx<K,V> entry)
                 throws GridCacheEntryRemovedException
```
    Specified by:
    
    ownsLock in interface IgniteInternalTx<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 IgniteInternalTx<K,V>
    
    Parameters:
    entry - Entry to check.
    
    Returns:
    True if lock is owned.
  - state
```
public TransactionState state()
```
    Gets current transaction state value.
    
    Specified by:
    
    state in interface IgniteInternalTx<K,V>
    
    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 IgniteInternalTx<K,V>
    
    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: IgniteInternalTx
    
    If transaction was marked as rollback-only.
    
    Specified by:
    
    isRollbackOnly in interface IgniteInternalTx<K,V>
    
    Returns:
    True if rollback only flag is set.
  - done
```
public boolean done()
```
    Specified by:
    
    done in interface IgniteInternalTx<K,V>
    
    Returns:
    True if transaction had completed successfully or unsuccessfully.
  - commitVersion
```
public GridCacheVersion commitVersion()
```
    Specified by:
    
    commitVersion in interface IgniteInternalTx<K,V>
    
    Returns:
    Commit version.
  - commitVersion
```
public boolean commitVersion(GridCacheVersion commitVer)
```
    Specified by:
    
    commitVersion in interface IgniteInternalTx<K,V>
    
    Parameters:
    commitVer - Commit version.
    
    Returns:
    True if set to not null value.
  - initCommitVersion
```
public void initCommitVersion()
```
  - close
```
public void close()
           throws IgniteCheckedException
```
    Description copied from interface: IgniteInternalTx
    
    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 IgniteInternalTx<K,V>
    
    Throws:
    
    IgniteCheckedException - If transaction could not be gracefully ended.
  - needsCompletedVersions
```
public boolean needsCompletedVersions()
```
    Specified by:
    
    needsCompletedVersions in interface IgniteInternalTx<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 IgniteInternalTx<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 IgniteCheckedException
```
    Awaits transaction completion.
    
    Throws:
    
    IgniteCheckedException - If waiting failed.
  - internal
```
public boolean internal()
```
    Specified by:
    
    internal in interface IgniteInternalTx<K,V>
    
    Returns:
    True if transaction has at least one internal entry.
  - checkInternal
```
protected boolean checkInternal(IgniteTxKey<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 IgniteInternalTx<K,V>
    
    Returns:
    Fast commit flag.
  - optimistic
```
public boolean optimistic()
```
    Specified by:
    
    optimistic in interface IgniteInternalTx<K,V>
    
    Returns:
    True for OPTIMISTIC transactions.
  - pessimistic
```
public boolean pessimistic()
```
    Specified by:
    
    pessimistic in interface IgniteInternalTx<K,V>
    
    Returns:
    True for PESSIMISTIC transactions.
  - serializable
```
public boolean serializable()
```
    Specified by:
    
    serializable in interface IgniteInternalTx<K,V>
    
    Returns:
    True if serializable.
  - repeatableRead
```
public boolean repeatableRead()
```
    Specified by:
    
    repeatableRead in interface IgniteInternalTx<K,V>
    
    Returns:
    True if repeatable-read.
  - readCommitted
```
public boolean readCommitted()
```
    Specified by:
    
    readCommitted in interface IgniteInternalTx<K,V>
    
    Returns:
    True if read-committed.
  - state
```
public boolean state(TransactionState state)
```
    Specified by:
    
    state in interface IgniteInternalTx<K,V>
    
    Parameters:
    state - Transaction state.
    
    Returns:
    True if transition was valid, false otherwise.
  - finishFuture
```
public IgniteInternalFuture<IgniteInternalTx> finishFuture()
```
    Specified by:
    
    finishFuture in interface IgniteInternalTx<K,V>
    
    Returns:
    Future for transaction completion.
  - startVersion
```
public GridCacheVersion startVersion()
```
    Specified by:
    
    startVersion in interface IgniteInternalTx<K,V>
    
    Returns:
    Start version.
  - endVersion
```
public GridCacheVersion endVersion()
```
    Specified by:
    
    endVersion in interface IgniteInternalTx<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 IgniteInternalTx<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 IgniteInternalTx<K,V>
    
    Returns:
    Transaction write version. For all transactions except DHT transactions, will be equal to IgniteInternalTx.xidVersion().
  - writeVersion
```
public void writeVersion(GridCacheVersion writeVer)
```
    Sets write version.
    
    Specified by:
    
    writeVersion in interface IgniteInternalTx<K,V>
    
    Parameters:
    writeVer - Write version.
  - timeoutId
```
public IgniteUuid 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 IgniteInternalTx<K,V>
    
    Returns:
    True if transaction timed out.
  - invalidate
```
public void invalidate(boolean invalidate)
```
    Specified by:
    
    invalidate in interface IgniteInternalTx<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 IgniteInternalTx<K,V>
    
    Returns:
    Invalidation flag.
  - isSystemInvalidate
```
public boolean isSystemInvalidate()
```
    Specified by:
    
    isSystemInvalidate in interface IgniteInternalTx<K,V>
    
    Returns:
    System invalidate flag.
  - systemInvalidate
```
public void systemInvalidate(boolean sysInvalidate)
```
    Specified by:
    
    systemInvalidate in interface IgniteInternalTx<K,V>
    
    Parameters:
    sysInvalidate - System invalidate flag.
  - transactionNodes
```
@Nullable
public Map<UUID,Collection<UUID>> transactionNodes()
```
    Specified by:
    
    transactionNodes in interface IgniteInternalTx<K,V>
    
    Returns:
    Transaction nodes mapping (primary node -> related backup nodes).
  - transactionNodes
```
public void transactionNodes(Map<UUID,Collection<UUID>> txNodes)
```
    Parameters:
    txNodes - Transaction nodes.
  - nearXidVersion
```
@Nullable
public GridCacheVersion nearXidVersion()
```
    Specified by:
    
    nearXidVersion in interface IgniteInternalTx<K,V>
    
    Returns:
    Near transaction ID.
  - applyTransformClosures
```
protected GridTuple3<GridCacheOperation,V,byte[]> applyTransformClosures(IgniteTxEntry<K,V> txEntry,
                                                             boolean metrics)
                                                                  throws GridCacheEntryRemovedException,
                                                                         IgniteCheckedException
```
    Parameters:
    txEntry - Entry to process.
    metrics - True if metrics should be updated.
    
    Returns:
    Tuple containing transformation results.
    
    Throws:
    
    IgniteCheckedException - If failed to get previous value for transform.
    
    GridCacheEntryRemovedException - If entry was concurrently deleted.
  - resolveTaskName
```
public String resolveTaskName()
```
    Returns:
    Resolves task name.
  - conflictResolve
```
protected IgniteBiTuple<GridCacheOperation,GridCacheVersionConflictContext<K,V>> conflictResolve(GridCacheOperation op,
                                                                                     K key,
                                                                                     V newVal,
                                                                                     byte[] newValBytes,
                                                                                     long newTtl,
                                                                                     long newDrExpireTime,
                                                                                     GridCacheVersion newVer,
                                                                                     GridCacheEntryEx<K,V> old)
                                                                                          throws IgniteCheckedException,
                                                                                                 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:
    
    IgniteCheckedException - In case of eny exception.
    
    GridCacheEntryRemovedException - If entry got removed.
  - isNearLocallyMapped
```
protected boolean isNearLocallyMapped(IgniteTxEntry<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(IgniteTxEntry<K,V> e,
                     boolean primaryOnly)
                          throws IgniteCheckedException
```
    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:
    
    IgniteCheckedException - 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 unmarshalling.
    
    Returns:
    Reconstructed object.
    
    Throws:
    
    ObjectStreamException - Thrown in case of unmarshalling error.
  - proxy
```
public TransactionProxy proxy()
```
    Specified by:
    
    proxy in interface IgniteInternalTx<K,V>
    
    Returns:
    Public API proxy.
  - 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 IgniteTxAdapter<K,V>

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

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

Field Detail

log

xidVer

writeVer

implicit

implicitSingle

loc

threadId

startTime

nodeId

startVer

cctx

endVer

isolation

concurrency

timeout

invalidate

internal

onePhaseCommit

syncCommit

syncRollback

transform

isDone

txSize

grpLockKey

txNodes

subjId

taskNameHash

taskName

storeEnabled

Constructor Detail

IgniteTxAdapter

IgniteTxAdapter

IgniteTxAdapter

Method Detail

lock

unlock

signalAll

awaitSignal

updateNearCache

optimisticLockEntries

storeEnabled

storeEnabled

system

ioPolicy

storeUsed

store

uncommit

groupLockEntry

otherNodeId

subjectId

taskNameHash

topologyVersion

topologyVersion

hasTransforms

markPreparing

markFinalizing

finalizationStatus

isStarted

groupLock

groupLockKey

size

log

near

implicit

implicitSingle

local

user

dht

colocated

replicated