Fix findbugs violations in netconf
[netconf.git] / netconf / sal-netconf-connector / src / main / java / org / opendaylight / netconf / sal / connect / netconf / sal / tx / AbstractWriteTx.java
index 3aeff93da40082c2a4405b5213a759a434890360..5f31400bec62fdef8adf03d806c3c67635cda0d6 100644 (file)
@@ -8,19 +8,28 @@
 
 package org.opendaylight.netconf.sal.connect.netconf.sal.tx;
 
-import com.google.common.base.Function;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
-import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import javax.annotation.Nonnull;
+import org.opendaylight.controller.config.util.xml.DocumentedException;
 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;
 import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
 import org.opendaylight.netconf.api.NetconfDocumentedException;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
 import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
@@ -36,17 +45,20 @@ public abstract class AbstractWriteTx implements DOMDataWriteTransaction {
     protected final RemoteDeviceId id;
     protected final NetconfBaseOps netOps;
     protected final boolean rollbackSupport;
+    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;
         this.id = id;
         this.rollbackSupport = rollbackSupport;
+        this.resultsFutures = Lists.newArrayList();
         init();
     }
 
-    static boolean isSuccess(final DOMRpcResult result) {
+    protected static boolean isSuccess(final DOMRpcResult result) {
         return result.getErrors().isEmpty();
     }
 
@@ -58,28 +70,12 @@ public abstract class AbstractWriteTx implements DOMDataWriteTransaction {
         return finished;
     }
 
-    protected void invokeBlocking(final String msg, final Function<NetconfBaseOps, ListenableFuture<DOMRpcResult>> op) throws NetconfDocumentedException {
-        try {
-            final DOMRpcResult compositeNodeRpcResult = op.apply(netOps).get();
-            if(isSuccess(compositeNodeRpcResult) == false) {
-                throw new NetconfDocumentedException(id + ": " + msg + " failed: " + compositeNodeRpcResult.getErrors(), NetconfDocumentedException.ErrorType.application,
-                        NetconfDocumentedException.ErrorTag.operation_failed, NetconfDocumentedException.ErrorSeverity.warning);
-            }
-        } catch (final InterruptedException e) {
-            Thread.currentThread().interrupt();
-            throw new RuntimeException(e);
-        } catch (final ExecutionException e) {
-            throw new NetconfDocumentedException(id + ": " + msg + " failed: " + e.getMessage(), e, NetconfDocumentedException.ErrorType.application,
-                    NetconfDocumentedException.ErrorTag.operation_failed, NetconfDocumentedException.ErrorSeverity.warning);
-        }
-    }
-
     @Override
     public synchronized boolean cancel() {
-        if(isFinished()) {
+        if (isFinished()) {
             return false;
         }
-
+        listeners.forEach(listener -> listener.onTransactionCancelled(this));
         finished = true;
         cleanup();
         return true;
@@ -95,48 +91,46 @@ public abstract class AbstractWriteTx implements DOMDataWriteTransaction {
     }
 
     @Override
-    public synchronized void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+    public synchronized void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
+                                 final NormalizedNode<?, ?> data) {
         checkEditable(store);
 
-        // trying to write only mixin nodes (not visible when serialized). Ignoring. Some devices cannot handle empty edit-config rpc
-        if(containsOnlyNonVisibleData(path, data)) {
+        // Trying to write only mixin nodes (not visible when serialized).
+        // Ignoring. Some devices cannot handle empty edit-config rpc
+        if (containsOnlyNonVisibleData(path, data)) {
             LOG.debug("Ignoring put for {} and data {}. Resulting data structure is empty.", path, data);
             return;
         }
 
-        try {
-            editConfig(
-                    netOps.createEditConfigStrcture(Optional.<NormalizedNode<?, ?>>fromNullable(data), Optional.of(ModifyAction.REPLACE), path), Optional.of(ModifyAction.NONE));
-        } catch (final NetconfDocumentedException e) {
-            handleEditException(path, data, e, "putting");
-        }
+        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");
     }
 
-    protected abstract void handleEditException(YangInstanceIdentifier path, NormalizedNode<?, ?> data, NetconfDocumentedException e, String editType);
-    protected abstract void handleDeleteException(YangInstanceIdentifier path, NetconfDocumentedException e);
-
     @Override
-    public synchronized void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+    public synchronized void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
+                                   final NormalizedNode<?, ?> data) {
         checkEditable(store);
 
-        // trying to write only mixin nodes (not visible when serialized). Ignoring. Some devices cannot handle empty edit-config rpc
+        // Trying to write only mixin nodes (not visible when serialized).
+        // Ignoring. Some devices cannot handle empty edit-config rpc
         if (containsOnlyNonVisibleData(path, data)) {
             LOG.debug("Ignoring merge for {} and data {}. Resulting data structure is empty.", path, data);
             return;
         }
 
-        try {
-            editConfig(
-                    netOps.createEditConfigStrcture(Optional.<NormalizedNode<?, ?>>fromNullable(data), Optional.<ModifyAction>absent(), path), Optional.<ModifyAction>absent());
-        } catch (final NetconfDocumentedException e) {
-            handleEditException(path, data, e, "merge");
-        }
+        final DataContainerChild<?, ?> editStructure =
+                netOps.createEditConfigStrcture(Optional.<NormalizedNode<?, ?>>fromNullable(data),
+                        Optional.<ModifyAction>absent(), path);
+        editConfig(path, Optional.fromNullable(data), editStructure, Optional.<ModifyAction>absent(), "merge");
     }
 
     /**
-     * Check whether the data to be written consists only from mixins
+     * Check whether the data to be written consists only from mixins.
      */
-    private static boolean containsOnlyNonVisibleData(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+    private static boolean containsOnlyNonVisibleData(final YangInstanceIdentifier path,
+                                                      final NormalizedNode<?, ?> data) {
         // There's only one such case:top level list (pathArguments == 1 && data is Mixin)
         // any other mixin nodes are contained by a "regular" node thus visible when serialized
         return path.getPathArguments().size() == 1 && data instanceof MixinNode;
@@ -145,29 +139,91 @@ public abstract class AbstractWriteTx implements DOMDataWriteTransaction {
     @Override
     public synchronized void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
         checkEditable(store);
-
-        try {
-            editConfig(
-                    netOps.createEditConfigStrcture(Optional.<NormalizedNode<?, ?>>absent(), Optional.of(ModifyAction.DELETE), path), Optional.of(ModifyAction.NONE));
-        } catch (final NetconfDocumentedException e) {
-            handleDeleteException(path, e);
-        }
+        final DataContainerChild<?, ?> editStructure =
+                netOps.createEditConfigStrcture(Optional.<NormalizedNode<?, ?>>absent(),
+                        Optional.of(ModifyAction.DELETE), path);
+        editConfig(path, Optional.<NormalizedNode<?, ?>>absent(),
+                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<Void>> result = performCommit();
+        Futures.addCallback(result, new FutureCallback<RpcResult<Void>>() {
+            @Override
+            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",
+                                    rpcResult.getErrors().toArray(new RpcError[rpcResult.getErrors().size()]));
+                    listeners.forEach(listener -> listener.onTransactionFailed(AbstractWriteTx.this, cause));
+                }
+            }
 
-        return performCommit();
+            @Override
+            public void onFailure(final Throwable throwable) {
+                listeners.forEach(listener -> listener.onTransactionFailed(AbstractWriteTx.this, throwable));
+            }
+        }, MoreExecutors.directExecutor());
+        return result;
     }
 
-    protected abstract ListenableFuture<RpcResult<TransactionStatus>> performCommit();
+    protected abstract ListenableFuture<RpcResult<Void>> performCommit();
 
     private void checkEditable(final LogicalDatastoreType store) {
         checkNotFinished();
-        Preconditions.checkArgument(store == LogicalDatastoreType.CONFIGURATION, "Can edit only configuration data, not %s", store);
+        Preconditions.checkArgument(store == LogicalDatastoreType.CONFIGURATION,
+                "Can edit only configuration data, not %s", store);
+    }
+
+    protected abstract void editConfig(YangInstanceIdentifier path, Optional<NormalizedNode<?, ?>> data,
+                                       DataContainerChild<?, ?> editStructure,
+                                       Optional<ModifyAction> defaultOperation, String operation);
+
+    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(@Nonnull final List<DOMRpcResult> domRpcResults) {
+                domRpcResults.forEach(domRpcResult -> {
+                    if (!domRpcResult.getErrors().isEmpty() && !transformed.isDone()) {
+                        final NetconfDocumentedException exception =
+                                new NetconfDocumentedException(id + ":RPC during tx failed",
+                                        DocumentedException.ErrorType.APPLICATION,
+                                        DocumentedException.ErrorTag.OPERATION_FAILED,
+                                        DocumentedException.ErrorSeverity.ERROR);
+                        transformed.setException(exception);
+                    }
+                });
+
+                if (!transformed.isDone()) {
+                    transformed.set(RpcResultBuilder.<Void>success().build());
+                }
+            }
+
+            @Override
+            public void onFailure(final Throwable throwable) {
+                final NetconfDocumentedException exception =
+                        new NetconfDocumentedException(
+                                id + ":RPC during tx returned an exception",
+                                new Exception(throwable),
+                                DocumentedException.ErrorType.APPLICATION,
+                                DocumentedException.ErrorTag.OPERATION_FAILED,
+                                DocumentedException.ErrorSeverity.ERROR);
+                transformed.setException(exception);
+            }
+        }, MoreExecutors.directExecutor());
+
+        return transformed;
     }
 
-    protected abstract void editConfig(DataContainerChild<?, ?> editStructure, Optional<ModifyAction> defaultOperation) throws NetconfDocumentedException;
+    AutoCloseable addListener(final TxListener listener) {
+        listeners.add(listener);
+        return () -> listeners.remove(listener);
+    }
 }