update deprecated transform and addCallback methods

[groupbasedpolicy.git] / renderers / vpp / src / main / java / org / opendaylight / groupbasedpolicy / renderer / vpp / adapter / VppRpcServiceImpl.java

diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/adapter/VppRpcServiceImpl.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/adapter/VppRpcServiceImpl.java
index 940e2f596ebf6c0a5a6540a52ba7b9492c17e45b..e529468e407edb32413812119ac622b33d263913 100644 (file)
--- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/adapter/VppRpcServiceImpl.java
+++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/adapter/VppRpcServiceImpl.java
@@ -22,7 +22,7 @@ import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.ConfigCommand;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.interfaces.ConfigCommand;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.TapPortCommand;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand.VhostUserCommandBuilder;
@@ -45,9 +45,10 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapte
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes.InterfaceTypeChoice;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.bridge.domain.base.attributes.PhysicalLocationRef;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170315.VhostUserRole;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170315.VxlanVni;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VhostUserRole;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VxlanVni;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyVbridgeAugment;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vlan.rev170327.network.topology.topology.tunnel.parameters.VlanNetworkParameters;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vxlan.rev170327.network.topology.topology.tunnel.parameters.VxlanTunnelParameters;
@@ -68,6 +69,7 @@ import com.google.common.util.concurrent.AsyncFunction;
 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.MoreExecutors;
 
 public class VppRpcServiceImpl implements VppAdapterService, AutoCloseable {
 
@@ -112,7 +114,7 @@ public class VppRpcServiceImpl implements VppAdapterService, AutoCloseable {
                 futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(input.getId(), vlanId, nodeId));
             });
         }
-        return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());
+        return Futures.transformAsync(Futures.allAsList(futures), voidsToRpcResult(), MoreExecutors.directExecutor());
     }
 
     public Future<RpcResult<Void>> deleteVirtualBridgeDomainFromNodes(DeleteVirtualBridgeDomainFromNodesInput input) {
@@ -121,7 +123,7 @@ public class VppRpcServiceImpl implements VppAdapterService, AutoCloseable {
         input.getBridgeDomainNode().forEach(nodeId -> {
             futures.add(bridgeDomainManager.removeBridgeDomainFromVppNode(input.getBridgeDomainId(), nodeId));
         });
-        return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());
+        return Futures.transformAsync(Futures.allAsList(futures), voidsToRpcResult(), MoreExecutors.directExecutor());
     }
 
     public ListenableFuture<RpcResult<Void>> cloneVirtualBridgeDomainOnNodes(CloneVirtualBridgeDomainOnNodesInput input) {
@@ -130,7 +132,7 @@ public class VppRpcServiceImpl implements VppAdapterService, AutoCloseable {
         ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
         InstanceIdentifier<Topology> topologyIid = VppIidFactory.getTopologyIid(new TopologyKey(new TopologyId(
                 input.getBridgeDomainId())));
-        return Futures.transform(rTx.read(LogicalDatastoreType.CONFIGURATION, topologyIid),
+        return Futures.transformAsync(rTx.read(LogicalDatastoreType.CONFIGURATION, topologyIid),
                 new AsyncFunction<Optional<Topology>, RpcResult<Void>>() {
 
                     @Override
@@ -174,9 +176,9 @@ public class VppRpcServiceImpl implements VppAdapterService, AutoCloseable {
                                                 input.getBridgeDomainId(), vlanId, nodeId));
                                     });
                         }
-                        return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());
+                        return Futures.transformAsync(Futures.allAsList(futures), voidsToRpcResult(), MoreExecutors.directExecutor());
                     }
