Bump odlparent to 5.0.0

[netconf.git] / netconf / sal-netconf-connector / src / main / java / org / opendaylight / netconf / sal / connect / netconf / sal / tx / ReadOnlyTx.java

diff --git a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/ReadOnlyTx.java b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/ReadOnlyTx.java
index 56fa78fe12faecda5d43e941c8fcc26cf98fb716..488f5604afecc62f29a93b14d4a6327208177c89 100644 (file)
--- a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/ReadOnlyTx.java
+++ b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/ReadOnlyTx.java
@@ -5,28 +5,27 @@
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
  * and is available at http://www.eclipse.org/legal/epl-v10.html
  */
-
 package org.opendaylight.netconf.sal.connect.netconf.sal.tx;
 
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+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.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
+import java.util.Optional;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfRpcFutureCallback;
 import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
-import org.opendaylight.yangtools.util.concurrent.MappingCheckedFuture;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-
-public final class ReadOnlyTx implements DOMDataReadOnlyTransaction {
+public final class ReadOnlyTx implements DOMDataTreeReadTransaction {
 
     private static final Logger LOG  = LoggerFactory.getLogger(ReadOnlyTx.class);
 
@@ -38,20 +37,34 @@ public final class ReadOnlyTx implements DOMDataReadOnlyTransaction {
         this.id = id;
     }
 
-    private CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readConfigurationData(
+    private FluentFuture<Optional<NormalizedNode<?, ?>>> readConfigurationData(
             final YangInstanceIdentifier path) {
-        final ListenableFuture<Optional<NormalizedNode<?, ?>>> configRunning = netconfOps.getConfigRunningData(
-                new NetconfRpcFutureCallback("Data read", id), Optional.fromNullable(path));
-
-        return MappingCheckedFuture.create(configRunning, ReadFailedException.MAPPER);
+        return remapException(netconfOps.getConfigRunningData(
+            new NetconfRpcFutureCallback("Data read", id), Optional.ofNullable(path)));
     }
 
-    private CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readOperationalData(
+    private FluentFuture<Optional<NormalizedNode<?, ?>>> readOperationalData(
             final YangInstanceIdentifier path) {
-        final ListenableFuture<Optional<NormalizedNode<?, ?>>> configCandidate = netconfOps.getData(
-                new NetconfRpcFutureCallback("Data read", id), Optional.fromNullable(path));
+        return remapException(netconfOps.getData(
+            new NetconfRpcFutureCallback("Data read", id), Optional.ofNullable(path)));
+    }
 
-        return MappingCheckedFuture.create(configCandidate, ReadFailedException.MAPPER);
+    private static <T> FluentFuture<T> remapException(final ListenableFuture<T> input) {
+        final SettableFuture<T> ret = SettableFuture.create();
+        Futures.addCallback(input, new FutureCallback<T>() {
+
+            @Override
+            public void onSuccess(final T result) {
+                ret.set(result);
+            }
+
+            @Override
+            public void onFailure(final Throwable cause) {
+                ret.setException(cause instanceof ReadFailedException ? cause
+                        : new ReadFailedException("NETCONF operation failed", cause));
+            }
+        }, MoreExecutors.directExecutor());
+        return FluentFuture.from(ret);
     }
 
     @Override
@@ -60,29 +73,24 @@ public final class ReadOnlyTx implements DOMDataReadOnlyTransaction {
     }
 
     @Override
-    public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(
-            final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+    public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+            final YangInstanceIdentifier path) {
         switch (store) {
-        case CONFIGURATION: {
-            return readConfigurationData(path);
+            case CONFIGURATION:
+                return readConfigurationData(path);
+            case OPERATIONAL:
+                return readOperationalData(path);
+            default:
+                LOG.info("Unknown datastore type: {}.", store);
+                throw new IllegalArgumentException(String.format(
+                    "%s, Cannot read data %s for %s datastore, unknown datastore type", id, path, store));
         }
-        case OPERATIONAL: {
-            return readOperationalData(path);
-        }
-        }
-
-        throw new IllegalArgumentException(String.format("%s, Cannot read data %s for %s datastore, unknown datastore type", id, path, store));
     }
 
     @Override
-    public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
-        final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> data = read(store, path);
-
-        try {
-            return Futures.immediateCheckedFuture(data.get().isPresent());
-        } catch (InterruptedException | ExecutionException e) {
-            return Futures.immediateFailedCheckedFuture(new ReadFailedException("Exists failed",e));
-        }
+    public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+        return read(store, path).transform(optionalNode -> optionalNode != null && optionalNode.isPresent(),
+                MoreExecutors.directExecutor());
     }
 
     @Override