Merge "Improve performance of XmlElement.getName"

[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / main / java / org / opendaylight / controller / cluster / datastore / TransactionChainProxy.java

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionChainProxy.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionChainProxy.java
index b74c89d727c2a1761a7c993272abcab1e4ad9999..cf261cbd2af103b70f3dfce9885903a88ee293e6 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionChainProxy.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionChainProxy.java
@@ -8,72 +8,128 @@
 
 package org.opendaylight.controller.cluster.datastore;
 
-import akka.actor.ActorPath;
-import akka.dispatch.Futures;
+import com.google.common.base.Preconditions;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
 import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionChain;
 import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionChainClosedException;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
-import scala.concurrent.Await;
 import scala.concurrent.Future;
 
-import java.util.Collections;
-import java.util.List;
-
 /**
  * TransactionChainProxy acts as a proxy for a DOMStoreTransactionChain created on a remote shard
  */
-public class TransactionChainProxy implements DOMStoreTransactionChain{
+public class TransactionChainProxy implements DOMStoreTransactionChain {
+
+    private interface State {
+        boolean isReady();
+
+        List<Future<Object>> getPreviousReadyFutures();
+    }
+
+    private static class Allocated implements State {
+        private final ChainedTransactionProxy transaction;
+
+        Allocated(ChainedTransactionProxy transaction) {
+            this.transaction = transaction;
+        }
+
+        @Override
+        public boolean isReady() {
+            return transaction.isReady();
+        }
+
+        @Override
+        public List<Future<Object>> getPreviousReadyFutures() {
+            return transaction.getReadyFutures();
+        }
+    }
+
+    private static abstract class AbstractDefaultState implements State {
+        @Override
+        public List<Future<Object>> getPreviousReadyFutures() {
+            return Collections.emptyList();
+        }
+    }
+
+    private static final State IDLE_STATE = new AbstractDefaultState() {
+        @Override
+        public boolean isReady() {
+            return true;
+        }
+    };
+
+    private static final State CLOSED_STATE = new AbstractDefaultState() {
+        @Override
+        public boolean isReady() {
+            throw new TransactionChainClosedException("Transaction chain has been closed");
+        }
+    };
+
+    private static final AtomicInteger counter = new AtomicInteger(0);
+
     private final ActorContext actorContext;
     private final String transactionChainId;
-    private volatile List<Future<ActorPath>> cohortPathFutures = Collections.emptyList();
+    private volatile State currentState = IDLE_STATE;
 
     public TransactionChainProxy(ActorContext actorContext) {
         this.actorContext = actorContext;
-        transactionChainId = actorContext.getCurrentMemberName() + "-" + System.currentTimeMillis();
+        transactionChainId = actorContext.getCurrentMemberName() + "-txn-chain-" + counter.incrementAndGet();
+    }
+
+    public String getTransactionChainId() {
+        return transactionChainId;
     }
 
     @Override
     public DOMStoreReadTransaction newReadOnlyTransaction() {
-        return new TransactionProxy(actorContext,
-            TransactionProxy.TransactionType.READ_ONLY, this);
+        State localState = currentState;
+        checkReadyState(localState);
+
+        return new ChainedTransactionProxy(actorContext, TransactionProxy.TransactionType.READ_ONLY,
+                transactionChainId, localState.getPreviousReadyFutures());
     }
 
     @Override
     public DOMStoreReadWriteTransaction newReadWriteTransaction() {
-        return new TransactionProxy(actorContext,
-            TransactionProxy.TransactionType.READ_WRITE, this);
+        actorContext.acquireTxCreationPermit();
+        return allocateWriteTransaction(TransactionProxy.TransactionType.READ_WRITE);
     }
 
     @Override
     public DOMStoreWriteTransaction newWriteOnlyTransaction() {
-        return new TransactionProxy(actorContext,
-            TransactionProxy.TransactionType.WRITE_ONLY, this);
+        actorContext.acquireTxCreationPermit();
+        return allocateWriteTransaction(TransactionProxy.TransactionType.WRITE_ONLY);
     }
 
     @Override
     public void close() {
+        currentState = CLOSED_STATE;
+
         // Send a close transaction chain request to each and every shard
-        actorContext.broadcast(new CloseTransactionChain(transactionChainId));
+        actorContext.broadcast(new CloseTransactionChain(transactionChainId).toSerializable());
     }
 
-    public String getTransactionChainId() {
-        return transactionChainId;
-    }
+    private ChainedTransactionProxy allocateWriteTransaction(TransactionProxy.TransactionType type) {
+        State localState = currentState;
 
-    public void onTransactionReady(List<Future<ActorPath>> cohortPathFutures){
-        this.cohortPathFutures = cohortPathFutures;
+        checkReadyState(localState);
+
+        // Pass the ready Futures from the previous Tx.
+        ChainedTransactionProxy txProxy = new ChainedTransactionProxy(actorContext, type,
+                transactionChainId, localState.getPreviousReadyFutures());
+
+        currentState = new Allocated(txProxy);
+
+        return txProxy;
     }
 
-    public void waitTillCurrentTransactionReady(){
-        try {
-            Await.result(Futures
-                .sequence(this.cohortPathFutures, actorContext.getActorSystem().dispatcher()),
-                actorContext.getOperationDuration());
-        } catch (Exception e) {
-            throw new IllegalStateException("Failed when waiting for transaction on a chain to become ready", e);
-        }
+    private void checkReadyState(State state) {
+        Preconditions.checkState(state.isReady(), "Previous transaction is not ready yet");
     }
 }