X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatabroker%2Factors%2Fdds%2FRemoteProxyTransaction.java;h=192205dc0a9c0f1df53b8177484f8bf3c0a2282f;hp=347c7eac033ae1bf4a63db2f3d4ba0d26b981d6c;hb=3ee40198347cfb53bd0ce12ffd625cff8ed2383b;hpb=320a4e5cd2d9d80468a3f82798744f2035488218 diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/actors/dds/RemoteProxyTransaction.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/actors/dds/RemoteProxyTransaction.java index 347c7eac03..192205dc0a 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/actors/dds/RemoteProxyTransaction.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/actors/dds/RemoteProxyTransaction.java @@ -13,11 +13,12 @@ import com.google.common.util.concurrent.CheckedFuture; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.SettableFuture; -import java.util.ArrayList; -import java.util.Collection; import java.util.function.Consumer; import javax.annotation.Nullable; +import org.opendaylight.controller.cluster.access.commands.AbortLocalTransactionRequest; +import org.opendaylight.controller.cluster.access.commands.AbstractLocalTransactionRequest; import org.opendaylight.controller.cluster.access.commands.AbstractReadTransactionRequest; +import org.opendaylight.controller.cluster.access.commands.CommitLocalTransactionRequest; import org.opendaylight.controller.cluster.access.commands.ExistsTransactionRequest; import org.opendaylight.controller.cluster.access.commands.ExistsTransactionSuccess; import org.opendaylight.controller.cluster.access.commands.ModifyTransactionRequest; @@ -25,20 +26,26 @@ import org.opendaylight.controller.cluster.access.commands.ModifyTransactionRequ import org.opendaylight.controller.cluster.access.commands.PersistenceProtocol; import org.opendaylight.controller.cluster.access.commands.ReadTransactionRequest; import org.opendaylight.controller.cluster.access.commands.ReadTransactionSuccess; +import org.opendaylight.controller.cluster.access.commands.TransactionAbortRequest; import org.opendaylight.controller.cluster.access.commands.TransactionDelete; +import org.opendaylight.controller.cluster.access.commands.TransactionDoCommitRequest; import org.opendaylight.controller.cluster.access.commands.TransactionMerge; import org.opendaylight.controller.cluster.access.commands.TransactionModification; +import org.opendaylight.controller.cluster.access.commands.TransactionPreCommitRequest; +import org.opendaylight.controller.cluster.access.commands.TransactionPurgeRequest; import org.opendaylight.controller.cluster.access.commands.TransactionRequest; import org.opendaylight.controller.cluster.access.commands.TransactionSuccess; import org.opendaylight.controller.cluster.access.commands.TransactionWrite; -import org.opendaylight.controller.cluster.access.concepts.RequestException; import org.opendaylight.controller.cluster.access.concepts.RequestFailure; import org.opendaylight.controller.cluster.access.concepts.Response; import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier; +import org.opendaylight.controller.cluster.datastore.util.AbstractDataTreeModificationCursor; import org.opendaylight.mdsal.common.api.ReadFailedException; import org.opendaylight.yangtools.util.concurrent.MappingCheckedFuture; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -62,18 +69,27 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { // FIXME: make this tuneable private static final int REQUEST_MAX_MODIFICATIONS = 1000; - private final Collection> successfulRequests = new ArrayList<>(); private final ModifyTransactionRequestBuilder builder; + private final boolean sendReadyOnSeal; + private final boolean snapshotOnly; private boolean builderBusy; private volatile Exception operationFailure; - RemoteProxyTransaction(final ProxyHistory parent, final TransactionIdentifier identifier) { + RemoteProxyTransaction(final ProxyHistory parent, final TransactionIdentifier identifier, + final boolean snapshotOnly, final boolean sendReadyOnSeal) { super(parent); + this.snapshotOnly = snapshotOnly; + this.sendReadyOnSeal = sendReadyOnSeal; builder = new ModifyTransactionRequestBuilder(identifier, localActor()); } + @Override + boolean isSnapshotOnly() { + return snapshotOnly; + } + @Override public TransactionIdentifier getIdentifier() { return builder.getIdentifier(); @@ -111,25 +127,25 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { @Override CheckedFuture doExists(final YangInstanceIdentifier path) { final SettableFuture future = SettableFuture.create(); - return sendReadRequest(new ExistsTransactionRequest(getIdentifier(), nextSequence(), localActor(), path), - t -> completeExists(future, t), future); + return sendReadRequest(new ExistsTransactionRequest(getIdentifier(), nextSequence(), localActor(), path, + isSnapshotOnly()), t -> completeExists(future, t), future); } @Override CheckedFuture>, ReadFailedException> doRead(final YangInstanceIdentifier path) { final SettableFuture>> future = SettableFuture.create(); - return sendReadRequest(new ReadTransactionRequest(getIdentifier(), nextSequence(), localActor(), path), - t -> completeRead(future, t), future); + return sendReadRequest(new ReadTransactionRequest(getIdentifier(), nextSequence(), localActor(), path, + isSnapshotOnly()), t -> completeRead(future, t), future); } @Override void doAbort() { - ensureInitializedBuider(); + ensureInitializedBuilder(); builder.setAbort(); flushBuilder(); } - private void ensureInitializedBuider() { + private void ensureInitializedBuilder() { if (!builderBusy) { builder.setSequence(nextSequence()); builderBusy = true; @@ -153,6 +169,41 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { sendRequest(request, response -> completeModify(request, response)); } + @Override + void handleForwardedLocalRequest(final AbstractLocalTransactionRequest request, + final Consumer> callback) { + if (request instanceof CommitLocalTransactionRequest) { + replayLocalCommitRequest((CommitLocalTransactionRequest) request, callback); + } else if (request instanceof AbortLocalTransactionRequest) { + sendRequest(abortRequest(), callback); + } else { + throw new IllegalStateException("Unhandled request " + request); + } + } + + private void replayLocalCommitRequest(final CommitLocalTransactionRequest request, + final Consumer> callback) { + final DataTreeModification mod = request.getModification(); + mod.applyToCursor(new AbstractDataTreeModificationCursor() { + @Override + public void write(final PathArgument child, final NormalizedNode data) { + doWrite(current().node(child), data); + } + + @Override + public void merge(final PathArgument child, final NormalizedNode data) { + doMerge(current().node(child), data); + } + + @Override + public void delete(final PathArgument child) { + doDelete(current().node(child)); + } + }); + + sendRequest(commitRequest(request.isCoordinated()), callback); + } + @Override void handleForwardedRemoteRequest(final TransactionRequest request, final @Nullable Consumer> callback) { @@ -179,7 +230,7 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { private void appendModification(final TransactionModification modification) { if (operationFailure == null) { - ensureInitializedBuider(); + ensureInitializedBuilder(); builder.addModification(modification); if (builder.size() >= REQUEST_MAX_MODIFICATIONS) { @@ -195,7 +246,7 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { if (response instanceof TransactionSuccess) { // Happy path - successfulRequests.add(request); + recordSuccessfulRequest(request); } else { recordFailedResponse(response); } @@ -229,6 +280,8 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { } else { failFuture(future, response); } + + recordFinishedRequest(); } private void completeRead(final SettableFuture>> future, @@ -240,11 +293,21 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { } else { failFuture(future, response); } + + recordFinishedRequest(); + } + + private ModifyTransactionRequest abortRequest() { + ensureInitializedBuilder(); + builder.setAbort(); + final ModifyTransactionRequest ret = builder.build(); + builderBusy = false; + return ret; } @Override ModifyTransactionRequest commitRequest(final boolean coordinated) { - ensureInitializedBuider(); + ensureInitializedBuilder(); builder.setCommit(coordinated); final ModifyTransactionRequest ret = builder.build(); @@ -254,28 +317,29 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { @Override void doSeal() { - // No-op + if (sendReadyOnSeal) { + ensureInitializedBuilder(); + builder.setReady(); + flushBuilder(); + } } @Override - void replaySuccessfulRequests(final AbstractProxyTransaction successor) { - super.replaySuccessfulRequests(successor); - - for (TransactionRequest req : successfulRequests) { - LOG.debug("Forwarding request {} to successor {}", req, successor); - successor.handleForwardedRemoteRequest(req, null); + void flushState(final AbstractProxyTransaction successor) { + if (builderBusy) { + final ModifyTransactionRequest request = builder.build(); + builderBusy = false; + successor.handleForwardedRemoteRequest(request, null); } - successfulRequests.clear(); } @Override void forwardToRemote(final RemoteProxyTransaction successor, final TransactionRequest request, - final Consumer> callback) throws RequestException { + final Consumer> callback) { successor.handleForwardedRequest(request, callback); } - private void handleForwardedRequest(final TransactionRequest request, final Consumer> callback) - throws RequestException { + private void handleForwardedRequest(final TransactionRequest request, final Consumer> callback) { if (request instanceof ModifyTransactionRequest) { final ModifyTransactionRequest req = (ModifyTransactionRequest) request; @@ -283,11 +347,11 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { final java.util.Optional maybeProto = req.getPersistenceProtocol(); if (maybeProto.isPresent()) { - seal(); + ensureSealed(); switch (maybeProto.get()) { case ABORT: - sendAbort(callback); + sendRequest(abortRequest(), callback); break; case SIMPLE: sendRequest(commitRequest(false), callback); @@ -295,10 +359,32 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { case THREE_PHASE: sendRequest(commitRequest(true), callback); break; + case READY: + //no op + break; default: throw new IllegalArgumentException("Unhandled protocol " + maybeProto.get()); } } + } else if (request instanceof ReadTransactionRequest) { + ensureFlushedBuider(); + sendRequest(new ReadTransactionRequest(getIdentifier(), nextSequence(), localActor(), + ((ReadTransactionRequest) request).getPath(), isSnapshotOnly()), callback); + } else if (request instanceof ExistsTransactionRequest) { + ensureFlushedBuider(); + sendRequest(new ExistsTransactionRequest(getIdentifier(), nextSequence(), localActor(), + ((ExistsTransactionRequest) request).getPath(), isSnapshotOnly()), callback); + } else if (request instanceof TransactionPreCommitRequest) { + ensureFlushedBuider(); + sendRequest(new TransactionPreCommitRequest(getIdentifier(), nextSequence(), localActor()), callback); + } else if (request instanceof TransactionDoCommitRequest) { + ensureFlushedBuider(); + sendRequest(new TransactionDoCommitRequest(getIdentifier(), nextSequence(), localActor()), callback); + } else if (request instanceof TransactionAbortRequest) { + ensureFlushedBuider(); + sendAbort(callback); + } else if (request instanceof TransactionPurgeRequest) { + purge(); } else { throw new IllegalArgumentException("Unhandled request {}" + request); } @@ -306,7 +392,7 @@ final class RemoteProxyTransaction extends AbstractProxyTransaction { @Override void forwardToLocal(final LocalProxyTransaction successor, final TransactionRequest request, - final Consumer> callback) throws RequestException { + final Consumer> callback) { successor.handleForwardedRemoteRequest(request, callback); } }