ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [48/50] [abbrv] incubator-ignite git commit: # ignite-26
Date Sat, 31 Jan 2015 07:07:13 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/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 e0dcbfa..c88604b 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<IgniteTx>
-    implements GridCacheFuture<IgniteTx> {
+public final class GridDhtTxFinishFuture<K, V> extends GridCompoundIdentityFuture<IgniteTxEx>
+    implements GridCacheFuture<IgniteTxEx> {
     /** */
     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.<IgniteTx>identityReducer(tx));
+        super(cctx.kernalContext(), F.<IgniteTxEx>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<IgniteTx> fut : futures()) {
+            for (IgniteInternalFuture<IgniteTxEx> 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(IgniteTx tx, Throwable err) {
+    @Override public boolean onDone(IgniteTxEx 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<IgniteTx> {
+    private class MiniFuture extends GridFutureAdapter<IgniteTxEx> {
         /** */
         private static final long serialVersionUID = 0L;
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/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 2197ca2..55b63a5 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
@@ -450,7 +450,7 @@ public class GridDhtTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> implements
 
     /** {@inheritDoc} */
     @SuppressWarnings({"ThrowableInstanceNeverThrown"})
-    @Override public IgniteInternalFuture<IgniteTx> commitAsync() {
+    @Override public IgniteInternalFuture<IgniteTxEx> commitAsync() {
         if (log.isDebugEnabled())
             log.debug("Committing dht local tx: " + this);
 
@@ -545,7 +545,7 @@ public class GridDhtTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> implements
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<IgniteTx> rollbackAsync() {
+    @Override public IgniteInternalFuture<IgniteTxEx> rollbackAsync() {
         GridDhtTxPrepareFuture<K, V> prepFut = this.prepFut.get();
 
         final GridDhtTxFinishFuture<K, V> fut = new GridDhtTxFinishFuture<>(cctx, this, /*rollback*/false);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/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 00994f9..cc352f4 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<IgniteTx>
-    implements GridCacheFuture<IgniteTx> {
+public final class GridNearTxFinishFuture<K, V> extends GridCompoundIdentityFuture<IgniteTxEx>
+    implements GridCacheFuture<IgniteTxEx> {
     /** */
     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.<IgniteTx>identityReducer(tx));
+        super(cctx.kernalContext(), F.<IgniteTxEx>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<IgniteTx> fut : futures()) {
+            for (IgniteInternalFuture<IgniteTxEx> 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(IgniteTx tx, Throwable err) {
+    @Override public boolean onDone(IgniteTxEx 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<IgniteTx> fut = cctx.tm().txHandler().finishColocatedLocal(commit, tx);
+                    IgniteInternalFuture<IgniteTxEx> 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<IgniteTx> fut = cctx.tm().txHandler().finish(n.id(), tx, req);
+            IgniteInternalFuture<IgniteTxEx> 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<IgniteTx> {
+    private class MiniFuture extends GridFutureAdapter<IgniteTxEx> {
         /** */
         private static final long serialVersionUID = 0L;
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/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 ac5404b..95f7593 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
@@ -762,7 +762,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> {
 
     /** {@inheritDoc} */
     @SuppressWarnings({"ThrowableInstanceNeverThrown"})
-    @Override public IgniteInternalFuture<IgniteTx> commitAsync() {
+    @Override public IgniteInternalFuture<IgniteTxEx> commitAsync() {
         if (log.isDebugEnabled())
             log.debug("Committing near local tx: " + this);
 
@@ -808,7 +808,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> {
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<IgniteTx> rollbackAsync() {
+    @Override public IgniteInternalFuture<IgniteTxEx> rollbackAsync() {
         if (log.isDebugEnabled())
             log.debug("Rolling back near tx: " + this);
 
@@ -956,7 +956,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> {
      *
      * @return Commit future.
      */
-    public IgniteInternalFuture<IgniteTx> commitAsyncLocal() {
+    public IgniteInternalFuture<IgniteTxEx> commitAsyncLocal() {
         if (log.isDebugEnabled())
             log.debug("Committing colocated tx locally: " + this);
 
@@ -969,9 +969,9 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> {
         // Do not create finish future if there are no remote nodes.
         if (F.isEmpty(dhtMap) && F.isEmpty(nearMap)) {
             if (prep != null)
-                return (IgniteInternalFuture<IgniteTx>)(IgniteInternalFuture)prep;
+                return (IgniteInternalFuture<IgniteTxEx>)(IgniteInternalFuture)prep;
 
-            return new GridFinishedFuture<IgniteTx>(cctx.kernalContext(), this);
+            return new GridFinishedFuture<IgniteTxEx>(cctx.kernalContext(), this);
         }
 
         final GridDhtTxFinishFuture<K, V> fut = new GridDhtTxFinishFuture<>(cctx, this, /*commit*/true);
@@ -1029,7 +1029,7 @@ public class GridNearTxLocal<K, V> extends GridDhtTxLocalAdapter<K, V> {
      *
      * @return Commit future.
      */
-    public IgniteInternalFuture<IgniteTx> rollbackAsyncLocal() {
+    public IgniteInternalFuture<IgniteTxEx> rollbackAsyncLocal() {
         if (log.isDebugEnabled())
             log.debug("Rolling back colocated tx locally: " + this);
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/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 17181d8..e53c98b 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
@@ -146,7 +146,7 @@ class GridLocalTx<K, V> extends IgniteTxLocalAdapter<K, V> {
 
     /** {@inheritDoc} */
     @SuppressWarnings( {"unchecked", "RedundantCast"})
-    @Override public IgniteInternalFuture<IgniteTx> commitAsync() {
+    @Override public IgniteInternalFuture<IgniteTxEx> commitAsync() {
         try {
             prepare();
         }
@@ -177,7 +177,7 @@ class GridLocalTx<K, V> extends IgniteTxLocalAdapter<K, V> {
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteInternalFuture<IgniteTx> rollbackAsync() {
+    @Override public IgniteInternalFuture<IgniteTxEx> rollbackAsync() {
         try {
             state(ROLLING_BACK);
 
@@ -185,7 +185,7 @@ class GridLocalTx<K, V> extends IgniteTxLocalAdapter<K, V> {
 
             state(ROLLED_BACK);
 
-            return new GridFinishedFuture<IgniteTx>(cctx.kernalContext(), this);
+            return new GridFinishedFuture<IgniteTxEx>(cctx.kernalContext(), this);
         }
         catch (IgniteCheckedException e) {
             return new GridFinishedFuture<>(cctx.kernalContext(), e);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/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 de7416e..7c39317 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
@@ -55,7 +55,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx {
             cfg.getDefaultTxTimeout(),
             0,
             false
-        );
+        ).proxy();
     }
 
     /** {@inheritDoc} */
@@ -71,7 +71,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx {
             cfg.getDefaultTxTimeout(),
             0,
             false
-        );
+        ).proxy();
     }
 
     /** {@inheritDoc} */
@@ -88,9 +88,88 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx {
             timeout,
             txSize,
             false
-        );
+        ).proxy();
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteTxEx txStartEx(
+        GridCacheContext ctx,
+        IgniteTxConcurrency concurrency,
+        IgniteTxIsolation isolation,
+        long timeout,
+        int txSize)
+    {
+        A.notNull(concurrency, "concurrency");
+        A.notNull(isolation, "isolation");
+        A.ensure(timeout >= 0, "timeout cannot be negative");
+        A.ensure(txSize >= 0, "transaction size cannot be negative");
+
+        return txStart0(concurrency,
+            isolation,
+            timeout,
+            txSize,
+            ctx.system());
     }
 
+    /** {@inheritDoc} */
+    @Override public IgniteTxEx txStartEx(
+        GridCacheContext ctx,
+        IgniteTxConcurrency concurrency,
+        IgniteTxIsolation isolation)
+    {
+        A.notNull(concurrency, "concurrency");
+        A.notNull(isolation, "isolation");
+
+        TransactionsConfiguration cfg = cctx.gridConfig().getTransactionsConfiguration();
+
+        return txStart0(concurrency,
+            isolation,
+            cfg.getDefaultTxTimeout(),
+            0,
+            ctx.system());
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteTxEx txStartAffinity(GridCacheContext ctx,
+        Object affinityKey,
+        IgniteTxConcurrency concurrency,
+        IgniteTxIsolation isolation,
+        long timeout,
+        int txSize)
+        throws IgniteCheckedException
+    {
+        return txStartGroupLock(ctx,
+            affinityKey,
+            concurrency,
+            isolation,
+            false,
+            timeout,
+            txSize,
+            ctx.system());
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteTxEx txStartPartitionEx(GridCacheContext ctx,
+        int partId,
+        IgniteTxConcurrency concurrency,
+        IgniteTxIsolation isolation,
+        long timeout,
+        int txSize)
+        throws IgniteCheckedException
+    {
+        Object grpLockKey = ctx.affinity().partitionAffinityKey(partId);
+
+        return txStartGroupLock(ctx,
+            grpLockKey,
+            concurrency,
+            isolation,
+            true,
+            timeout,
+            txSize,
+            ctx.system());
+    }
+
+    /** {@inheritDoc} */
     @Override public IgniteTx txStartSystem(IgniteTxConcurrency concurrency, IgniteTxIsolation isolation,
         long timeout, int txSize) {
         A.notNull(concurrency, "concurrency");
@@ -104,7 +183,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx {
             timeout,
             txSize,
             true
-        );
+        ).proxy();
     }
 
     /**
@@ -115,7 +194,7 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx {
      * @param sys System flag.
      * @return Transaction.
      */
-    private IgniteTx txStart0(IgniteTxConcurrency concurrency, IgniteTxIsolation isolation,
+    private IgniteTxEx txStart0(IgniteTxConcurrency concurrency, IgniteTxIsolation isolation,
         long timeout, int txSize, boolean sys) {
         TransactionsConfiguration cfg = cctx.gridConfig().getTransactionsConfiguration();
 
@@ -145,26 +224,36 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx {
 
         assert tx != null;
 
-        // Wrap into proxy.
-        return new IgniteTxProxyImpl<>(tx, cctx, false);
-
+        return tx;
     }
 
     /** {@inheritDoc} */
     @Override public IgniteTx txStartAffinity(String cacheName, Object affinityKey, IgniteTxConcurrency concurrency,
-        IgniteTxIsolation isolation, long timeout, int txSize) throws IllegalStateException, IgniteCheckedException {
+        IgniteTxIsolation isolation, long timeout, int txSize) throws IllegalStateException, IgniteException {
         GridCacheAdapter<Object, Object> cache = cctx.kernalContext().cache().internalCache(cacheName);
 
         if (cache == null)
             throw new IllegalArgumentException("Failed to find cache with given name (cache is not configured): " +
                 cacheName);
 
-        return txStartGroupLock(cache.context(), affinityKey, concurrency, isolation, false, timeout, txSize, false);
+        try {
+            return txStartGroupLock(cache.context(),
+                affinityKey,
+                concurrency,
+                isolation,
+                false,
+                timeout,
+                txSize,
+                false).proxy();
+        }
+        catch (IgniteCheckedException e) {
+            throw U.convertException(e);
+        }
     }
 
     /** {@inheritDoc} */
     @Override public IgniteTx txStartPartition(String cacheName, int partId, IgniteTxConcurrency concurrency,
-        IgniteTxIsolation isolation, long timeout, int txSize) throws IllegalStateException, IgniteCheckedException {
+        IgniteTxIsolation isolation, long timeout, int txSize) throws IllegalStateException, IgniteException {
         GridCacheAdapter<Object, Object> cache = cctx.kernalContext().cache().internalCache(cacheName);
 
         if (cache == null)
@@ -173,12 +262,25 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx {
 
         Object grpLockKey = cache.context().affinity().partitionAffinityKey(partId);
 
-        return txStartGroupLock(cache.context(), grpLockKey, concurrency, isolation, true, timeout, txSize, false);
+        try {
+            return txStartGroupLock(cache.context(),
+                grpLockKey,
+                concurrency,
+                isolation,
+                true,
+                timeout,
+                txSize,
+                false).proxy();
+        }
+        catch (IgniteCheckedException e) {
+            throw U.convertException(e);
+        }
     }
 
     /**
      * Internal method to start group-lock transaction.
      *
+     * @param ctx Cache context.
      * @param grpLockKey Group lock key.
      * @param concurrency Transaction concurrency control.
      * @param isolation Transaction isolation level.
@@ -192,10 +294,10 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx {
      * @throws IgniteCheckedException In case of error.
      */
     @SuppressWarnings("unchecked")
-    private IgniteTx txStartGroupLock(GridCacheContext ctx, Object grpLockKey, IgniteTxConcurrency concurrency,
+    private IgniteTxEx txStartGroupLock(GridCacheContext ctx, Object grpLockKey, IgniteTxConcurrency concurrency,
         IgniteTxIsolation isolation, boolean partLock, long timeout, int txSize, boolean sys)
         throws IllegalStateException, IgniteCheckedException {
-        IgniteTx tx = cctx.tm().userTx();
+        IgniteTxEx tx = cctx.tm().userTx();
 
         if (tx != null)
             throw new IllegalStateException("Failed to start new transaction " +
@@ -231,13 +333,14 @@ public class IgniteTransactionsImpl<K, V> implements IgniteTransactionsEx {
             throw e;
         }
 
-        // Wrap into proxy.
-        return new IgniteTxProxyImpl<>(tx0, cctx, false);
+        return tx0;
     }
 
     /** {@inheritDoc} */
     @Nullable @Override public IgniteTx tx() {
-        return cctx.tm().userTx();
+        IgniteTxEx tx = cctx.tm().userTx();
+
+        return tx != null ? tx.proxy() : null;
     }
 
     /** {@inheritDoc} */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/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 e009b65..6b8c9ed 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
@@ -180,7 +180,7 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter
 
     /** */
     @GridToStringExclude
-    private AtomicReference<GridFutureAdapter<IgniteTx>> finFut = new AtomicReference<>();
+    private AtomicReference<GridFutureAdapter<IgniteTxEx>> finFut = new AtomicReference<>();
 
     /** Topology version. */
     private AtomicLong topVer = new AtomicLong(-1);
@@ -203,6 +203,9 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter
     /** Store used flag. */
     protected boolean storeEnabled = true;
 
+    /** */
+    private IgniteTxProxyImpl proxy;
+
     /**
      * Empty constructor required for {@link Externalizable}.
      */
@@ -547,21 +550,6 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter
         return finalizing.get();
     }
 
-    /** {@inheritDoc} */
-    @Override public IgniteAsyncSupport withAsync() {
-        throw new UnsupportedOperationException("withAsync() should not be called on IgniteTxAdapter directly.");
-    }
-
-    /** {@inheritDoc} */
-    @Override public boolean isAsync() {
-        return false;
-    }
-
-    /** {@inheritDoc} */
-    @Override public <R> IgniteFuture<R> future() {
-        throw new UnsupportedOperationException("future() should not be called on IgniteTxAdapter directly.");
-    }
-
     /**
      * @return {@code True} if transaction has at least one key enlisted.
      */
@@ -950,11 +938,11 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter
 
     /** {@inheritDoc} */
     @SuppressWarnings("ExternalizableWithoutPublicNoArgConstructor")
-    @Override public IgniteInternalFuture<IgniteTx> finishFuture() {
-        GridFutureAdapter<IgniteTx> fut = finFut.get();
+    @Override public IgniteInternalFuture<IgniteTxEx> finishFuture() {
+        GridFutureAdapter<IgniteTxEx> fut = finFut.get();
 
         if (fut == null) {
-            fut = new GridFutureAdapter<IgniteTx>(cctx.kernalContext()) {
+            fut = new GridFutureAdapter<IgniteTxEx>(cctx.kernalContext()) {
                 @Override public String toString() {
                     return S.toString(GridFutureAdapter.class, this, "tx", IgniteTxAdapter.this);
                 }
@@ -1076,7 +1064,7 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter
         }
 
         if (notify) {
-            GridFutureAdapter<IgniteTx> fut = finFut.get();
+            GridFutureAdapter<IgniteTxEx> fut = finFut.get();
 
             if (fut != null)
                 fut.onDone(this);
@@ -1419,6 +1407,14 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter
     }
 
     /** {@inheritDoc} */
+    @Override public IgniteTxProxy proxy() {
+        if (proxy == null)
+            proxy = new IgniteTxProxyImpl(this, cctx, false);
+
+        return proxy;
+    }
+
+    /** {@inheritDoc} */
     @Override public boolean equals(Object o) {
         return o == this || (o instanceof IgniteTxAdapter && xidVer.equals(((IgniteTxAdapter)o).xidVer));
     }
@@ -1438,7 +1434,7 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter
     /**
      * Transaction shadow class to be used for deserialization.
      */
-    private static class TxShadow extends GridMetadataAwareAdapter implements IgniteTx {
+    private static class TxShadow implements IgniteTxEx {
         /** */
         private static final long serialVersionUID = 0L;
 
@@ -1560,48 +1556,474 @@ public abstract class IgniteTxAdapter<K, V> extends GridMetadataAwareAdapter
         }
 
         /** {@inheritDoc} */
-        @Override public IgniteAsyncSupport withAsync() {
+        @Override public long timeout(long timeout) {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean setRollbackOnly() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public void commit() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public void close() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public void rollback() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<Integer> activeCacheIds() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public Object addMeta(String name, Object val) {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public Object removeMeta(String name) {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public Object meta(String name) {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public int size() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean storeEnabled() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean storeUsed() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean system() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public long topologyVersion() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean implicitSingle() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public long topologyVersion(long topVer) {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean empty() {
             throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
         }
 
         /** {@inheritDoc} */
-        @Override public boolean isAsync() {
+        @Override public boolean groupLock() {
             return false;
         }
 
         /** {@inheritDoc} */
-        @Override public <R> IgniteFuture<R> future() {
+        @Nullable @Override public IgniteTxKey groupLockKey() {
             throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
         }
 
         /** {@inheritDoc} */
-        @Override public long timeout(long timeout) {
+        @Override public boolean markPreparing() {
             throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
         }
 
         /** {@inheritDoc} */
-        @Override public boolean setRollbackOnly() {
+        @Override public boolean markFinalizing(FinalizationStatus status) {
             throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
         }
 
         /** {@inheritDoc} */
-        @Override public void commit() {
+        @Override public void addInvalidPartition(GridCacheContext cacheCtx, int part) {
             throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
         }
 
         /** {@inheritDoc} */
-        @Override public void close() {
+        @Override public Set<Integer> invalidPartitions() {
             throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
         }
 
         /** {@inheritDoc} */
-        @Override public void rollback() {
+        @Nullable @Override public GridCacheVersion ownedVersion(IgniteTxKey key) {
             throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
         }
 
         /** {@inheritDoc} */
+        @Nullable @Override public UUID otherNodeId() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public UUID eventNodeId() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public UUID originatingNodeId() {
+            throw new IllegalStateException("Deserialized transaction can only be used as read-only.");
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<UUID> masterNodeIds() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public GridCacheVersion nearXidVersion() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public Map<UUID, Collection<UUID>> transactionNodes() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean ownsLock(GridCacheEntryEx entry) throws GridCacheEntryRemovedException {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean ownsLockUnsafe(GridCacheEntryEx entry) {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean enforceSerializable() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean near() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean dht() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean colocated() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean local() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean replicated() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public UUID subjectId() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int taskNameHash() {
+            return 0;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean user() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean syncCommit() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean syncRollback() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean hasWriteKey(IgniteTxKey key) {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Set<IgniteTxKey> readSet() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Set<IgniteTxKey> writeSet() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<IgniteTxEntry> allEntries() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<IgniteTxEntry> writeEntries() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<IgniteTxEntry> readEntries() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Map<IgniteTxKey, IgniteTxEntry> writeMap() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Map<IgniteTxKey, IgniteTxEntry> readMap() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<IgniteTxEntry> recoveryWrites() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<IgniteTxEntry> optimisticLockEntries() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void seal() {
+
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public IgniteTxEntry entry(IgniteTxKey key) {
+            return null;
+        }
+
+        @Nullable
+        @Override
+        public GridTuple peek(GridCacheContext ctx, boolean failFast, Object key, @Nullable IgnitePredicate[] filter) throws GridCacheFilterFailedException {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public GridCacheVersion startVersion() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public GridCacheVersion xidVersion() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public GridCacheVersion commitVersion() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean commitVersion(GridCacheVersion commitVer) {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public GridCacheVersion endVersion() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void prepare() throws IgniteCheckedException {
+
+        }
+
+        /** {@inheritDoc} */
+        @Override public IgniteInternalFuture<IgniteTxEx> prepareAsync() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void endVersion(GridCacheVersion endVer) {
+
+        }
+
+        /** {@inheritDoc} */
+        @Override public GridCacheVersion writeVersion() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void writeVersion(GridCacheVersion ver) {
+
+        }
+
+        /** {@inheritDoc} */
+        @Override public IgniteInternalFuture<IgniteTxEx> finishFuture() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean state(IgniteTxState state) {
+            return false;
+        }
+
+        @Override
+        public void invalidate(boolean invalidate) {
+
+        }
+
+        /** {@inheritDoc} */
+        @Override public void systemInvalidate(boolean sysInvalidate) {
+
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isSystemInvalidate() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public IgniteInternalFuture<IgniteTxEx> rollbackAsync() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public IgniteInternalFuture<IgniteTxEx> commitAsync() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean onOwnerChanged(GridCacheEntryEx entry, GridCacheMvccCandidate owner) {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean timedOut() {
+            return false;
+        }
+
+        @Override
+        public boolean done() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean optimistic() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean pessimistic() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean readCommitted() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean repeatableRead() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean serializable() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean removed(IgniteTxKey key) {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long remainingTime() throws IgniteTxTimeoutException {
+            return 0;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<GridCacheVersion> alternateVersions() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean needsCompletedVersions() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void completedVersions(GridCacheVersion base, Collection committed, Collection rolledback) {
+
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean internal() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean onePhaseCommit() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean hasTransforms() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public IgniteTxProxy proxy() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public IgniteUuid timeoutId() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long endTime() {
+            return 0;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void onTimeout() {
+
+        }
+
+        /** {@inheritDoc} */
         @Override public boolean equals(Object o) {
-            return this == o || o instanceof IgniteTx && xid.equals(((IgniteTx)o).xid());
+            return this == o || o instanceof IgniteTxEx && xid.equals(((IgniteTxEx)o).xid());
         }
 
         /** {@inheritDoc} */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxEx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxEx.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxEx.java
index 63e4786..1bddf07 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxEx.java
@@ -33,7 +33,7 @@ import java.util.*;
 /**
  * Transaction managed by cache ({@code 'Ex'} stands for external).
  */
-public interface IgniteTxEx<K, V> extends IgniteTx, GridTimeoutObject {
+public interface IgniteTxEx<K, V> extends AutoCloseable, GridTimeoutObject {
     /**
      *
      */
@@ -53,6 +53,165 @@ public interface IgniteTxEx<K, V> extends IgniteTx, GridTimeoutObject {
     }
 
     /**
+     * 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 IgniteTxTimeoutException} 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();
@@ -407,7 +566,7 @@ public interface IgniteTxEx<K, V> extends IgniteTx, GridTimeoutObject {
     /**
      * @return Future for transaction completion.
      */
-    public IgniteInternalFuture<IgniteTx> finishFuture();
+    public IgniteInternalFuture<IgniteTxEx> finishFuture();
 
     /**
      * @param state Transaction state.
@@ -435,14 +594,14 @@ public interface IgniteTxEx<K, V> extends IgniteTx, GridTimeoutObject {
      *
      * @return Rollback future.
      */
-    public IgniteInternalFuture<IgniteTx> rollbackAsync();
+    public IgniteInternalFuture<IgniteTxEx> rollbackAsync();
 
     /**
      * Asynchronously commits this transaction by initiating {@code two-phase-commit} process.
      *
      * @return Future for commit operation.
      */
-    public IgniteInternalFuture<IgniteTx> commitAsync();
+    public IgniteInternalFuture<IgniteTxEx> commitAsync();
 
     /**
      * Callback invoked whenever there is a lock that has been acquired
@@ -538,4 +697,9 @@ public interface IgniteTxEx<K, V> extends IgniteTx, GridTimeoutObject {
      *      transactions.
      */
     public boolean hasTransforms();
+
+    /**
+     * @return Public API proxy.
+     */
+    public IgniteTxProxy proxy();
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxHandler.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxHandler.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxHandler.java
index 2bc62ec..07b8839 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxHandler.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxHandler.java
@@ -345,7 +345,7 @@ public class IgniteTxHandler<K, V> {
     private void processNearTxFinishResponse(UUID nodeId, GridNearTxFinishResponse<K, V> res) {
         ctx.tm().onFinishedRemote(nodeId, res.threadId());
 
-        GridNearTxFinishFuture<K, V> fut = (GridNearTxFinishFuture<K, V>)ctx.mvcc().<IgniteTx>future(
+        GridNearTxFinishFuture<K, V> fut = (GridNearTxFinishFuture<K, V>)ctx.mvcc().<IgniteTxEx>future(
             res.xid(), res.futureId());
 
         if (fut == null) {
@@ -384,7 +384,7 @@ public class IgniteTxHandler<K, V> {
         assert nodeId != null;
         assert res != null;
 
-        GridDhtTxFinishFuture<K, V> fut = (GridDhtTxFinishFuture<K, V>)ctx.mvcc().<IgniteTx>future(res.xid(),
+        GridDhtTxFinishFuture<K, V> fut = (GridDhtTxFinishFuture<K, V>)ctx.mvcc().<IgniteTxEx>future(res.xid(),
             res.futureId());
 
         if (fut == null) {
@@ -402,7 +402,7 @@ public class IgniteTxHandler<K, V> {
      * @param req Request.
      * @return Future.
      */
-    @Nullable public IgniteInternalFuture<IgniteTx> processNearTxFinishRequest(UUID nodeId, GridNearTxFinishRequest<K, V> req) {
+    @Nullable public IgniteInternalFuture<IgniteTxEx> processNearTxFinishRequest(UUID nodeId, GridNearTxFinishRequest<K, V> req) {
         return finish(nodeId, null, req);
     }
 
@@ -411,24 +411,24 @@ public class IgniteTxHandler<K, V> {
      * @param req Request.
      * @return Future.
      */
-    @Nullable public IgniteInternalFuture<IgniteTx> finish(UUID nodeId, @Nullable GridNearTxLocal<K, V> locTx,
+    @Nullable public IgniteInternalFuture<IgniteTxEx> finish(UUID nodeId, @Nullable GridNearTxLocal<K, V> locTx,
         GridNearTxFinishRequest<K, V> req) {
         assert nodeId != null;
         assert req != null;
 
         // Transaction on local cache only.
         if (locTx != null && !locTx.nearLocallyMapped() && !locTx.colocatedLocallyMapped())
-            return new GridFinishedFutureEx<IgniteTx>(locTx);
+            return new GridFinishedFutureEx<IgniteTxEx>(locTx);
 
         if (log.isDebugEnabled())
             log.debug("Processing near tx finish request [nodeId=" + nodeId + ", req=" + req + "]");
 
-        IgniteInternalFuture<IgniteTx> colocatedFinishFut = null;
+        IgniteInternalFuture<IgniteTxEx> colocatedFinishFut = null;
 
         if (locTx != null && locTx.colocatedLocallyMapped())
             colocatedFinishFut = finishColocatedLocal(req.commit(), locTx);
 
-        IgniteInternalFuture<IgniteTx> nearFinishFut = null;
+        IgniteInternalFuture<IgniteTxEx> nearFinishFut = null;
 
         if (locTx == null || locTx.nearLocallyMapped()) {
             if (locTx != null)
@@ -438,7 +438,7 @@ public class IgniteTxHandler<K, V> {
         }
 
         if (colocatedFinishFut != null && nearFinishFut != null) {
-            GridCompoundFuture<IgniteTx, IgniteTx> res = new GridCompoundFuture<>(ctx.kernalContext());
+            GridCompoundFuture<IgniteTxEx, IgniteTxEx> res = new GridCompoundFuture<>(ctx.kernalContext());
 
             res.add(colocatedFinishFut);
             res.add(nearFinishFut);
@@ -460,7 +460,7 @@ public class IgniteTxHandler<K, V> {
      * @param req Finish request.
      * @return Finish future.
      */
-    private IgniteInternalFuture<IgniteTx> finishDhtLocal(UUID nodeId, @Nullable GridNearTxLocal<K, V> locTx,
+    private IgniteInternalFuture<IgniteTxEx> finishDhtLocal(UUID nodeId, @Nullable GridNearTxLocal<K, V> locTx,
         GridNearTxFinishRequest<K, V> req) {
         GridCacheVersion dhtVer = ctx.tm().mappedVersion(req.version());
 
@@ -564,7 +564,7 @@ public class IgniteTxHandler<K, V> {
                 if (tx.pessimistic())
                     tx.prepare();
 
-                IgniteInternalFuture<IgniteTx> commitFut = tx.commitAsync();
+                IgniteInternalFuture<IgniteTxEx> commitFut = tx.commitAsync();
 
                 // Only for error logging.
                 commitFut.listenAsync(CU.errorLogger(log));
@@ -580,7 +580,7 @@ public class IgniteTxHandler<K, V> {
                 tx.nearFinishFutureId(req.futureId());
                 tx.nearFinishMiniId(req.miniId());
 
-                IgniteInternalFuture<IgniteTx> rollbackFut = tx.rollbackAsync();
+                IgniteInternalFuture<IgniteTxEx> rollbackFut = tx.rollbackAsync();
 
                 // Only for error logging.
                 rollbackFut.listenAsync(CU.errorLogger(log));
@@ -592,7 +592,7 @@ public class IgniteTxHandler<K, V> {
             U.error(log, "Failed completing transaction [commit=" + req.commit() + ", tx=" + tx + ']', e);
 
             if (tx != null) {
-                IgniteInternalFuture<IgniteTx> rollbackFut = tx.rollbackAsync();
+                IgniteInternalFuture<IgniteTxEx> rollbackFut = tx.rollbackAsync();
 
                 // Only for error logging.
                 rollbackFut.listenAsync(CU.errorLogger(log));
@@ -609,7 +609,7 @@ public class IgniteTxHandler<K, V> {
      * @param tx Transaction to commit.
      * @return Future.
      */
-    public IgniteInternalFuture<IgniteTx> finishColocatedLocal(boolean commit, GridNearTxLocal<K, V> tx) {
+    public IgniteInternalFuture<IgniteTxEx> finishColocatedLocal(boolean commit, GridNearTxLocal<K, V> tx) {
         try {
             if (commit) {
                 if (!tx.markFinalizing(USER_FINISH)) {

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxLocalAdapter.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxLocalAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxLocalAdapter.java
index 0145875..338a9d1 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxLocalAdapter.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxLocalAdapter.java
@@ -3420,8 +3420,8 @@ public abstract class IgniteTxLocalAdapter<K, V> extends IgniteTxAdapter<K, V>
                 setRollbackOnly();
 
                 if (commit && commitAfterLock())
-                    return rollbackAsync().chain(new C1<IgniteInternalFuture<IgniteTx>, T>() {
-                        @Override public T apply(IgniteInternalFuture<IgniteTx> f) {
+                    return rollbackAsync().chain(new C1<IgniteInternalFuture<IgniteTxEx>, T>() {
+                        @Override public T apply(IgniteInternalFuture<IgniteTxEx> f) {
                             throw new GridClosureException(e);
                         }
                     });
@@ -3437,8 +3437,8 @@ public abstract class IgniteTxLocalAdapter<K, V> extends IgniteTxAdapter<K, V>
                     ", tx=" + this + ']'));
 
                 if (commit && commitAfterLock())
-                    return rollbackAsync().chain(new C1<IgniteInternalFuture<IgniteTx>, T>() {
-                        @Override public T apply(IgniteInternalFuture<IgniteTx> f) {
+                    return rollbackAsync().chain(new C1<IgniteInternalFuture<IgniteTxEx>, T>() {
+                        @Override public T apply(IgniteInternalFuture<IgniteTxEx> f) {
                             throw ex;
                         }
                     });
@@ -3455,8 +3455,8 @@ public abstract class IgniteTxLocalAdapter<K, V> extends IgniteTxAdapter<K, V>
                 if (commit && commitAfterLock()) {
                     rollback = false;
 
-                    return commitAsync().chain(new CX1<IgniteInternalFuture<IgniteTx>, T>() {
-                        @Override public T applyx(IgniteInternalFuture<IgniteTx> f) throws IgniteCheckedException {
+                    return commitAsync().chain(new CX1<IgniteInternalFuture<IgniteTxEx>, T>() {
+                        @Override public T applyx(IgniteInternalFuture<IgniteTxEx> f) throws IgniteCheckedException {
                             f.get();
 
                             return r;
@@ -3470,8 +3470,8 @@ public abstract class IgniteTxLocalAdapter<K, V> extends IgniteTxAdapter<K, V>
             }
             catch (final IgniteCheckedException ex) {
                 if (commit && commitAfterLock())
-                    return rollbackAsync().chain(new C1<IgniteInternalFuture<IgniteTx>, T>() {
-                        @Override public T apply(IgniteInternalFuture<IgniteTx> f) {
+                    return rollbackAsync().chain(new C1<IgniteInternalFuture<IgniteTxEx>, T>() {
+                        @Override public T apply(IgniteInternalFuture<IgniteTxEx> f) {
                             throw new GridClosureException(ex);
                         }
                     });

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxManager.java
index 9cbd479..dc2183f 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxManager.java
@@ -516,10 +516,10 @@ public class IgniteTxManager<K, V> extends GridCacheSharedManagerAdapter<K, V> {
      * @return Future that will be completed when all ongoing transactions are finished.
      */
     public IgniteInternalFuture<Boolean> finishTxs(long topVer) {
-        GridCompoundFuture<IgniteTx, Boolean> res =
+        GridCompoundFuture<IgniteTxEx, Boolean> res =
             new GridCompoundFuture<>(context().kernalContext(),
-                new IgniteReducer<IgniteTx, Boolean>() {
-                    @Override public boolean collect(IgniteTx e) {
+                new IgniteReducer<IgniteTxEx, Boolean>() {
+                    @Override public boolean collect(IgniteTxEx e) {
                         return true;
                     }
 
@@ -671,7 +671,7 @@ public class IgniteTxManager<K, V> extends GridCacheSharedManagerAdapter<K, V> {
     /**
      * @return User transaction for current thread.
      */
-    @Nullable public IgniteTx userTx() {
+    @Nullable public IgniteTxEx userTx() {
         IgniteTxEx<K, V> tx = txContext();
 
         if (tx != null && tx.user() && tx.state() == ACTIVE)
@@ -1692,10 +1692,10 @@ public class IgniteTxManager<K, V> extends GridCacheSharedManagerAdapter<K, V> {
      * @param newState New state.
      * @param tx Cache transaction.
      */
-    public void onTxStateChange(@Nullable IgniteTxState prevState, IgniteTxState newState, IgniteTx tx) {
+    public void onTxStateChange(@Nullable IgniteTxState prevState, IgniteTxState newState, IgniteTxEx tx) {
         // Notify synchronizations.
         for (IgniteTxSynchronization s : syncs)
-            s.onStateChanged(prevState, newState, tx);
+            s.onStateChanged(prevState, newState, tx.proxy());
     }
 
     /**
@@ -1993,8 +1993,8 @@ public class IgniteTxManager<K, V> extends GridCacheSharedManagerAdapter<K, V> {
 
             final IgniteTxEx<K, V> tx0 = tx;
 
-            return tx.finishFuture().chain(new C1<IgniteInternalFuture<IgniteTx>, GridCacheCommittedTxInfo<K, V>>() {
-                @Override public GridCacheCommittedTxInfo<K, V> apply(IgniteInternalFuture<IgniteTx> txFut) {
+            return tx.finishFuture().chain(new C1<IgniteInternalFuture<IgniteTxEx>, GridCacheCommittedTxInfo<K, V>>() {
+                @Override public GridCacheCommittedTxInfo<K, V> apply(IgniteInternalFuture<IgniteTxEx> txFut) {
                     GridCacheCommittedTxInfo<K, V> info = null;
 
                     if (tx0.state() == COMMITTED)
@@ -2190,7 +2190,7 @@ public class IgniteTxManager<K, V> extends GridCacheSharedManagerAdapter<K, V> {
     /**
      * Commit listener. Checks if commit succeeded and rollbacks if case of error.
      */
-    private class CommitListener implements CI1<IgniteInternalFuture<IgniteTx>> {
+    private class CommitListener implements CI1<IgniteInternalFuture<IgniteTxEx>> {
         /** */
         private static final long serialVersionUID = 0L;
 
@@ -2205,7 +2205,7 @@ public class IgniteTxManager<K, V> extends GridCacheSharedManagerAdapter<K, V> {
         }
 
         /** {@inheritDoc} */
-        @Override public void apply(IgniteInternalFuture<IgniteTx> t) {
+        @Override public void apply(IgniteInternalFuture<IgniteTxEx> t) {
             try {
                 t.get();
             }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxProxyImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxProxyImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxProxyImpl.java
index 8167f7b..64c7e02 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxProxyImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/transactions/IgniteTxProxyImpl.java
@@ -229,36 +229,42 @@ public class IgniteTxProxyImpl<K, V> implements IgniteTxProxy, Externalizable {
     }
 
     /** {@inheritDoc} */
-    @Override public void commit() throws IgniteCheckedException {
+    @Override public void commit() {
         enter();
 
         try {
-            IgniteInternalFuture<IgniteTx> commitFut = cctx.commitTxAsync(tx);
+            IgniteInternalFuture<IgniteTxEx> commitFut = cctx.commitTxAsync(tx);
 
             if (async)
                 asyncRes = new IgniteFutureImpl(commitFut);
             else
                 commitFut.get();
         }
+        catch (IgniteCheckedException e) {
+            throw U.convertException(e);
+        }
         finally {
             leave();
         }
     }
 
     /** {@inheritDoc} */
-    @Override public void close() throws IgniteCheckedException {
+    @Override public void close() {
         enter();
 
         try {
             cctx.endTx(tx);
         }
+        catch (IgniteCheckedException e) {
+            throw U.convertException(e);
+        }
         finally {
             leave();
         }
     }
 
     /** {@inheritDoc} */
-    @Override public void rollback() throws IgniteCheckedException {
+    @Override public void rollback() {
         enter();
 
         try {
@@ -269,6 +275,9 @@ public class IgniteTxProxyImpl<K, V> implements IgniteTxProxy, Externalizable {
             else
                 rollbackFut.get();
         }
+        catch (IgniteCheckedException e) {
+            throw U.convertException(e);
+        }
         finally {
             leave();
         }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsDataManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsDataManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsDataManager.java
index 1d9098a..ef8bf97 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsDataManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsDataManager.java
@@ -26,6 +26,7 @@ import org.apache.ignite.fs.*;
 import org.apache.ignite.internal.*;
 import org.apache.ignite.internal.cluster.*;
 import org.apache.ignite.internal.processors.cache.*;
+import org.apache.ignite.internal.processors.cache.transactions.*;
 import org.apache.ignite.internal.util.*;
 import org.apache.ignite.lang.*;
 import org.apache.ignite.thread.*;
@@ -686,7 +687,7 @@ public class GridGgfsDataManager extends GridGgfsManager {
                         // Need to check if block is partially written.
                         // If so, must update it in pessimistic transaction.
                         if (block.length != fileInfo.blockSize()) {
-                            try (IgniteTx tx = dataCachePrj.txStart(PESSIMISTIC, REPEATABLE_READ)) {
+                            try (IgniteTxEx tx = dataCachePrj.txStartEx(PESSIMISTIC, REPEATABLE_READ)) {
                                 Map<GridGgfsBlockKey, byte[]> vals = dataCachePrj.getAll(F.asList(colocatedKey, key));
 
                                 byte[] val = vals.get(colocatedKey);
@@ -1129,7 +1130,7 @@ public class GridGgfsDataManager extends GridGgfsManager {
         GridGgfsBlockKey key = new GridGgfsBlockKey(colocatedKey.getFileId(), null,
             colocatedKey.evictExclude(), colocatedKey.getBlockId());
 
-        try (IgniteTx tx = dataCachePrj.txStart(PESSIMISTIC, REPEATABLE_READ)) {
+        try (IgniteTxEx tx = dataCachePrj.txStartEx(PESSIMISTIC, REPEATABLE_READ)) {
             // Lock keys.
             Map<GridGgfsBlockKey, byte[]> vals = dataCachePrj.getAll(F.asList(colocatedKey, key));
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsMetaManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsMetaManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsMetaManager.java
index 1f1407e..b640703 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsMetaManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsMetaManager.java
@@ -24,6 +24,7 @@ import org.apache.ignite.events.*;
 import org.apache.ignite.fs.*;
 import org.apache.ignite.internal.*;
 import org.apache.ignite.internal.processors.cache.*;
+import org.apache.ignite.internal.processors.cache.transactions.*;
 import org.apache.ignite.internal.util.*;
 import org.apache.ignite.lang.*;
 import org.apache.ignite.transactions.*;
@@ -408,7 +409,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
                 assert validTxState(false);
                 assert fileId != null;
 
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     // Lock file ID for this transaction.
@@ -491,7 +492,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
 
                 IgniteUuid fileId = info.id();
 
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     // Lock file ID for this transaction.
@@ -692,7 +693,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
 
                 IgniteUuid res = null;
 
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     res = putIfAbsentNonTx(parentId, fileName, newFileInfo);
@@ -781,7 +782,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
             try {
                 assert validTxState(false);
 
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     moveNonTx(fileId, srcFileName, srcParentId, destFileName, destParentId);
@@ -901,7 +902,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
             try {
                 assert validTxState(false);
 
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     if (parentId != null)
@@ -1015,7 +1016,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
             try {
                 assert validTxState(false);
 
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     if (parentId == null)
@@ -1136,7 +1137,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
                 assert listing != null;
                 assert validTxState(false);
 
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     Collection<IgniteUuid> res = new HashSet<>();
@@ -1221,7 +1222,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
             try {
                 assert validTxState(false);
 
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     boolean res = false;
@@ -1394,7 +1395,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
             try {
                 assert validTxState(false);
 
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     GridGgfsFileInfo info = updatePropertiesNonTx(parentId, fileId, fileName, props);
@@ -1464,7 +1465,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
                 if (log.isDebugEnabled())
                     log.debug("Update file info [fileId=" + fileId + ", c=" + c + ']');
 
-                IgniteTx tx = metaCache.isLockedByThread(fileId) ? null : metaCache.txStart(PESSIMISTIC,
+                IgniteTxEx tx = metaCache.isLockedByThread(fileId) ? null : metaCache.txStartEx(PESSIMISTIC,
                     REPEATABLE_READ);
 
                 try {
@@ -1527,7 +1528,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
             try {
                 validTxState(false);
 
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     Object prev = val != null ? metaCache.put(sampling, val) : metaCache.remove(sampling);
@@ -2361,7 +2362,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
                 pathIds.add(fileIds(path));
 
             // Start pessimistic.
-            IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+            IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
             try {
                 // Lock the very first existing parents and possibly the leaf as well.
@@ -2583,7 +2584,7 @@ public class GridGgfsMetaManager extends GridGgfsManager {
                 assert validTxState(false);
 
                 // Start pessimistic transaction.
-                IgniteTx tx = metaCache.txStart(PESSIMISTIC, REPEATABLE_READ);
+                IgniteTxEx tx = metaCache.txStartEx(PESSIMISTIC, REPEATABLE_READ);
 
                 try {
                     Map<IgniteUuid, GridGgfsFileInfo> infoMap = lockIds(fileId, parentId);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
index 853f5d6..cabbc29 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java
@@ -23,6 +23,7 @@ import org.apache.ignite.cache.datastructures.*;
 import org.apache.ignite.cluster.*;
 import org.apache.ignite.internal.*;
 import org.apache.ignite.internal.processors.cache.*;
+import org.apache.ignite.internal.processors.cache.transactions.*;
 import org.apache.ignite.lang.*;
 import org.apache.ignite.resources.*;
 import org.apache.ignite.transactions.*;
@@ -468,7 +469,7 @@ public class GridCacheCommandHandler extends GridRestCommandHandlerAdapter {
 
         return ctx.closure().callLocalSafe(new Callable<Object>() {
             @Override public Object call() throws Exception {
-                try (IgniteTx tx = cache.txStart(PESSIMISTIC, REPEATABLE_READ)) {
+                try (IgniteTxEx tx = cache.txStartEx(PESSIMISTIC, REPEATABLE_READ)) {
                     Object curVal = cache.get(key);
 
                     if (curVal == null)

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/main/java/org/apache/ignite/internal/processors/service/GridServiceProcessor.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/service/GridServiceProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/service/GridServiceProcessor.java
index e959ef3..dbada06 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/service/GridServiceProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/service/GridServiceProcessor.java
@@ -26,6 +26,7 @@ import org.apache.ignite.internal.*;
 import org.apache.ignite.internal.cluster.*;
 import org.apache.ignite.internal.processors.*;
 import org.apache.ignite.internal.processors.cache.*;
+import org.apache.ignite.internal.processors.cache.transactions.*;
 import org.apache.ignite.internal.util.*;
 import org.apache.ignite.lang.*;
 import org.apache.ignite.managed.*;
@@ -628,7 +629,7 @@ public class GridServiceProcessor extends GridProcessorAdapter {
         Object affKey = cfg.getAffinityKey();
 
         while (true) {
-            try (IgniteTx tx = cache.txStart(PESSIMISTIC, REPEATABLE_READ)) {
+            try (IgniteTxEx tx = cache.txStartEx(PESSIMISTIC, REPEATABLE_READ)) {
                 GridServiceAssignmentsKey key = new GridServiceAssignmentsKey(cfg.getName());
 
                 GridServiceAssignments oldAssigns = (GridServiceAssignments)cache.get(key);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java b/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
index af96a00..16b4826 100644
--- a/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
+++ b/modules/core/src/main/java/org/apache/ignite/transactions/IgniteTx.java
@@ -226,25 +226,25 @@ public interface IgniteTx extends AutoCloseable, IgniteAsyncSupport {
     /**
      * Commits this transaction by initiating {@code two-phase-commit} process.
      *
-     * @throws IgniteCheckedException If commit failed.
+     * @throws IgniteException If commit failed.
      */
     @IgniteAsyncSupported
-    public void commit() throws IgniteCheckedException;
+    public void commit() throws IgniteException;
 
     /**
      * Ends the transaction. Transaction will be rolled back if it has not been committed.
      *
-     * @throws IgniteCheckedException If transaction could not be gracefully ended.
+     * @throws IgniteException If transaction could not be gracefully ended.
      */
-    @Override public void close() throws IgniteCheckedException;
+    @Override public void close() throws IgniteException;
 
     /**
      * Rolls back this transaction.
      *
-     * @throws IgniteCheckedException If rollback failed.
+     * @throws IgniteException If rollback failed.
      */
     @IgniteAsyncSupported
-    public void rollback() throws IgniteCheckedException;
+    public void rollback() throws IgniteException;
 
     /**
      * Removes metadata by name.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/test/java/org/apache/ignite/internal/IgniteExecutorServiceTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/IgniteExecutorServiceTest.java b/modules/core/src/test/java/org/apache/ignite/internal/IgniteExecutorServiceTest.java
index d76fe95..ee1a0eb 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/IgniteExecutorServiceTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/IgniteExecutorServiceTest.java
@@ -265,7 +265,7 @@ public class IgniteExecutorServiceTest extends GridCommonAbstractTest {
     private ExecutorService createExecutorService(Ignite ignite) {
         assert ignite != null;
 
-        return new GridExecutorService((ClusterGroupAdapter) ignite, log());
+        return ignite.executorService();
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheNestedTxAbstractTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheNestedTxAbstractTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheNestedTxAbstractTest.java
index 53c5e93..4e11eab 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheNestedTxAbstractTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheNestedTxAbstractTest.java
@@ -159,7 +159,7 @@ public class GridCacheNestedTxAbstractTest extends GridCommonAbstractTest {
 
                         tx.commit();
                     }
-                    catch (IgniteCheckedException e) {
+                    catch (IgniteException e) {
                         error("Failed tx thread", e);
                     }
                 }
@@ -252,7 +252,7 @@ public class GridCacheNestedTxAbstractTest extends GridCommonAbstractTest {
 
                             tx.commit();
                         }
-                        catch (IgniteCheckedException e) {
+                        catch (IgniteException e) {
                             error("Failed tx thread", e);
                         }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteTxAbstractTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteTxAbstractTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteTxAbstractTest.java
index 00d0ccf..a71dc54 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteTxAbstractTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteTxAbstractTest.java
@@ -249,7 +249,7 @@ abstract class IgniteTxAbstractTest extends GridCommonAbstractTest {
                 try {
                     tx.rollback();
                 }
-                catch (IgniteCheckedException ex) {
+                catch (IgniteException ex) {
                     error("Failed to rollback optimistic failure: " + tx, ex);
 
                     throw ex;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearMultiGetSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearMultiGetSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearMultiGetSelfTest.java
index 08f9339..ddbb970 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearMultiGetSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearMultiGetSelfTest.java
@@ -278,7 +278,7 @@ public class GridCacheNearMultiGetSelfTest extends GridCommonAbstractTest {
             try {
                 tx.rollback();
             }
-            catch (IgniteCheckedException ex) {
+            catch (IgniteException ex) {
                 error("Failed to rollback optimistic failure: " + tx, ex);
 
                 throw ex;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/GridAbstractCacheStoreSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/GridAbstractCacheStoreSelfTest.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/GridAbstractCacheStoreSelfTest.java
index 0df84cd..a02b23a 100644
--- a/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/GridAbstractCacheStoreSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/GridAbstractCacheStoreSelfTest.java
@@ -532,12 +532,12 @@ public abstract class GridAbstractCacheStoreSelfTest<T extends CacheStore<Object
         }
 
         /** {@inheritDoc} */
-        @Override public void commit() throws IgniteCheckedException {
+        @Override public void commit() {
             // No-op.
         }
 
         /** {@inheritDoc} */
-        @Override public void close() throws IgniteCheckedException {
+        @Override public void close() {
             // No-op.
         }
 
@@ -557,7 +557,7 @@ public abstract class GridAbstractCacheStoreSelfTest<T extends CacheStore<Object
         }
 
         /** {@inheritDoc} */
-        @Override public void rollback() throws IgniteCheckedException {
+        @Override public void rollback() {
             // No-op.
         }
     }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/hibernate/src/main/java/org/apache/ignite/cache/hibernate/GridHibernateReadWriteAccessStrategy.java
----------------------------------------------------------------------
diff --git a/modules/hibernate/src/main/java/org/apache/ignite/cache/hibernate/GridHibernateReadWriteAccessStrategy.java b/modules/hibernate/src/main/java/org/apache/ignite/cache/hibernate/GridHibernateReadWriteAccessStrategy.java
index 848dac4..2e11949 100644
--- a/modules/hibernate/src/main/java/org/apache/ignite/cache/hibernate/GridHibernateReadWriteAccessStrategy.java
+++ b/modules/hibernate/src/main/java/org/apache/ignite/cache/hibernate/GridHibernateReadWriteAccessStrategy.java
@@ -234,7 +234,7 @@ public class GridHibernateReadWriteAccessStrategy extends GridHibernateAccessStr
                     tx.rollback();
             }
         }
-        catch (IgniteCheckedException e) {
+        catch (IgniteException e) {
             log.error("Failed to rollback cache transaction.", e);
         }
     }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/jta/src/main/java/org/apache/ignite/internal/processors/cache/jta/CacheJtaManager.java
----------------------------------------------------------------------
diff --git a/modules/jta/src/main/java/org/apache/ignite/internal/processors/cache/jta/CacheJtaManager.java b/modules/jta/src/main/java/org/apache/ignite/internal/processors/cache/jta/CacheJtaManager.java
index fec4d45..3c0c1aa 100644
--- a/modules/jta/src/main/java/org/apache/ignite/internal/processors/cache/jta/CacheJtaManager.java
+++ b/modules/jta/src/main/java/org/apache/ignite/internal/processors/cache/jta/CacheJtaManager.java
@@ -67,7 +67,7 @@ public class CacheJtaManager<K, V> extends CacheJtaManagerAdapter<K, V> {
                     Transaction jtaTx = jtaTm.getTransaction();
 
                     if (jtaTx != null) {
-                        IgniteTx tx = cctx.tm().userTx();
+                        IgniteTxEx tx = cctx.tm().userTx();
 
                         if (tx == null) {
                             TransactionsConfiguration tCfg = cctx.kernalContext().config()

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/3d6afdaa/modules/web/src/main/java/org/apache/ignite/cache/websession/GridWebSessionFilter.java
----------------------------------------------------------------------
diff --git a/modules/web/src/main/java/org/apache/ignite/cache/websession/GridWebSessionFilter.java b/modules/web/src/main/java/org/apache/ignite/cache/websession/GridWebSessionFilter.java
index cfae3f6..fd790e7 100644
--- a/modules/web/src/main/java/org/apache/ignite/cache/websession/GridWebSessionFilter.java
+++ b/modules/web/src/main/java/org/apache/ignite/cache/websession/GridWebSessionFilter.java
@@ -295,7 +295,7 @@ public class GridWebSessionFilter implements Filter {
                 else
                     sesId = doFilter0(httpReq, res, chain);
             }
-            catch (IgniteCheckedException e) {
+            catch (Exception e) {
                 U.error(log, "Failed to update web session: " + sesId, e);
             }
         }
@@ -310,10 +310,10 @@ public class GridWebSessionFilter implements Filter {
      * @return Session ID.
      * @throws IOException In case of I/O error.
      * @throws ServletException In case oif servlet error.
-     * @throws IgniteCheckedException In case of other error.
+     * @throws CacheException In case of other error.
      */
     private String doFilter0(HttpServletRequest httpReq, ServletResponse res, FilterChain chain) throws IOException,
-        ServletException, IgniteCheckedException {
+        ServletException, CacheException {
         GridWebSession cached;
 
         String sesId = httpReq.getRequestedSessionId();


Mime
View raw message