http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/GridDistributedTxRemoteAdapter.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/GridDistributedTxRemoteAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/GridDistributedTxRemoteAdapter.java index 8dae033..f9e2342 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/GridDistributedTxRemoteAdapter.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/GridDistributedTxRemoteAdapter.java @@ -360,7 +360,7 @@ public class GridDistributedTxRemoteAdapter<K, V> extends IgniteTxAdapter<K, V> } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx<K, V>> prepareAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx<K, V>> prepareAsync() { assert false; return null; } @@ -718,11 +718,11 @@ public class GridDistributedTxRemoteAdapter<K, V> extends IgniteTxAdapter<K, V> } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx> commitAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> commitAsync() { try { commit(); - return new GridFinishedFutureEx<IgniteTxEx>(this); + return new GridFinishedFutureEx<IgniteInternalTx>(this); } catch (IgniteCheckedException e) { return new GridFinishedFutureEx<>(e); @@ -749,10 +749,10 @@ public class GridDistributedTxRemoteAdapter<K, V> extends IgniteTxAdapter<K, V> } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx> rollbackAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> rollbackAsync() { rollback(); - return new GridFinishedFutureEx<IgniteTxEx>(this); + return new GridFinishedFutureEx<IgniteInternalTx>(this); } /** {@inheritDoc} */
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtCacheEntry.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtCacheEntry.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtCacheEntry.java index 550a693..2b244a8 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtCacheEntry.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtCacheEntry.java @@ -234,7 +234,7 @@ public class GridDhtCacheEntry<K, V> extends GridDistributedCacheEntry<K, V> { } /** {@inheritDoc} */ - @Override public boolean tmLock(IgniteTxEx<K, V> tx, long timeout) + @Override public boolean tmLock(IgniteInternalTx<K, V> tx, long timeout) throws GridCacheEntryRemovedException, GridDistributedLockCancelledException { if (tx.local()) { GridDhtTxLocalAdapter<K, V> dhtTx = (GridDhtTxLocalAdapter<K, V>)tx; @@ -436,7 +436,7 @@ public class GridDhtCacheEntry<K, V> extends GridDistributedCacheEntry<K, V> { if (!F.isEmpty(cands)) { for (GridCacheMvccCandidate<K> c : cands) { - IgniteTxEx<K, V> tx = cctx.tm().tx(c.version()); + IgniteInternalTx<K, V> tx = cctx.tm().tx(c.version()); if (tx != null) { assert tx.local(); http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTransactionalCacheAdapter.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTransactionalCacheAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTransactionalCacheAdapter.java index c6474ed..57c3455 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTransactionalCacheAdapter.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTransactionalCacheAdapter.java @@ -869,8 +869,8 @@ public abstract class GridDhtTransactionalCacheAdapter<K, V> extends GridDhtCach assert t.implicit(); return t.commitAsync().chain( - new C1<IgniteInternalFuture<IgniteTxEx>, GridNearLockResponse<K, V>>() { - @Override public GridNearLockResponse<K, V> apply(IgniteInternalFuture<IgniteTxEx> f) { + new C1<IgniteInternalFuture<IgniteInternalTx>, GridNearLockResponse<K, V>>() { + @Override public GridNearLockResponse<K, V> apply(IgniteInternalFuture<IgniteInternalTx> f) { try { // Check for error. f.get(); @@ -1096,7 +1096,7 @@ public abstract class GridDhtTransactionalCacheAdapter<K, V> extends GridDhtCach */ private void sendLockReply( ClusterNode nearNode, - @Nullable IgniteTxEx<K,V> tx, + @Nullable IgniteInternalTx<K,V> tx, GridNearLockRequest<K, V> req, GridNearLockResponse<K, V> res ) { http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxFinishFuture.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxFinishFuture.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxFinishFuture.java index fbb2a69..ac2b55a 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxFinishFuture.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxFinishFuture.java @@ -43,8 +43,8 @@ import static org.apache.ignite.internal.managers.communication.GridIoPolicy.*; /** * */ -public final class GridDhtTxFinishFuture<K, V> extends GridCompoundIdentityFuture<IgniteTxEx> - implements GridCacheFuture<IgniteTxEx> { +public final class GridDhtTxFinishFuture<K, V> extends GridCompoundIdentityFuture<IgniteInternalTx> + implements GridCacheFuture<IgniteInternalTx> { /** */ private static final long serialVersionUID = 0L; @@ -93,7 +93,7 @@ public final class GridDhtTxFinishFuture<K, V> extends GridCompoundIdentityFutur * @param commit Commit flag. */ public GridDhtTxFinishFuture(GridCacheSharedContext<K, V> cctx, GridDhtTxLocalAdapter<K, V> tx, boolean commit) { - super(cctx.kernalContext(), F.<IgniteTxEx>identityReducer(tx)); + super(cctx.kernalContext(), F.<IgniteInternalTx>identityReducer(tx)); assert cctx != null; @@ -201,7 +201,7 @@ public final class GridDhtTxFinishFuture<K, V> extends GridCompoundIdentityFutur */ public void onResult(UUID nodeId, GridDhtTxFinishResponse<K, V> res) { if (!isDone()) { - for (IgniteInternalFuture<IgniteTxEx> fut : futures()) { + for (IgniteInternalFuture<IgniteInternalTx> fut : futures()) { if (isMini(fut)) { MiniFuture f = (MiniFuture)fut; @@ -216,7 +216,7 @@ public final class GridDhtTxFinishFuture<K, V> extends GridCompoundIdentityFutur } /** {@inheritDoc} */ - @Override public boolean onDone(IgniteTxEx tx, Throwable err) { + @Override public boolean onDone(IgniteInternalTx tx, Throwable err) { if (initialized() || err != null) { if (this.tx.onePhaseCommit() && (this.tx.state() == COMMITTING)) this.tx.tmCommit(); @@ -446,7 +446,7 @@ public final class GridDhtTxFinishFuture<K, V> extends GridCompoundIdentityFutur * Mini-future for get operations. Mini-futures are only waiting on a single * node as opposed to multiple nodes. */ - private class MiniFuture extends GridFutureAdapter<IgniteTxEx> { + private class MiniFuture extends GridFutureAdapter<IgniteInternalTx> { /** */ private static final long serialVersionUID = 0L; http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxLocal.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxLocal.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxLocal.java index ec71035..2c55311 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxLocal.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxLocal.java @@ -278,7 +278,7 @@ public class GridDhtTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> implements } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx<K, V>> prepareAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx<K, V>> prepareAsync() { if (optimistic()) { assert isSystemInvalidate(); @@ -350,7 +350,7 @@ public class GridDhtTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> implements * @param lastBackups IDs of backup nodes receiving last prepare request. * @return Future that will be completed when locks are acquired. */ - public IgniteInternalFuture<IgniteTxEx<K, V>> prepareAsync(@Nullable Iterable<IgniteTxEntry<K, V>> reads, + public IgniteInternalFuture<IgniteInternalTx<K, V>> prepareAsync(@Nullable Iterable<IgniteTxEntry<K, V>> reads, @Nullable Iterable<IgniteTxEntry<K, V>> writes, Map<IgniteTxKey<K>, GridCacheVersion> verMap, long msgId, @@ -451,7 +451,7 @@ public class GridDhtTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> implements /** {@inheritDoc} */ @SuppressWarnings({"ThrowableInstanceNeverThrown"}) - @Override public IgniteInternalFuture<IgniteTxEx> commitAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> commitAsync() { if (log.isDebugEnabled()) log.debug("Committing dht local tx: " + this); @@ -488,8 +488,8 @@ public class GridDhtTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> implements } } else - prep.listenAsync(new CI1<IgniteInternalFuture<IgniteTxEx<K, V>>>() { - @Override public void apply(IgniteInternalFuture<IgniteTxEx<K, V>> f) { + prep.listenAsync(new CI1<IgniteInternalFuture<IgniteInternalTx<K, V>>>() { + @Override public void apply(IgniteInternalFuture<IgniteInternalTx<K, V>> f) { try { f.get(); // Check for errors of a parent future. @@ -546,7 +546,7 @@ public class GridDhtTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> implements } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx> rollbackAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> rollbackAsync() { GridDhtTxPrepareFuture<K, V> prepFut = this.prepFut.get(); final GridDhtTxFinishFuture<K, V> fut = new GridDhtTxFinishFuture<>(cctx, this, /*rollback*/false); @@ -576,8 +576,8 @@ public class GridDhtTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> implements else { prepFut.complete(); - prepFut.listenAsync(new CI1<IgniteInternalFuture<IgniteTxEx<K, V>>>() { - @Override public void apply(IgniteInternalFuture<IgniteTxEx<K, V>> f) { + prepFut.listenAsync(new CI1<IgniteInternalFuture<IgniteInternalTx<K, V>>>() { + @Override public void apply(IgniteInternalFuture<IgniteInternalTx<K, V>> f) { try { f.get(); // Check for errors of a parent future. } http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxPrepareFuture.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxPrepareFuture.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxPrepareFuture.java index 72799f1..8f45c7f 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxPrepareFuture.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtTxPrepareFuture.java @@ -46,8 +46,8 @@ import static org.apache.ignite.internal.managers.communication.GridIoPolicy.*; /** * */ -public final class GridDhtTxPrepareFuture<K, V> extends GridCompoundIdentityFuture<IgniteTxEx<K, V>> - implements GridCacheMvccFuture<K, V, IgniteTxEx<K, V>> { +public final class GridDhtTxPrepareFuture<K, V> extends GridCompoundIdentityFuture<IgniteInternalTx<K, V>> + implements GridCacheMvccFuture<K, V, IgniteInternalTx<K, V>> { /** */ private static final long serialVersionUID = 0L; @@ -123,12 +123,12 @@ public final class GridDhtTxPrepareFuture<K, V> extends GridCompoundIdentityFutu */ public GridDhtTxPrepareFuture(GridCacheSharedContext<K, V> cctx, final GridDhtTxLocalAdapter<K, V> tx, IgniteUuid nearMiniId, Map<IgniteTxKey<K>, GridCacheVersion> dhtVerMap, boolean last, Collection<UUID> lastBackups) { - super(cctx.kernalContext(), new IgniteReducer<IgniteTxEx<K, V>, IgniteTxEx<K, V>>() { - @Override public boolean collect(IgniteTxEx<K, V> e) { + super(cctx.kernalContext(), new IgniteReducer<IgniteInternalTx<K, V>, IgniteInternalTx<K, V>>() { + @Override public boolean collect(IgniteInternalTx<K, V> e) { return true; } - @Override public IgniteTxEx<K, V> reduce() { + @Override public IgniteInternalTx<K, V> reduce() { // Nothing to aggregate. return tx; } @@ -307,7 +307,7 @@ public final class GridDhtTxPrepareFuture<K, V> extends GridCompoundIdentityFutu */ public void onResult(UUID nodeId, GridDhtTxPrepareResponse<K, V> res) { if (!isDone()) { - for (IgniteInternalFuture<IgniteTxEx<K, V>> fut : pending()) { + for (IgniteInternalFuture<IgniteInternalTx<K, V>> fut : pending()) { if (isMini(fut)) { MiniFuture f = (MiniFuture)fut; @@ -376,7 +376,7 @@ public final class GridDhtTxPrepareFuture<K, V> extends GridCompoundIdentityFutu } /** {@inheritDoc} */ - @Override public boolean onDone(IgniteTxEx<K, V> tx0, Throwable err) { + @Override public boolean onDone(IgniteInternalTx<K, V> tx0, Throwable err) { assert err != null || (initialized() && !hasPending()) : "On done called for prepare future that has " + "pending mini futures: " + this; @@ -891,7 +891,7 @@ public final class GridDhtTxPrepareFuture<K, V> extends GridCompoundIdentityFutu * Mini-future for get operations. Mini-futures are only waiting on a single * node as opposed to multiple nodes. */ - private class MiniFuture extends GridFutureAdapter<IgniteTxEx<K, V>> { + private class MiniFuture extends GridFutureAdapter<IgniteInternalTx<K, V>> { /** */ private static final long serialVersionUID = 0L; http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearCacheAdapter.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearCacheAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearCacheAdapter.java index 7d7fb35..235929e 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearCacheAdapter.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearCacheAdapter.java @@ -174,7 +174,7 @@ public abstract class GridNearCacheAdapter<K, V> extends GridDistributedCacheAda /** {@inheritDoc} */ @SuppressWarnings({"unchecked", "RedundantCast"}) @Override public IgniteInternalFuture<Object> readThroughAllAsync(Collection<? extends K> keys, boolean reload, - IgniteTxEx<K, V> tx, IgnitePredicate<CacheEntry<K, V>>[] filter, @Nullable UUID subjId, String taskName, + IgniteInternalTx<K, V> tx, IgnitePredicate<CacheEntry<K, V>>[] filter, @Nullable UUID subjId, String taskName, IgniteBiInClosure<K, V> vis) { return (IgniteInternalFuture)loadAsync(tx, keys, @@ -272,7 +272,7 @@ public abstract class GridNearCacheAdapter<K, V> extends GridDistributedCacheAda * @param expiryPlc Expiry policy. * @return Loaded values. */ - public IgniteInternalFuture<Map<K, V>> loadAsync(@Nullable IgniteTxEx tx, + public IgniteInternalFuture<Map<K, V>> loadAsync(@Nullable IgniteInternalTx tx, @Nullable Collection<? extends K> keys, boolean reload, boolean forcePrimary, http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearCacheEntry.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearCacheEntry.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearCacheEntry.java index a113a63..2974cf4 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearCacheEntry.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearCacheEntry.java @@ -315,7 +315,7 @@ public class GridNearCacheEntry<K, V> extends GridDistributedCacheEntry<K, V> { } /** {@inheritDoc} */ - @Override protected V readThrough(IgniteTxEx<K, V> tx, K key, boolean reload, + @Override protected V readThrough(IgniteInternalTx<K, V> tx, K key, boolean reload, IgnitePredicate<CacheEntry<K, V>>[] filter, UUID subjId, String taskName) throws IgniteCheckedException { return cctx.near().loadAsync(tx, F.asList(key), @@ -346,7 +346,7 @@ public class GridNearCacheEntry<K, V> extends GridDistributedCacheEntry<K, V> { * @throws GridCacheEntryRemovedException If entry was removed. */ @SuppressWarnings({"RedundantTypeArguments"}) - public boolean loadedValue(@Nullable IgniteTxEx tx, UUID primaryNodeId, V val, byte[] valBytes, + public boolean loadedValue(@Nullable IgniteInternalTx tx, UUID primaryNodeId, V val, byte[] valBytes, GridCacheVersion ver, GridCacheVersion dhtVer, @Nullable GridCacheVersion expVer, long ttl, long expireTime, boolean evt, long topVer, UUID subjId) throws IgniteCheckedException, GridCacheEntryRemovedException { http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxFinishFuture.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxFinishFuture.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxFinishFuture.java index 8b7d340..f0fa418 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxFinishFuture.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxFinishFuture.java @@ -45,8 +45,8 @@ import static org.apache.ignite.internal.processors.cache.GridCacheOperation.*; /** * */ -public final class GridNearTxFinishFuture<K, V> extends GridCompoundIdentityFuture<IgniteTxEx> - implements GridCacheFuture<IgniteTxEx> { +public final class GridNearTxFinishFuture<K, V> extends GridCompoundIdentityFuture<IgniteInternalTx> + implements GridCacheFuture<IgniteInternalTx> { /** */ private static final long serialVersionUID = 0L; @@ -91,7 +91,7 @@ public final class GridNearTxFinishFuture<K, V> extends GridCompoundIdentityFutu * @param commit Commit flag. */ public GridNearTxFinishFuture(GridCacheSharedContext<K, V> cctx, GridNearTxLocal<K, V> tx, boolean commit) { - super(cctx.kernalContext(), F.<IgniteTxEx>identityReducer(tx)); + super(cctx.kernalContext(), F.<IgniteInternalTx>identityReducer(tx)); assert cctx != null; @@ -200,7 +200,7 @@ public final class GridNearTxFinishFuture<K, V> extends GridCompoundIdentityFutu */ public void onResult(UUID nodeId, GridNearTxFinishResponse<K, V> res) { if (!isDone()) - for (IgniteInternalFuture<IgniteTxEx> fut : futures()) { + for (IgniteInternalFuture<IgniteInternalTx> fut : futures()) { if (isMini(fut)) { MiniFuture f = (MiniFuture)fut; @@ -214,7 +214,7 @@ public final class GridNearTxFinishFuture<K, V> extends GridCompoundIdentityFutu } /** {@inheritDoc} */ - @Override public boolean onDone(IgniteTxEx tx, Throwable err) { + @Override public boolean onDone(IgniteInternalTx tx, Throwable err) { if ((initialized() || err != null)) { if (this.tx.onePhaseCommit() && (this.tx.state() == COMMITTING)) this.tx.tmCommit(); @@ -283,7 +283,7 @@ public final class GridNearTxFinishFuture<K, V> extends GridCompoundIdentityFutu // Finish local mapping only as we need send commit message to backups. for (GridDistributedTxMapping<K, V> m : mappings.values()) { if (m.node().isLocal()) { - IgniteInternalFuture<IgniteTxEx> fut = cctx.tm().txHandler().finishColocatedLocal(commit, tx); + IgniteInternalFuture<IgniteInternalTx> fut = cctx.tm().txHandler().finishColocatedLocal(commit, tx); // Add new future. if (fut != null) @@ -370,7 +370,7 @@ public final class GridNearTxFinishFuture<K, V> extends GridCompoundIdentityFutu if (n.isLocal()) { req.miniId(IgniteUuid.randomUuid()); - IgniteInternalFuture<IgniteTxEx> fut = cctx.tm().txHandler().finish(n.id(), tx, req); + IgniteInternalFuture<IgniteInternalTx> fut = cctx.tm().txHandler().finish(n.id(), tx, req); // Add new future. if (fut != null) @@ -415,7 +415,7 @@ public final class GridNearTxFinishFuture<K, V> extends GridCompoundIdentityFutu * Mini-future for get operations. Mini-futures are only waiting on a single * node as opposed to multiple nodes. */ - private class MiniFuture extends GridFutureAdapter<IgniteTxEx> { + private class MiniFuture extends GridFutureAdapter<IgniteInternalTx> { /** */ private static final long serialVersionUID = 0L; http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxLocal.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxLocal.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxLocal.java index e39d67f..f8a482b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxLocal.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxLocal.java @@ -62,7 +62,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { new ConcurrentHashMap8<>(); /** Future. */ - private final AtomicReference<IgniteInternalFuture<IgniteTxEx<K, V>>> prepFut = + private final AtomicReference<IgniteInternalFuture<IgniteInternalTx<K, V>>> prepFut = new AtomicReference<>(); /** */ @@ -542,7 +542,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { /** {@inheritDoc} */ @Override public boolean onOwnerChanged(GridCacheEntryEx<K, V> entry, GridCacheMvccCandidate<K> owner) { - GridCacheMvccFuture<K, V, IgniteTxEx<K, V>> fut = (GridCacheMvccFuture<K, V, IgniteTxEx<K, V>>)prepFut + GridCacheMvccFuture<K, V, IgniteInternalTx<K, V>> fut = (GridCacheMvccFuture<K, V, IgniteInternalTx<K, V>>)prepFut .get(); return fut != null && fut.onOwnerChanged(entry, owner); @@ -695,8 +695,8 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx<K, V>> prepareAsync() { - IgniteInternalFuture<IgniteTxEx<K, V>> fut = prepFut.get(); + @Override public IgniteInternalFuture<IgniteInternalTx<K, V>> prepareAsync() { + IgniteInternalFuture<IgniteInternalTx<K, V>> fut = prepFut.get(); if (fut == null) { // Future must be created before any exception can be thrown. @@ -763,7 +763,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { /** {@inheritDoc} */ @SuppressWarnings({"ThrowableInstanceNeverThrown"}) - @Override public IgniteInternalFuture<IgniteTxEx> commitAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> commitAsync() { if (log.isDebugEnabled()) log.debug("Committing near local tx: " + this); @@ -776,10 +776,10 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { cctx.mvcc().addFuture(fut); - IgniteInternalFuture<IgniteTxEx<K, V>> prepareFut = prepFut.get(); + IgniteInternalFuture<IgniteInternalTx<K, V>> prepareFut = prepFut.get(); - prepareFut.listenAsync(new CI1<IgniteInternalFuture<IgniteTxEx<K, V>>>() { - @Override public void apply(IgniteInternalFuture<IgniteTxEx<K, V>> f) { + prepareFut.listenAsync(new CI1<IgniteInternalFuture<IgniteInternalTx<K, V>>>() { + @Override public void apply(IgniteInternalFuture<IgniteInternalTx<K, V>> f) { GridNearTxFinishFuture<K, V> fut0 = commitFut.get(); try { @@ -809,7 +809,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx> rollbackAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> rollbackAsync() { if (log.isDebugEnabled()) log.debug("Rolling back near tx: " + this); @@ -823,7 +823,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { cctx.mvcc().addFuture(fut); - IgniteInternalFuture<IgniteTxEx<K, V>> prepFut = this.prepFut.get(); + IgniteInternalFuture<IgniteInternalTx<K, V>> prepFut = this.prepFut.get(); if (prepFut == null || prepFut.isDone()) { try { @@ -847,8 +847,8 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { } } else { - prepFut.listenAsync(new CI1<IgniteInternalFuture<IgniteTxEx<K, V>>>() { - @Override public void apply(IgniteInternalFuture<IgniteTxEx<K, V>> f) { + prepFut.listenAsync(new CI1<IgniteInternalFuture<IgniteInternalTx<K, V>>>() { + @Override public void apply(IgniteInternalFuture<IgniteInternalTx<K, V>> f) { try { // Check for errors in prepare future. f.get(); @@ -891,7 +891,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { * @return Future that will be completed when locks are acquired. */ @SuppressWarnings("TypeMayBeWeakened") - public IgniteInternalFuture<IgniteTxEx<K, V>> prepareAsyncLocal(@Nullable Collection<IgniteTxEntry<K, V>> reads, + public IgniteInternalFuture<IgniteInternalTx<K, V>> prepareAsyncLocal(@Nullable Collection<IgniteTxEntry<K, V>> reads, @Nullable Collection<IgniteTxEntry<K, V>> writes, Map<UUID, Collection<UUID>> txNodes, boolean last, Collection<UUID> lastBackups) { assert optimistic(); @@ -957,7 +957,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { * * @return Commit future. */ - public IgniteInternalFuture<IgniteTxEx> commitAsyncLocal() { + public IgniteInternalFuture<IgniteInternalTx> commitAsyncLocal() { if (log.isDebugEnabled()) log.debug("Committing colocated tx locally: " + this); @@ -965,14 +965,14 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { if (pessimistic()) prepareAsync(); - IgniteInternalFuture<IgniteTxEx<K, V>> prep = prepFut.get(); + IgniteInternalFuture<IgniteInternalTx<K, V>> prep = prepFut.get(); // Do not create finish future if there are no remote nodes. if (F.isEmpty(dhtMap) && F.isEmpty(nearMap)) { if (prep != null) - return (IgniteInternalFuture<IgniteTxEx>)(IgniteInternalFuture)prep; + return (IgniteInternalFuture<IgniteInternalTx>)(IgniteInternalFuture)prep; - return new GridFinishedFuture<IgniteTxEx>(cctx.kernalContext(), this); + return new GridFinishedFuture<IgniteInternalTx>(cctx.kernalContext(), this); } final GridDhtTxFinishFuture<K, V> fut = new GridDhtTxFinishFuture<>(cctx, this, /*commit*/true); @@ -1001,8 +1001,8 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { } } else - prep.listenAsync(new CI1<IgniteInternalFuture<IgniteTxEx<K, V>>>() { - @Override public void apply(IgniteInternalFuture<IgniteTxEx<K, V>> f) { + prep.listenAsync(new CI1<IgniteInternalFuture<IgniteInternalTx<K, V>>>() { + @Override public void apply(IgniteInternalFuture<IgniteInternalTx<K, V>> f) { try { f.get(); // Check for errors of a parent future. @@ -1030,7 +1030,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { * * @return Commit future. */ - public IgniteInternalFuture<IgniteTxEx> rollbackAsyncLocal() { + public IgniteInternalFuture<IgniteInternalTx> rollbackAsyncLocal() { if (log.isDebugEnabled()) log.debug("Rolling back colocated tx locally: " + this); @@ -1038,7 +1038,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { cctx.mvcc().addFuture(fut); - IgniteInternalFuture<IgniteTxEx<K, V>> prep = prepFut.get(); + IgniteInternalFuture<IgniteInternalTx<K, V>> prep = prepFut.get(); if (prep == null || prep.isDone()) { try { @@ -1054,8 +1054,8 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { fut.finish(); } else - prep.listenAsync(new CI1<IgniteInternalFuture<IgniteTxEx<K, V>>>() { - @Override public void apply(IgniteInternalFuture<IgniteTxEx<K, V>> f) { + prep.listenAsync(new CI1<IgniteInternalFuture<IgniteInternalTx<K, V>>>() { + @Override public void apply(IgniteInternalFuture<IgniteInternalTx<K, V>> f) { try { f.get(); // Check for errors of a parent future. } @@ -1245,13 +1245,13 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { /** * */ - private static class PessimisticPrepareFuture<K, V> extends GridFutureAdapter<IgniteTxEx<K, V>> { + private static class PessimisticPrepareFuture<K, V> extends GridFutureAdapter<IgniteInternalTx<K, V>> { /** */ private static final long serialVersionUID = 0L; /** Transaction. */ @GridToStringExclude - private IgniteTxEx<K, V> tx; + private IgniteInternalTx<K, V> tx; /** * Empty constructor required by {@link Externalizable}. @@ -1264,7 +1264,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> { * @param ctx Kernal context. * @param tx Transaction. */ - private PessimisticPrepareFuture(GridKernalContext ctx, IgniteTxEx<K, V> tx) { + private PessimisticPrepareFuture(GridKernalContext ctx, IgniteInternalTx<K, V> tx) { super(ctx); this.tx = tx; } http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxPrepareFuture.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxPrepareFuture.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxPrepareFuture.java index 134a8ff..0898003 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxPrepareFuture.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxPrepareFuture.java @@ -48,8 +48,8 @@ import static org.apache.ignite.internal.processors.cache.GridCacheOperation.*; /** * */ -public final class GridNearTxPrepareFuture<K, V> extends GridCompoundIdentityFuture<IgniteTxEx<K, V>> - implements GridCacheMvccFuture<K, V, IgniteTxEx<K, V>> { +public final class GridNearTxPrepareFuture<K, V> extends GridCompoundIdentityFuture<IgniteInternalTx<K, V>> + implements GridCacheMvccFuture<K, V, IgniteInternalTx<K, V>> { /** */ private static final long serialVersionUID = 0L; @@ -91,12 +91,12 @@ public final class GridNearTxPrepareFuture<K, V> extends GridCompoundIdentityFut * @param tx Transaction. */ public GridNearTxPrepareFuture(GridCacheSharedContext<K, V> cctx, final GridNearTxLocal<K, V> tx) { - super(cctx.kernalContext(), new IgniteReducer<IgniteTxEx<K, V>, IgniteTxEx<K, V>>() { - @Override public boolean collect(IgniteTxEx<K, V> e) { + super(cctx.kernalContext(), new IgniteReducer<IgniteInternalTx<K, V>, IgniteInternalTx<K, V>>() { + @Override public boolean collect(IgniteInternalTx<K, V> e) { return true; } - @Override public IgniteTxEx<K, V> reduce() { + @Override public IgniteInternalTx<K, V> reduce() { // Nothing to aggregate. return tx; } @@ -263,7 +263,7 @@ public final class GridNearTxPrepareFuture<K, V> extends GridCompoundIdentityFut */ public void onResult(UUID nodeId, GridNearTxPrepareResponse<K, V> res) { if (!isDone()) { - for (IgniteInternalFuture<IgniteTxEx<K, V>> fut : pending()) { + for (IgniteInternalFuture<IgniteInternalTx<K, V>> fut : pending()) { if (isMini(fut)) { MiniFuture f = (MiniFuture)fut; @@ -278,7 +278,7 @@ public final class GridNearTxPrepareFuture<K, V> extends GridCompoundIdentityFut } /** {@inheritDoc} */ - @Override public boolean onDone(IgniteTxEx<K, V> t, Throwable err) { + @Override public boolean onDone(IgniteInternalTx<K, V> t, Throwable err) { // If locks were not acquired yet, delay completion. if (isDone() || (err == null && !checkLocks())) return false; @@ -601,14 +601,14 @@ public final class GridNearTxPrepareFuture<K, V> extends GridCompoundIdentityFut // At this point, if any new node joined, then it is // waiting for this transaction to complete, so // partition reassignments are not possible here. - IgniteInternalFuture<IgniteTxEx<K, V>> fut = cctx.tm().txHandler().prepareTx(n.id(), tx, req); + IgniteInternalFuture<IgniteInternalTx<K, V>> fut = cctx.tm().txHandler().prepareTx(n.id(), tx, req); // Add new future. add(new GridEmbeddedFuture<>( cctx.kernalContext(), fut, - new C2<IgniteTxEx<K, V>, Exception, IgniteTxEx<K, V>>() { - @Override public IgniteTxEx<K, V> apply(IgniteTxEx<K, V> t, Exception ex) { + new C2<IgniteInternalTx<K, V>, Exception, IgniteInternalTx<K, V>>() { + @Override public IgniteInternalTx<K, V> apply(IgniteInternalTx<K, V> t, Exception ex) { if (ex != null) { onError(n.id(), mappings, ex); @@ -737,7 +737,7 @@ public final class GridNearTxPrepareFuture<K, V> extends GridCompoundIdentityFut * Mini-future for get operations. Mini-futures are only waiting on a single * node as opposed to multiple nodes. */ - private class MiniFuture extends GridFutureAdapter<IgniteTxEx<K, V>> { + private class MiniFuture extends GridFutureAdapter<IgniteInternalTx<K, V>> { /** */ private static final long serialVersionUID = 0L; http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxPrepareRequest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxPrepareRequest.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxPrepareRequest.java index 8aecfe0..5fd686a 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxPrepareRequest.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxPrepareRequest.java @@ -90,7 +90,7 @@ public class GridNearTxPrepareRequest<K, V> extends GridDistributedTxPrepareRequ public GridNearTxPrepareRequest( IgniteUuid futId, long topVer, - IgniteTxEx<K, V> tx, + IgniteInternalTx<K, V> tx, Collection<IgniteTxEntry<K, V>> reads, Collection<IgniteTxEntry<K, V>> writes, IgniteTxKey grpLockKey, http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalCacheEntry.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalCacheEntry.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalCacheEntry.java index 0144617..6c51860 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalCacheEntry.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalCacheEntry.java @@ -180,7 +180,7 @@ public class GridLocalCacheEntry<K, V> extends GridCacheMapEntry<K, V> { } /** {@inheritDoc} */ - @Override public boolean tmLock(IgniteTxEx<K, V> tx, long timeout) throws GridCacheEntryRemovedException { + @Override public boolean tmLock(IgniteInternalTx<K, V> tx, long timeout) throws GridCacheEntryRemovedException { GridCacheMvccCandidate<K> cand = addLocal( tx.threadId(), tx.xidVersion(), @@ -276,7 +276,7 @@ public class GridLocalCacheEntry<K, V> extends GridCacheMapEntry<K, V> { * * @param tx Transaction to unlock. */ - @Override public void txUnlock(IgniteTxEx<K, V> tx) throws GridCacheEntryRemovedException { + @Override public void txUnlock(IgniteInternalTx<K, V> tx) throws GridCacheEntryRemovedException { removeLock(tx.xidVersion()); } http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalTx.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalTx.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalTx.java index e53c98b..8a0f0b7 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalTx.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalTx.java @@ -107,11 +107,11 @@ class GridLocalTx<K, V> extends IgniteTxLocalAdapter<K, V> { } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx<K, V>> prepareAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx<K, V>> prepareAsync() { try { prepare(); - return new GridFinishedFuture<IgniteTxEx<K, V>>(cctx.kernalContext(), this); + return new GridFinishedFuture<IgniteInternalTx<K, V>>(cctx.kernalContext(), this); } catch (IgniteCheckedException e) { return new GridFinishedFuture<>(cctx.kernalContext(), e); @@ -146,7 +146,7 @@ class GridLocalTx<K, V> extends IgniteTxLocalAdapter<K, V> { /** {@inheritDoc} */ @SuppressWarnings( {"unchecked", "RedundantCast"}) - @Override public IgniteInternalFuture<IgniteTxEx> commitAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> commitAsync() { try { prepare(); } @@ -177,7 +177,7 @@ class GridLocalTx<K, V> extends IgniteTxLocalAdapter<K, V> { } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx> rollbackAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> rollbackAsync() { try { state(ROLLING_BACK); @@ -185,7 +185,7 @@ class GridLocalTx<K, V> extends IgniteTxLocalAdapter<K, V> { state(ROLLED_BACK); - return new GridFinishedFuture<IgniteTxEx>(cctx.kernalContext(), this); + return new GridFinishedFuture<IgniteInternalTx>(cctx.kernalContext(), this); } catch (IgniteCheckedException e) { return new GridFinishedFuture<>(cctx.kernalContext(), e); http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalTxFuture.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalTxFuture.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalTxFuture.java index 552e7c0..6784c1b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalTxFuture.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/local/GridLocalTxFuture.java @@ -37,8 +37,8 @@ import static org.apache.ignite.transactions.IgniteTxState.*; /** * Replicated cache transaction future. */ -final class GridLocalTxFuture<K, V> extends GridFutureAdapter<IgniteTxEx<K, V>> - implements GridCacheMvccFuture<K, V, IgniteTxEx<K, V>> { +final class GridLocalTxFuture<K, V> extends GridFutureAdapter<IgniteInternalTx<K, V>> + implements GridCacheMvccFuture<K, V, IgniteInternalTx<K, V>> { /** */ private static final long serialVersionUID = 0L; http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteInternalTx.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteInternalTx.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteInternalTx.java new file mode 100644 index 0000000..be83e25 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteInternalTx.java @@ -0,0 +1,706 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.processors.cache.transactions; + +import org.apache.ignite.*; +import org.apache.ignite.cache.*; +import org.apache.ignite.internal.*; +import org.apache.ignite.internal.processors.cache.*; +import org.apache.ignite.internal.processors.cache.version.*; +import org.apache.ignite.internal.transactions.*; +import org.apache.ignite.lang.*; +import org.apache.ignite.transactions.*; +import org.apache.ignite.internal.processors.timeout.*; +import org.apache.ignite.internal.util.lang.*; +import org.jetbrains.annotations.*; + +import java.util.*; + +/** + * Transaction managed by cache ({@code 'Ex'} stands for external). + */ +public interface IgniteInternalTx<K, V> extends AutoCloseable, GridTimeoutObject { + /** + * + */ + @SuppressWarnings("PublicInnerClass") + public enum FinalizationStatus { + /** Transaction was not finalized yet. */ + NONE, + + /** Transaction is being finalized by user. */ + USER_FINISH, + + /** Recovery request is received, user finish requests should be ignored. */ + RECOVERY_WAIT, + + /** Transaction is being finalized by recovery procedure. */ + RECOVERY_FINISH + } + + /** + * Gets unique identifier for this transaction. + * + * @return Transaction UID. + */ + public IgniteUuid xid(); + + /** + * ID of the node on which this transaction started. + * + * @return Originating node ID. + */ + public UUID nodeId(); + + /** + * ID of the thread in which this transaction started. + * + * @return Thread ID. + */ + public long threadId(); + + /** + * Start time of this transaction. + * + * @return Start time of this transaction on this node. + */ + public long startTime(); + + /** + * Cache transaction isolation level. + * + * @return Isolation level. + */ + public IgniteTxIsolation isolation(); + + /** + * Cache transaction concurrency mode. + * + * @return Concurrency mode. + */ + public IgniteTxConcurrency concurrency(); + + /** + * Flag indicating whether transaction was started automatically by the + * system or not. System will start transactions implicitly whenever + * any cache {@code put(..)} or {@code remove(..)} operation is invoked + * outside of transaction. + * + * @return {@code True} if transaction was started implicitly. + */ + public boolean implicit(); + + /** + * Get invalidation flag for this transaction. If set to {@code true}, then + * remote values will be {@code invalidated} (set to {@code null}) instead + * of updated. + * <p> + * 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. + * + * @return Invalidation flag. + */ + public boolean isInvalidate(); + + /** + * Gets current transaction state value. + * + * @return Current transaction state. + */ + public IgniteTxState state(); + + /** + * Gets timeout value in milliseconds for this transaction. If transaction times + * out prior to it's completion, {@link org.apache.ignite.internal.transactions.IgniteTxTimeoutCheckedException} will be thrown. + * + * @return Transaction timeout value. + */ + public long timeout(); + + /** + * Sets transaction timeout value. This value can be set only before a first operation + * on transaction has been performed. + * + * @param timeout Transaction timeout value. + * @return Previous timeout. + */ + public long timeout(long timeout); + + /** + * Modify the transaction associated with the current thread such that the + * only possible outcome of the transaction is to roll back the + * transaction. + * + * @return {@code True} if rollback-only flag was set as a result of this operation, + * {@code 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. + */ + public boolean setRollbackOnly(); + + /** + * If transaction was marked as rollback-only. + * + * @return {@code True} if transaction can only be rolled back. + */ + public boolean isRollbackOnly(); + + /** + * Commits this transaction by initiating {@code two-phase-commit} process. + * + * @throws IgniteCheckedException If commit failed. + */ + @IgniteAsyncSupported + public void commit() throws IgniteCheckedException; + + /** + * Ends the transaction. Transaction will be rolled back if it has not been committed. + * + * @throws IgniteCheckedException If transaction could not be gracefully ended. + */ + @Override public void close() throws IgniteCheckedException; + + /** + * Rolls back this transaction. + * + * @throws IgniteCheckedException If rollback failed. + */ + @IgniteAsyncSupported + public void rollback() throws IgniteCheckedException; + + /** + * Removes metadata by name. + * + * @param name Name of the metadata to remove. + * @param <T> Type of the value. + * @return Value of removed metadata or {@code null}. + */ + @Nullable public <T> T removeMeta(String name); + + /** + * Gets metadata by name. + * + * @param name Metadata name. + * @param <T> Type of the value. + * @return Metadata value or {@code null}. + */ + @Nullable public <T> T meta(String name); + + /** + * Adds a new metadata. + * + * @param name Metadata name. + * @param val Metadata value. + * @param <T> Type of the value. + * @return Metadata previously associated with given name, or + * {@code null} if there was none. + */ + @Nullable public <T> T addMeta(String name, T val); + + /** + * @return Size of the transaction. + */ + public int size(); + + /** + * @return {@code True} if transaction is allowed to use store. + */ + public boolean storeEnabled(); + + /** + * @return {@code True} if transaction is allowed to use store and transactions spans one or more caches with + * store enabled. + */ + public boolean storeUsed(); + + /** + * 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. + * + * @return {@code True} if transaction is started for system cache. + */ + public boolean system(); + + /** + * @return Last recorded topology version. + */ + public long topologyVersion(); + + /** + * @return Flag indicating whether transaction is implicit with only one key. + */ + public boolean implicitSingle(); + + /** + * @return Collection of cache IDs involved in this transaction. + */ + public Collection<Integer> activeCacheIds(); + + /** + * 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). + * + * @param topVer Topology version. + * @return Recorded topology version. + */ + public long topologyVersion(long topVer); + + /** + * @return {@code True} if transaction is empty. + */ + public boolean empty(); + + /** + * @return {@code True} if transaction group-locked. + */ + public boolean groupLock(); + + /** + * @return Group lock key if {@link #groupLock()} is {@code true}. + */ + @Nullable public IgniteTxKey groupLockKey(); + + /** + * @return {@code True} if preparing flag was set with this call. + */ + public boolean markPreparing(); + + /** + * @param status Finalization status to set. + * @return {@code True} if could mark was set. + */ + public boolean markFinalizing(FinalizationStatus status); + + /** + * @param cacheCtx Cache context. + * @param part Invalid partition. + */ + public void addInvalidPartition(GridCacheContext<K, V> cacheCtx, int part); + + /** + * @return Invalid partitions. + */ + public Set<Integer> invalidPartitions(); + + /** + * Gets owned version for near remote transaction. + * + * @param key Key to get version for. + * @return Owned version, if any. + */ + @Nullable public GridCacheVersion ownedVersion(IgniteTxKey<K> key); + + /** + * Gets ID of additional node involved. For example, in DHT case, other node is + * near node ID. + * + * @return Parent node IDs. + */ + @Nullable public UUID otherNodeId(); + + /** + * @return Event node ID. + */ + public UUID eventNodeId(); + + /** + * 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. + * + * @return Originating node ID. + */ + public UUID originatingNodeId(); + + /** + * @return Master node IDs. + */ + public Collection<UUID> masterNodeIds(); + + /** + * @return Near transaction ID. + */ + @Nullable public GridCacheVersion nearXidVersion(); + + /** + * @return Transaction nodes mapping (primary node -> related backup nodes). + */ + @Nullable public Map<UUID, Collection<UUID>> transactionNodes(); + + /** + * @param entry Entry to check. + * @return {@code True} if lock is owned. + * @throws GridCacheEntryRemovedException If entry has been removed. + */ + public boolean ownsLock(GridCacheEntryEx<K, V> entry) throws GridCacheEntryRemovedException; + + /** + * @param entry Entry to check. + * @return {@code True} if lock is owned. + */ + public boolean ownsLockUnsafe(GridCacheEntryEx<K, V> entry); + + /** + * For Partitioned caches, this flag is {@code false} for remote DHT and remote NEAR + * transactions because serializability of transaction is enforced on primary node. All + * other transaction types must enforce it. + * + * @return Enforce serializable flag. + */ + public boolean enforceSerializable(); + + /** + * @return {@code True} if near transaction. + */ + public boolean near(); + + /** + * @return {@code True} if DHT transaction. + */ + public boolean dht(); + + /** + * @return {@code True} if dht colocated transaction. + */ + public boolean colocated(); + + /** + * @return {@code True} if transaction is local, {@code false} if it's remote. + */ + public boolean local(); + + /** + * @return {@code True} if transaction is replicated. + */ + public boolean replicated(); + + /** + * @return Subject ID initiated this transaction. + */ + public UUID subjectId(); + + /** + * Task name hash in case if transaction was initiated within task execution. + * + * @return Task name hash. + */ + public int taskNameHash(); + + /** + * @return {@code True} if transaction is user transaction, which means: + * <ul> + * <li>Explicit</li> + * <li>Local</li> + * <li>Not DHT</li> + * </ul> + */ + public boolean user(); + + /** + * @return {@code True} if transaction is configured with synchronous commit flag. + */ + public boolean syncCommit(); + + /** + * @return {@code True} if transaction is configured with synchronous rollback flag. + */ + public boolean syncRollback(); + + /** + * @param key Key to check. + * @return {@code True} if key is present. + */ + public boolean hasWriteKey(IgniteTxKey<K> key); + + /** + * @return Read set. + */ + public Set<IgniteTxKey<K>> readSet(); + + /** + * @return Write set. + */ + public Set<IgniteTxKey<K>> writeSet(); + + /** + * @return All transaction entries. + */ + public Collection<IgniteTxEntry<K, V>> allEntries(); + + /** + * @return Write entries. + */ + public Collection<IgniteTxEntry<K, V>> writeEntries(); + + /** + * @return Read entries. + */ + public Collection<IgniteTxEntry<K, V>> readEntries(); + + /** + * @return Transaction write map. + */ + public Map<IgniteTxKey<K>, IgniteTxEntry<K, V>> writeMap(); + + /** + * @return Transaction read map. + */ + public Map<IgniteTxKey<K>, IgniteTxEntry<K, V>> readMap(); + + /** + * Gets pessimistic recovery writes, i.e. values that have never been sent to remote nodes with lock requests. + * + * @return Collection of recovery writes. + */ + public Collection<IgniteTxEntry<K, V>> recoveryWrites(); + + /** + * Gets a list of entries that needs to be locked on the next step of prepare stage of + * optimistic transaction. + * + * @return List of tx entries for optimistic locking. + */ + public Collection<IgniteTxEntry<K, V>> optimisticLockEntries(); + + /** + * Seals transaction for updates. + */ + public void seal(); + + /** + * @param key Key for the entry. + * @return Entry for the key (either from write set or read set). + */ + @Nullable public IgniteTxEntry<K, V> entry(IgniteTxKey<K> key); + + /** + * @param ctx Cache context. + * @param failFast Fail-fast flag. + * @param key Key to look up. + * @param filter Filter to check. + * @return Current value for the key within transaction. + * @throws GridCacheFilterFailedException If filter failed and failFast is {@code true}. + */ + @Nullable public GridTuple<V> peek( + GridCacheContext<K, V> ctx, + boolean failFast, + K key, + @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) throws GridCacheFilterFailedException; + + /** + * @return Start version. + */ + public GridCacheVersion startVersion(); + + /** + * @return Transaction version. + */ + public GridCacheVersion xidVersion(); + + /** + * @return Version created at commit time. + */ + public GridCacheVersion commitVersion(); + + /** + * @param commitVer Commit version. + * @return {@code True} if version was set. + */ + public boolean commitVersion(GridCacheVersion commitVer); + + /** + * @return End version (a.k.a. <tt>'tnc'</tt> or <tt>'transaction number counter'</tt>) + * assigned to this transaction at the end of write phase. + */ + public GridCacheVersion endVersion(); + + /** + * Prepare state. + * + * @throws IgniteCheckedException If failed. + */ + public void prepare() throws IgniteCheckedException; + + /** + * Prepare stage. + * + * @return Future for prepare step. + */ + public IgniteInternalFuture<IgniteInternalTx<K, V>> prepareAsync(); + + /** + * @param endVer End version (a.k.a. <tt>'tnc'</tt> or <tt>'transaction number counter'</tt>) + * assigned to this transaction at the end of write phase. + */ + public void endVersion(GridCacheVersion endVer); + + /** + * @return Transaction write version. For all transactions except DHT transactions, will be equal to + * {@link #xidVersion()}. + */ + public GridCacheVersion writeVersion(); + + /** + * Sets write version. + * + * @param ver Write version. + */ + public void writeVersion(GridCacheVersion ver); + + /** + * @return Future for transaction completion. + */ + public IgniteInternalFuture<IgniteInternalTx> finishFuture(); + + /** + * @param state Transaction state. + * @return {@code True} if transition was valid, {@code false} otherwise. + */ + public boolean state(IgniteTxState state); + + /** + * @param invalidate Invalidate flag. + */ + public void invalidate(boolean invalidate); + + /** + * @param sysInvalidate System invalidate flag. + */ + public void systemInvalidate(boolean sysInvalidate); + + /** + * @return System invalidate flag. + */ + public boolean isSystemInvalidate(); + + /** + * Asynchronously rollback this transaction. + * + * @return Rollback future. + */ + public IgniteInternalFuture<IgniteInternalTx> rollbackAsync(); + + /** + * Asynchronously commits this transaction by initiating {@code two-phase-commit} process. + * + * @return Future for commit operation. + */ + public IgniteInternalFuture<IgniteInternalTx> commitAsync(); + + /** + * Callback invoked whenever there is a lock that has been acquired + * by this transaction for any of the participating entries. + * + * @param entry Cache entry. + * @param owner Lock candidate that won ownership of the lock. + * @return {@code True} if transaction cared about notification. + */ + public boolean onOwnerChanged(GridCacheEntryEx<K, V> entry, GridCacheMvccCandidate<K> owner); + + /** + * @return {@code True} if transaction timed out. + */ + public boolean timedOut(); + + /** + * @return {@code True} if transaction had completed successfully or unsuccessfully. + */ + public boolean done(); + + /** + * @return {@code True} for OPTIMISTIC transactions. + */ + public boolean optimistic(); + + /** + * @return {@code True} for PESSIMISTIC transactions. + */ + public boolean pessimistic(); + + /** + * @return {@code True} if read-committed. + */ + public boolean readCommitted(); + + /** + * @return {@code True} if repeatable-read. + */ + public boolean repeatableRead(); + + /** + * @return {@code True} if serializable. + */ + public boolean serializable(); + + /** + * Checks whether given key has been removed within transaction. + * + * @param key Key to check. + * @return {@code True} if key has been removed. + */ + public boolean removed(IgniteTxKey<K> key); + + /** + * Gets allowed remaining time for this transaction. + * + * @return Remaining time. + * @throws org.apache.ignite.internal.transactions.IgniteTxTimeoutCheckedException If transaction timed out. + */ + public long remainingTime() throws IgniteTxTimeoutCheckedException; + + /** + * @return Alternate transaction versions. + */ + public Collection<GridCacheVersion> alternateVersions(); + + /** + * @return {@code True} if transaction needs completed versions for processing. + */ + public boolean needsCompletedVersions(); + + /** + * @param base Base for committed versions. + * @param committed Committed transactions relative to base. + * @param rolledback Rolled back transactions relative to base. + */ + public void completedVersions(GridCacheVersion base, Collection<GridCacheVersion> committed, + Collection<GridCacheVersion> rolledback); + + /** + * @return {@code True} if transaction has at least one internal entry. + */ + public boolean internal(); + + /** + * @return {@code True} if transaction is a one-phase-commit transaction. + */ + public boolean onePhaseCommit(); + + /** + * @return {@code True} if transaction has transform entries. This flag will be only set for local + * transactions. + */ + public boolean hasTransforms(); + + /** + * @return Public API proxy. + */ + public IgniteTxProxy proxy(); +} http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTransactionsImpl.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTransactionsImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTransactionsImpl.java index 7c39317..f817ee9 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTransactionsImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTransactionsImpl.java @@ -92,7 +92,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx { } /** {@inheritDoc} */ - @Override public IgniteTxEx txStartEx( + @Override public IgniteInternalTx txStartEx( GridCacheContext ctx, IgniteTxConcurrency concurrency, IgniteTxIsolation isolation, @@ -112,7 +112,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx { } /** {@inheritDoc} */ - @Override public IgniteTxEx txStartEx( + @Override public IgniteInternalTx txStartEx( GridCacheContext ctx, IgniteTxConcurrency concurrency, IgniteTxIsolation isolation) @@ -130,7 +130,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx { } /** {@inheritDoc} */ - @Override public IgniteTxEx txStartAffinity(GridCacheContext ctx, + @Override public IgniteInternalTx txStartAffinity(GridCacheContext ctx, Object affinityKey, IgniteTxConcurrency concurrency, IgniteTxIsolation isolation, @@ -149,7 +149,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx { } /** {@inheritDoc} */ - @Override public IgniteTxEx txStartPartitionEx(GridCacheContext ctx, + @Override public IgniteInternalTx txStartPartitionEx(GridCacheContext ctx, int partId, IgniteTxConcurrency concurrency, IgniteTxIsolation isolation, @@ -194,7 +194,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx { * @param sys System flag. * @return Transaction. */ - private IgniteTxEx txStart0(IgniteTxConcurrency concurrency, IgniteTxIsolation isolation, + private IgniteInternalTx txStart0(IgniteTxConcurrency concurrency, IgniteTxIsolation isolation, long timeout, int txSize, boolean sys) { TransactionsConfiguration cfg = cctx.gridConfig().getTransactionsConfiguration(); @@ -202,7 +202,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx { throw new IllegalArgumentException("SERIALIZABLE isolation level is disabled (to enable change " + "'txSerializableEnabled' configuration property)"); - IgniteTxEx<K, V> tx = (IgniteTxEx<K, V>)cctx.tm().userTx(); + IgniteInternalTx<K, V> tx = (IgniteInternalTx<K, V>)cctx.tm().userTx(); if (tx != null) throw new IllegalStateException("Failed to start new transaction " + @@ -294,10 +294,10 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx { * @throws IgniteCheckedException In case of error. */ @SuppressWarnings("unchecked") - private IgniteTxEx txStartGroupLock(GridCacheContext ctx, Object grpLockKey, IgniteTxConcurrency concurrency, + private IgniteInternalTx txStartGroupLock(GridCacheContext ctx, Object grpLockKey, IgniteTxConcurrency concurrency, IgniteTxIsolation isolation, boolean partLock, long timeout, int txSize, boolean sys) throws IllegalStateException, IgniteCheckedException { - IgniteTxEx tx = cctx.tm().userTx(); + IgniteInternalTx tx = cctx.tm().userTx(); if (tx != null) throw new IllegalStateException("Failed to start new transaction " + @@ -338,7 +338,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx { /** {@inheritDoc} */ @Nullable @Override public IgniteTx tx() { - IgniteTxEx tx = cctx.tm().userTx(); + IgniteInternalTx tx = cctx.tm().userTx(); return tx != null ? tx.proxy() : null; } http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxAdapter.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxAdapter.java index 48baf09..4de5441 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxAdapter.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxAdapter.java @@ -51,7 +51,7 @@ import static org.apache.ignite.internal.processors.cache.GridCacheOperation.*; * Managed transaction adapter. */ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter - implements IgniteTxEx<K, V>, Externalizable { + implements IgniteInternalTx<K, V>, Externalizable { /** */ private static final long serialVersionUID = 0L; @@ -181,7 +181,7 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter /** */ @GridToStringExclude - private AtomicReference<GridFutureAdapter<IgniteTxEx>> finFut = new AtomicReference<>(); + private AtomicReference<GridFutureAdapter<IgniteInternalTx>> finFut = new AtomicReference<>(); /** Topology version. */ private AtomicLong topVer = new AtomicLong(-1); @@ -940,11 +940,11 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter /** {@inheritDoc} */ @SuppressWarnings("ExternalizableWithoutPublicNoArgConstructor") - @Override public IgniteInternalFuture<IgniteTxEx> finishFuture() { - GridFutureAdapter<IgniteTxEx> fut = finFut.get(); + @Override public IgniteInternalFuture<IgniteInternalTx> finishFuture() { + GridFutureAdapter<IgniteInternalTx> fut = finFut.get(); if (fut == null) { - fut = new GridFutureAdapter<IgniteTxEx>(cctx.kernalContext()) { + fut = new GridFutureAdapter<IgniteInternalTx>(cctx.kernalContext()) { @Override public String toString() { return S.toString(GridFutureAdapter.class, this, "tx", IgniteTxAdapter.this); } @@ -1066,7 +1066,7 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter } if (notify) { - GridFutureAdapter<IgniteTxEx> fut = finFut.get(); + GridFutureAdapter<IgniteInternalTx> fut = finFut.get(); if (fut != null) fut.onDone(this); @@ -1436,7 +1436,7 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter /** * Transaction shadow class to be used for deserialization. */ - private static class TxShadow implements IgniteTxEx { + private static class TxShadow implements IgniteInternalTx { /** */ private static final long serialVersionUID = 0L; @@ -1869,7 +1869,7 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx> prepareAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> prepareAsync() { return null; } @@ -1889,7 +1889,7 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx> finishFuture() { + @Override public IgniteInternalFuture<IgniteInternalTx> finishFuture() { return null; } @@ -1914,12 +1914,12 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx> rollbackAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> rollbackAsync() { return null; } /** {@inheritDoc} */ - @Override public IgniteInternalFuture<IgniteTxEx> commitAsync() { + @Override public IgniteInternalFuture<IgniteInternalTx> commitAsync() { return null; } @@ -2025,7 +2025,7 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter /** {@inheritDoc} */ @Override public boolean equals(Object o) { - return this == o || o instanceof IgniteTxEx && xid.equals(((IgniteTxEx)o).xid()); + return this == o || o instanceof IgniteInternalTx && xid.equals(((IgniteInternalTx)o).xid()); } /** {@inheritDoc} */ http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d89ef5bd/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxEntry.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxEntry.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxEntry.java index 11fd32c..b129a79 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxEntry.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxEntry.java @@ -53,7 +53,7 @@ public class IgniteTxEntry<K, V> implements GridPeerDeployAware, Externalizable, /** Owning transaction. */ @GridToStringExclude - private IgniteTxEx<K, V> tx; + private IgniteInternalTx<K, V> tx; /** Cache key. */ @GridToStringInclude @@ -167,7 +167,7 @@ public class IgniteTxEntry<K, V> implements GridPeerDeployAware, Externalizable, * @param drVer Data center replication version. */ public IgniteTxEntry(GridCacheContext<K, V> ctx, - IgniteTxEx<K, V> tx, + IgniteInternalTx<K, V> tx, GridCacheOperation op, V val, long ttl, @@ -210,7 +210,7 @@ public class IgniteTxEntry<K, V> implements GridPeerDeployAware, Externalizable, * @param drVer Data center replication version. */ public IgniteTxEntry(GridCacheContext<K, V> ctx, - IgniteTxEx<K, V> tx, + IgniteInternalTx<K, V> tx, GridCacheOperation op, V val, EntryProcessor<K, V, ?> entryProcessor,