-                });
+                }, MoreExecutors.directExecutor());
     }
 
     public ListenableFuture<RpcResult<Void>> createInterfaceOnNode(CreateInterfaceOnNodeInput input) {
@@ -205,21 +207,15 @@ public class VppRpcServiceImpl implements VppAdapterService, AutoCloseable {
             ifaceCommand = tapBuilder.build();
         }
         InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
-        Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
-        if (!optDataBroker.isPresent()) {
-            return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
-                .withError(ErrorType.RPC, "Cannot find data broker for mount point " + vppNodeIid)
-                .build());
-        }
-        return Futures.transform(interfaceManager.createInterfaceOnVpp(ifaceCommand, optDataBroker.get()),
-                voidToRpcResult());
+        return Futures.transformAsync(interfaceManager.createInterfaceOnVpp(ifaceCommand, vppNodeIid),
+                voidToRpcResult(), MoreExecutors.directExecutor());
     }
 
     public ListenableFuture<RpcResult<Void>> deleteInterfaceFromNode(DeleteInterfaceFromNodeInput input) {
         LOG.info("Processing a remote call for removing interface {} from node {}", input.getVppInterfaceName(),
                 input.getVppNodeId());
         InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
-        return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),
+        return Futures.transformAsync(readInterface(vppNodeIid, input.getVppInterfaceName()),
                 new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {
 
                     @Override
@@ -233,19 +229,19 @@ public class VppRpcServiceImpl implements VppAdapterService, AutoCloseable {
                                                 + ". Not found or already deleted.")
                                 .build());
                         }
-                        Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
+                        Optional<DataBroker> dataBroker = mountDataProvider.resolveDataBrokerForMountPoint(vppNodeIid);
                         WriteTransaction wTx = dataBroker.get().newWriteOnlyTransaction();
                         wTx.delete(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getInterfaceIID(iKey));
-                        return Futures.transform(wTx.submit(), voidToRpcResult());
+                        return Futures.transformAsync(wTx.submit(), voidToRpcResult(), MoreExecutors.directExecutor());
                     }
-                });
+                }, MoreExecutors.directExecutor());
     }
 
     public ListenableFuture<RpcResult<Void>> addInterfaceToBridgeDomain(AddInterfaceToBridgeDomainInput input) {
         LOG.info("Processing a remote call for adding interface {} to bridge domain {}", input.getVppInterfaceName(),
                 input.getBridgeDomainId());
         InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
-        return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),
+        return Futures.transformAsync(readInterface(vppNodeIid, input.getVppInterfaceName()),
                 new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {
 
                     @Override
@@ -259,17 +255,16 @@ public class VppRpcServiceImpl implements VppAdapterService, AutoCloseable {
                                                 + vppNodeIid + ". Not found or deleted.")
                                 .build());
                         }
-                        Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
-                        return Futures.transform(interfaceManager.configureInterface(dataBroker.get(), iKey,
-                                input.getBridgeDomainId(), null), voidToRpcResult());
+                        return Futures.transformAsync(interfaceManager.configureInterface(vppNodeIid, iKey,
+                                input.getBridgeDomainId(), null), voidToRpcResult(), MoreExecutors.directExecutor());
                     }
-                });
+                }, MoreExecutors.directExecutor());
     }
 
     public ListenableFuture<RpcResult<Void>> delInterfaceFromBridgeDomain(DelInterfaceFromBridgeDomainInput input) {
         LOG.info("Processing a remote call for removing interface {} from bridge domain.", input.getVppInterfaceName());
         InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
-        return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),
+        return Futures.transformAsync(readInterface(vppNodeIid, input.getVppInterfaceName()),
                 new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {
 
                     @Override
@@ -283,16 +278,15 @@ public class VppRpcServiceImpl implements VppAdapterService, AutoCloseable {
                                                 + ". Not found or deleted.")
                                 .build());
                         }
-                        Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
-                        return Futures.transform(interfaceManager.removeInterfaceFromBridgeDomain(dataBroker.get(),
-                                optIface.get().getKey()), voidToRpcResult());
+                        return Futures.transformAsync(interfaceManager.removeInterfaceFromBridgeDomain(vppNodeIid,
+                                optIface.get().getKey()), voidToRpcResult(), MoreExecutors.directExecutor());
                     }
-                });
+                }, MoreExecutors.directExecutor());
     }
 
-    private CheckedFuture<Optional<Interface>, ReadFailedException> readInterface(InstanceIdentifier<?> nodeIid,
+    private CheckedFuture<Optional<Interface>, ReadFailedException> readInterface(InstanceIdentifier<Node> nodeIid,
             String interfaceName) {
-        Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(nodeIid);
+        Optional<DataBroker> optDataBroker = mountDataProvider.resolveDataBrokerForMountPoint(nodeIid);
         if (!optDataBroker.isPresent()) {
             LOG.error("Cannot find data broker for node {}", nodeIid);
             return Futures.immediateCheckedFuture(Optional.absent());