Merge "NETCONF-526 : edit-config payload default-operation needs to be set to default...
authorJakub Morvay <jakub.morvay@gmail.com>
Wed, 4 Apr 2018 08:34:19 +0000 (08:34 +0000)
committerGerrit Code Review <gerrit@opendaylight.org>
Wed, 4 Apr 2018 08:34:19 +0000 (08:34 +0000)
1  2 
netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/AbstractWriteTx.java

index 5f31400bec62fdef8adf03d806c3c67635cda0d6,8c5929752c97bf0ea056a41aea4165c3600808ac..c4e01f37b0670a8fdd03965831282801050897e1
@@@ -18,8 -18,9 +18,8 @@@ import com.google.common.util.concurren
  import com.google.common.util.concurrent.SettableFuture;
  import java.util.List;
  import java.util.concurrent.CopyOnWriteArrayList;
 -import javax.annotation.Nullable;
 +import javax.annotation.Nonnull;
  import org.opendaylight.controller.config.util.xml.DocumentedException;
 -import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
@@@ -48,7 -49,7 +48,7 @@@ public abstract class AbstractWriteTx i
      protected final List<ListenableFuture<DOMRpcResult>> resultsFutures;
      private final List<TxListener> listeners = new CopyOnWriteArrayList<>();
      // Allow commit to be called only once
 -    protected boolean finished = false;
 +    protected volatile boolean finished = false;
  
      public AbstractWriteTx(final NetconfBaseOps netOps, final RemoteDeviceId id, final boolean rollbackSupport) {
          this.netOps = netOps;
          final DataContainerChild<?, ?> editStructure =
                  netOps.createEditConfigStrcture(Optional.<NormalizedNode<?, ?>>fromNullable(data),
                          Optional.of(ModifyAction.REPLACE), path);
-         editConfig(path, Optional.fromNullable(data), editStructure, Optional.of(ModifyAction.NONE), "put");
+         editConfig(path, Optional.fromNullable(data), editStructure, Optional.<ModifyAction>absent(), "put");
      }
  
      @Override
                  editStructure, Optional.of(ModifyAction.NONE), "delete");
      }
  
 -    @Override
 -    public final ListenableFuture<RpcResult<TransactionStatus>> commit() {
 +    protected final ListenableFuture<RpcResult<Void>> commitConfiguration() {
          listeners.forEach(listener -> listener.onTransactionSubmitted(this));
          checkNotFinished();
          finished = true;
 -        final ListenableFuture<RpcResult<TransactionStatus>> result = performCommit();
 -        Futures.addCallback(result, new FutureCallback<RpcResult<TransactionStatus>>() {
 +        final ListenableFuture<RpcResult<Void>> result = performCommit();
 +        Futures.addCallback(result, new FutureCallback<RpcResult<Void>>() {
              @Override
 -            public void onSuccess(@Nullable final RpcResult<TransactionStatus> result) {
 -                if (result != null && result.isSuccessful()) {
 +            public void onSuccess(@Nonnull final RpcResult<Void> rpcResult) {
 +                if (rpcResult.isSuccessful()) {
                      listeners.forEach(txListener -> txListener.onTransactionSuccessful(AbstractWriteTx.this));
                  } else {
                      final TransactionCommitFailedException cause =
                              new TransactionCommitFailedException("Transaction failed",
 -                                    result.getErrors().toArray(new RpcError[result.getErrors().size()]));
 +                                    rpcResult.getErrors().toArray(new RpcError[rpcResult.getErrors().size()]));
                      listeners.forEach(listener -> listener.onTransactionFailed(AbstractWriteTx.this, cause));
                  }
              }
          return result;
      }
  
 -    protected abstract ListenableFuture<RpcResult<TransactionStatus>> performCommit();
 +    protected abstract ListenableFuture<RpcResult<Void>> performCommit();
  
      private void checkEditable(final LogicalDatastoreType store) {
          checkNotFinished();
                                         DataContainerChild<?, ?> editStructure,
                                         Optional<ModifyAction> defaultOperation, String operation);
  
 -    protected ListenableFuture<RpcResult<TransactionStatus>> resultsToTxStatus() {
 -        final SettableFuture<RpcResult<TransactionStatus>> transformed = SettableFuture.create();
 +    protected ListenableFuture<RpcResult<Void>> resultsToTxStatus() {
 +        final SettableFuture<RpcResult<Void>> transformed = SettableFuture.create();
  
          Futures.addCallback(Futures.allAsList(resultsFutures), new FutureCallback<List<DOMRpcResult>>() {
              @Override
 -            public void onSuccess(final List<DOMRpcResult> domRpcResults) {
 +            public void onSuccess(@Nonnull final List<DOMRpcResult> domRpcResults) {
                  domRpcResults.forEach(domRpcResult -> {
                      if (!domRpcResult.getErrors().isEmpty() && !transformed.isDone()) {
                          final NetconfDocumentedException exception =
                  });
  
                  if (!transformed.isDone()) {
 -                    transformed.set(RpcResultBuilder.success(TransactionStatus.COMMITED).build());
 +                    transformed.set(RpcResultBuilder.<Void>success().build());
                  }
              }