X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2FTransactionProxy.java;h=6183c489c4cdbc56a1ba9ac0c3c3939963277edb;hb=refs%2Fchanges%2F44%2F9944%2F5;hp=95862ae9d93670de67dbdd8bd99074a9ba49e8b8;hpb=a1ea6554ff025f333b171637b37a9ad87c7846ea;p=controller.git diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionProxy.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionProxy.java index 95862ae9d9..6183c489c4 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionProxy.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionProxy.java @@ -12,13 +12,14 @@ import akka.actor.ActorPath; import akka.actor.ActorRef; import akka.actor.ActorSelection; import akka.actor.Props; +import akka.dispatch.OnComplete; + import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.common.util.concurrent.CheckedFuture; import com.google.common.util.concurrent.Futures; -import com.google.common.util.concurrent.ListeningExecutorService; -import org.opendaylight.controller.cluster.datastore.exceptions.PrimaryNotFoundException; -import org.opendaylight.controller.cluster.datastore.exceptions.TimeoutException; +import com.google.common.util.concurrent.SettableFuture; + import org.opendaylight.controller.cluster.datastore.identifiers.TransactionIdentifier; import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction; import org.opendaylight.controller.cluster.datastore.messages.CreateTransaction; @@ -44,11 +45,12 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import scala.concurrent.Future; + import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.concurrent.Callable; import java.util.concurrent.atomic.AtomicLong; /** @@ -80,27 +82,24 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { private final ActorContext actorContext; private final Map remoteTransactionPaths = new HashMap<>(); private final TransactionIdentifier identifier; - private final ListeningExecutorService executor; private final SchemaContext schemaContext; + private boolean inReadyState; - public TransactionProxy( - ActorContext actorContext, - TransactionType transactionType, - ListeningExecutorService executor, - SchemaContext schemaContext - ) { + public TransactionProxy(ActorContext actorContext, TransactionType transactionType, + SchemaContext schemaContext) { this.actorContext = Preconditions.checkNotNull(actorContext, "actorContext should not be null"); this.transactionType = Preconditions.checkNotNull(transactionType, "transactionType should not be null"); - this.executor = Preconditions.checkNotNull(executor, "executor should not be null"); this.schemaContext = Preconditions.checkNotNull(schemaContext, "schemaContext should not be null"); String memberName = actorContext.getCurrentMemberName(); if(memberName == null){ memberName = "UNKNOWN-MEMBER"; } - this.identifier = TransactionIdentifier.builder().memberName(memberName).counter(counter.getAndIncrement()).build(); - LOG.debug("Created txn {}", identifier); + this.identifier = TransactionIdentifier.builder().memberName(memberName).counter( + counter.getAndIncrement()).build(); + + LOG.debug("Created txn {} of type {}", identifier, transactionType); } @@ -108,6 +107,9 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { public CheckedFuture>, ReadFailedException> read( final YangInstanceIdentifier path) { + Preconditions.checkState(transactionType != TransactionType.WRITE_ONLY, + "Read operation on write-only transaction is not allowed"); + LOG.debug("txn {} read {}", identifier, path); createTransactionIfMissing(actorContext, path); @@ -115,8 +117,12 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { return transactionContext(path).readData(path); } - @Override public CheckedFuture exists( - YangInstanceIdentifier path) { + @Override + public CheckedFuture exists(YangInstanceIdentifier path) { + + Preconditions.checkState(transactionType != TransactionType.WRITE_ONLY, + "Exists operation on write-only transaction is not allowed"); + LOG.debug("txn {} exists {}", identifier, path); createTransactionIfMissing(actorContext, path); @@ -124,9 +130,18 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { return transactionContext(path).dataExists(path); } + private void checkModificationState() { + Preconditions.checkState(transactionType != TransactionType.READ_ONLY, + "Modification operation on read-only transaction is not allowed"); + Preconditions.checkState(!inReadyState, + "Transaction is sealed - further modifications are allowed"); + } + @Override public void write(YangInstanceIdentifier path, NormalizedNode data) { + checkModificationState(); + LOG.debug("txn {} write {}", identifier, path); createTransactionIfMissing(actorContext, path); @@ -137,6 +152,8 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { @Override public void merge(YangInstanceIdentifier path, NormalizedNode data) { + checkModificationState(); + LOG.debug("txn {} merge {}", identifier, path); createTransactionIfMissing(actorContext, path); @@ -147,6 +164,8 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { @Override public void delete(YangInstanceIdentifier path) { + checkModificationState(); + LOG.debug("txn {} delete {}", identifier, path); createTransactionIfMissing(actorContext, path); @@ -156,25 +175,36 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { @Override public DOMStoreThreePhaseCommitCohort ready() { + + checkModificationState(); + + inReadyState = true; + List cohortPaths = new ArrayList<>(); - LOG.debug("txn {} Trying to get {} transactions ready for commit", identifier, remoteTransactionPaths.size()); + LOG.debug("txn {} Trying to get {} transactions ready for commit", identifier, + remoteTransactionPaths.size()); for(TransactionContext transactionContext : remoteTransactionPaths.values()) { - LOG.debug("txn {} Readying transaction for shard {}", identifier, transactionContext.getShardName()); + LOG.debug("txn {} Readying transaction for shard {}", identifier, + transactionContext.getShardName()); Object result = transactionContext.readyTransaction(); if(result.getClass().equals(ReadyTransactionReply.SERIALIZABLE_CLASS)){ - ReadyTransactionReply reply = ReadyTransactionReply.fromSerializable(actorContext.getActorSystem(),result); - String resolvedCohortPath = transactionContext - .getResolvedCohortPath(reply.getCohortPath().toString()); + ReadyTransactionReply reply = ReadyTransactionReply.fromSerializable( + actorContext.getActorSystem(),result); + String resolvedCohortPath = transactionContext.getResolvedCohortPath( + reply.getCohortPath().toString()); cohortPaths.add(actorContext.actorFor(resolvedCohortPath)); + } else { + LOG.error("Was expecting {} but got {}", ReadyTransactionReply.SERIALIZABLE_CLASS, + result.getClass()); } } - return new ThreePhaseCommitCohortProxy(actorContext, cohortPaths, identifier.toString(), executor); + return new ThreePhaseCommitCohortProxy(actorContext, cohortPaths, identifier.toString()); } @Override @@ -213,8 +243,7 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { Object response = actorContext.executeShardOperation(shardName, new CreateTransaction(identifier.toString(),this.transactionType.ordinal() ).toSerializable(), ActorContext.ASK_DURATION); - if (response.getClass() - .equals(CreateTransactionReply.SERIALIZABLE_CLASS)) { + if (response.getClass().equals(CreateTransactionReply.SERIALIZABLE_CLASS)) { CreateTransactionReply reply = CreateTransactionReply.fromSerializable(response); @@ -229,11 +258,13 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { transactionActor); remoteTransactionPaths.put(shardName, transactionContext); + } else { + LOG.error("Was expecting {} but got {}", CreateTransactionReply.SERIALIZABLE_CLASS, + response.getClass()); } - } catch(TimeoutException | PrimaryNotFoundException e){ + } catch(Exception e){ LOG.error("txn {} Creating NoOpTransaction because of : {}", identifier, e.getMessage()); - remoteTransactionPaths.put(shardName, - new NoOpTransactionContext(shardName)); + remoteTransactionPaths.put(shardName, new NoOpTransactionContext(shardName, e)); } } @@ -272,7 +303,8 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { this.actor = actor; } - @Override public String getShardName() { + @Override + public String getShardName() { return shardName; } @@ -280,96 +312,105 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { return actor; } - @Override public String getResolvedCohortPath(String cohortPath) { + @Override + public String getResolvedCohortPath(String cohortPath) { return actorContext.resolvePath(actorPath, cohortPath); } - @Override public void closeTransaction() { - getActor().tell( - new CloseTransaction().toSerializable(), null); + @Override + public void closeTransaction() { + actorContext.sendRemoteOperationAsync(getActor(), new CloseTransaction().toSerializable()); } - @Override public Object readyTransaction() { + @Override + public Object readyTransaction() { return actorContext.executeRemoteOperation(getActor(), - new ReadyTransaction().toSerializable(), - ActorContext.ASK_DURATION - ); - + new ReadyTransaction().toSerializable(), ActorContext.ASK_DURATION); } - @Override public void deleteData(YangInstanceIdentifier path) { - getActor().tell(new DeleteData(path).toSerializable(), null); + @Override + public void deleteData(YangInstanceIdentifier path) { + actorContext.sendRemoteOperationAsync(getActor(), new DeleteData(path).toSerializable() ); } - @Override public void mergeData(YangInstanceIdentifier path, - NormalizedNode data) { - getActor() - .tell(new MergeData(path, data, schemaContext).toSerializable(), - null); + @Override + public void mergeData(YangInstanceIdentifier path, NormalizedNode data) { + actorContext.sendRemoteOperationAsync(getActor(), + new MergeData(path, data, schemaContext).toSerializable()); } @Override public CheckedFuture>, ReadFailedException> readData( final YangInstanceIdentifier path) { - Callable>> call = - new Callable>>() { - - @Override public Optional> call() - throws Exception { - Object response = actorContext - .executeRemoteOperation(getActor(), - new ReadData(path).toSerializable(), - ActorContext.ASK_DURATION); - if (response.getClass() - .equals(ReadDataReply.SERIALIZABLE_CLASS)) { - ReadDataReply reply = ReadDataReply - .fromSerializable(schemaContext, path, - response); + final SettableFuture>> returnFuture = SettableFuture.create(); + + OnComplete onComplete = new OnComplete() { + @Override + public void onComplete(Throwable failure, Object response) throws Throwable { + if(failure != null) { + returnFuture.setException(new ReadFailedException( + "Error reading data for path " + path, failure)); + } else { + if (response.getClass().equals(ReadDataReply.SERIALIZABLE_CLASS)) { + ReadDataReply reply = ReadDataReply.fromSerializable(schemaContext, + path, response); if (reply.getNormalizedNode() == null) { - return Optional.absent(); + returnFuture.set(Optional.>absent()); + } else { + returnFuture.set(Optional.>of( + reply.getNormalizedNode())); } - return Optional.>of( - reply.getNormalizedNode()); + } else { + returnFuture.setException(new ReadFailedException( + "Invalid response reading data for path " + path)); } - - throw new ReadFailedException("Read Failed " + path); } - }; + } + }; - return MappingCheckedFuture - .create(executor.submit(call), ReadFailedException.MAPPER); - } + Future future = actorContext.executeRemoteOperationAsync(getActor(), + new ReadData(path).toSerializable(), ActorContext.ASK_DURATION); + future.onComplete(onComplete, actorContext.getActorSystem().dispatcher()); - @Override public void writeData(YangInstanceIdentifier path, - NormalizedNode data) { - getActor() - .tell(new WriteData(path, data, schemaContext).toSerializable(), - null); + return MappingCheckedFuture.create(returnFuture, ReadFailedException.MAPPER); } - @Override public CheckedFuture dataExists( - final YangInstanceIdentifier path) { - - Callable call = new Callable() { - - @Override public Boolean call() throws Exception { - Object o = actorContext.executeRemoteOperation(getActor(), - new DataExists(path).toSerializable(), - ActorContext.ASK_DURATION - ); - + @Override + public void writeData(YangInstanceIdentifier path, NormalizedNode data) { + actorContext.sendRemoteOperationAsync(getActor(), + new WriteData(path, data, schemaContext).toSerializable()); + } - if (DataExistsReply.SERIALIZABLE_CLASS - .equals(o.getClass())) { - return DataExistsReply.fromSerializable(o).exists(); + @Override + public CheckedFuture dataExists( + final YangInstanceIdentifier path) { + + final SettableFuture returnFuture = SettableFuture.create(); + + OnComplete onComplete = new OnComplete() { + @Override + public void onComplete(Throwable failure, Object response) throws Throwable { + if(failure != null) { + returnFuture.setException(new ReadFailedException( + "Error checking exists for path " + path, failure)); + } else { + if (response.getClass().equals(DataExistsReply.SERIALIZABLE_CLASS)) { + returnFuture.set(Boolean.valueOf(DataExistsReply. + fromSerializable(response).exists())); + } else { + returnFuture.setException(new ReadFailedException( + "Invalid response checking exists for path " + path)); + } } - - throw new ReadFailedException("Exists Failed " + path); } }; - return MappingCheckedFuture - .create(executor.submit(call), ReadFailedException.MAPPER); + + Future future = actorContext.executeRemoteOperationAsync(getActor(), + new DataExists(path).toSerializable(), ActorContext.ASK_DURATION); + future.onComplete(onComplete, actorContext.getActorSystem().dispatcher()); + + return MappingCheckedFuture.create(returnFuture, ReadFailedException.MAPPER); } } @@ -379,22 +420,28 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { LOG = LoggerFactory.getLogger(NoOpTransactionContext.class); private final String shardName; + private final Exception failure; private ActorRef cohort; - public NoOpTransactionContext(String shardName){ + public NoOpTransactionContext(String shardName, Exception failure){ this.shardName = shardName; + this.failure = failure; } - @Override public String getShardName() { + + @Override + public String getShardName() { return shardName; } - @Override public String getResolvedCohortPath(String cohortPath) { + @Override + public String getResolvedCohortPath(String cohortPath) { return cohort.path().toString(); } - @Override public void closeTransaction() { + @Override + public void closeTransaction() { LOG.warn("txn {} closeTransaction called", identifier); } @@ -404,11 +451,13 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { return new ReadyTransactionReply(cohort.path()).toSerializable(); } - @Override public void deleteData(YangInstanceIdentifier path) { + @Override + public void deleteData(YangInstanceIdentifier path) { LOG.warn("txt {} deleteData called path = {}", identifier, path); } - @Override public void mergeData(YangInstanceIdentifier path, + @Override + public void mergeData(YangInstanceIdentifier path, NormalizedNode data) { LOG.warn("txn {} mergeData called path = {}", identifier, path); } @@ -417,8 +466,8 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { public CheckedFuture>, ReadFailedException> readData( YangInstanceIdentifier path) { LOG.warn("txn {} readData called path = {}", identifier, path); - return Futures.immediateCheckedFuture( - Optional.>absent()); + return Futures.immediateFailedCheckedFuture(new ReadFailedException( + "Error reading data for path " + path, failure)); } @Override public void writeData(YangInstanceIdentifier path, @@ -429,10 +478,8 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { @Override public CheckedFuture dataExists( YangInstanceIdentifier path) { LOG.warn("txn {} dataExists called path = {}", identifier, path); - - // Returning false instead of an exception to keep this aligned with - // read - return Futures.immediateCheckedFuture(false); + return Futures.immediateFailedCheckedFuture(new ReadFailedException( + "Error checking exists for path " + path, failure)); } }