-/*\r
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
- *\r
- * This program and the accompanying materials are made available under the\r
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
- * and is available at http://www.eclipse.org/legal/epl-v10.html\r
- */\r
-\r
-package org.opendaylight.groupbasedpolicy.renderer.vpp.adapter;\r
-\r
-import java.util.ArrayList;\r
-import java.util.List;\r
-import java.util.concurrent.Future;\r
-import java.util.stream.Collectors;\r
-\r
-import javax.annotation.Nonnull;\r
-\r
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;\r
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.ConfigCommand;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.TapPortCommand;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand.VhostUserCommandBuilder;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General.Operations;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;\r
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;\r
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.AddInterfaceToBridgeDomainInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateInterfaceOnNodeInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateVirtualBridgeDomainOnNodesInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DelInterfaceFromBridgeDomainInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteInterfaceFromNodeInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteVirtualBridgeDomainFromNodesInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CloneVirtualBridgeDomainOnNodesInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.bridge.domain.attributes.tunnel.type.Vlan;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.bridge.domain.attributes.tunnel.type.Vxlan;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes.InterfaceTypeChoice;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCase;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCase;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUserRole;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanVni;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyVbridgeAugment;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vlan.rev160429.network.topology.topology.tunnel.parameters.VlanNetworkParameters;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vxlan.rev160429.network.topology.topology.tunnel.parameters.VxlanTunnelParameters;\r
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;\r
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;\r
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;\r
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;\r
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;\r
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;\r
-import org.opendaylight.yangtools.yang.common.RpcResult;\r
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;\r
-import org.slf4j.Logger;\r
-import org.slf4j.LoggerFactory;\r
-\r
-import com.google.common.base.Optional;\r
-import com.google.common.util.concurrent.AsyncFunction;\r
-import com.google.common.util.concurrent.CheckedFuture;\r
-import com.google.common.util.concurrent.Futures;\r
-import com.google.common.util.concurrent.ListenableFuture;\r
-\r
-public class VppRpcServiceImpl {\r
-\r
- private static final Logger LOG = LoggerFactory.getLogger(VppRpcServiceImpl.class);\r
-\r
- private final DataBroker dataBroker;\r
- private final BridgeDomainManager bridgeDomainManager;\r
- private final InterfaceManager interfaceManager;\r
- private final MountedDataBrokerProvider mountDataProvider;\r
-\r
- public VppRpcServiceImpl(@Nonnull DataBroker dataBroker, @Nonnull MountedDataBrokerProvider mountDataProvider,\r
- BridgeDomainManager bridgeDomainManager, InterfaceManager interfaceManager) {\r
- this.dataBroker = dataBroker;\r
- this.bridgeDomainManager = bridgeDomainManager;\r
- this.interfaceManager = interfaceManager;\r
- this.mountDataProvider = mountDataProvider;\r
- }\r
-\r
- public Future<RpcResult<Void>> createVirtualBridgeDomain(CreateVirtualBridgeDomainOnNodesInput input) {\r
- LOG.info("Processing a remote call for creating bridge domain {}", input.getId());\r
- if (input.getTunnelType() == null) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(ErrorType.RPC,\r
- "Failed to create bridge domain" + input.getId() + "." + "Tunnel type not specified")\r
- .build());\r
- }\r
- List<ListenableFuture<Void>> futures = new ArrayList<>();\r
- List<NodeId> nodeIds = input.getPhysicalLocationRef()\r
- .stream()\r
- .map(locationRef -> locationRef.getNodeId())\r
- .collect(Collectors.toList());\r
- LOG.trace("Corresponding nodes for bridge-domain {}", input.getPhysicalLocationRef());\r
- if (input.getTunnelType() instanceof Vxlan) {\r
- LOG.trace("Detected VXLAN type for bridge domain {}", input.getId());\r
- Vxlan tunnelType = (Vxlan) input.getTunnelType();\r
- VxlanVni vxlanVni = new VxlanVni(tunnelType.getVni().getValue());\r
- nodeIds.forEach(nodeId -> {\r
- futures.add(bridgeDomainManager.createVxlanBridgeDomainOnVppNode(input.getId(), vxlanVni, nodeId));\r
- });\r
- } else if (input.getTunnelType() instanceof Vlan) {\r
- LOG.trace("Detected VLAN type for bridge domain {}", input.getId());\r
- Vlan vlan = (Vlan) input.getTunnelType();\r
- VlanId vlanId = new VlanId(vlan.getVlanId().getValue());\r
- nodeIds.forEach(nodeId -> {\r
- futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(input.getId(), vlanId, nodeId));\r
- });\r
- }\r
- return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());\r
- }\r
-\r
- public Future<RpcResult<Void>> deleteVirtualBridgeDomain(DeleteVirtualBridgeDomainFromNodesInput input) {\r
- LOG.info("Processing a remote call for removing bridge domain {}", input.getBridgeDomainId());\r
- List<ListenableFuture<Void>> futures = new ArrayList<>();\r
- input.getBridgeDomainNode().forEach(nodeId -> {\r
- futures.add(bridgeDomainManager.removeBridgeDomainFromVppNode(input.getBridgeDomainId(), nodeId));\r
- });\r
- return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());\r
- }\r
-\r
- public ListenableFuture<RpcResult<Void>> cloneVirtualBridgeDomainOnNode(CloneVirtualBridgeDomainOnNodesInput input) {\r
- LOG.info("Processing a remote call for clonning bridge domain {}", input.getBridgeDomainId());\r
- List<ListenableFuture<Void>> futures = new ArrayList<>();\r
- ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();\r
- InstanceIdentifier<Topology> topologyIid = VppIidFactory.getTopologyIid(new TopologyKey(new TopologyId(\r
- input.getBridgeDomainId())));\r
- return Futures.transform(rTx.read(LogicalDatastoreType.CONFIGURATION, topologyIid),\r
- new AsyncFunction<Optional<Topology>, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(Optional<Topology> optTopology) throws Exception {\r
- if (!optTopology.isPresent()) {\r
-\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(\r
- ErrorType.RPC,\r
- "Failed to clone bridge domain. Bridge domain " + input.getBridgeDomainId()\r
- + " does not exist.")\r
- .build());\r
- }\r
- TopologyVbridgeAugment vBridgeAug = optTopology.get().getAugmentation(TopologyVbridgeAugment.class);\r
- if (vBridgeAug == null) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(\r
- ErrorType.RPC,\r
- "Failed to clone bridge domain. Topology " + input.getBridgeDomainId()\r
- + " is not bridge domain type.")\r
- .build());\r
- }\r
- if (vBridgeAug.getTunnelParameters() instanceof VxlanTunnelParameters) {\r
- LOG.debug("Clonning VXLAN type bridge domain {} on nodes {}", input.getBridgeDomainId(),\r
- input.getBridgeDomainNode());\r
- VxlanTunnelParameters vxlanTunnelParams = (VxlanTunnelParameters) vBridgeAug.getTunnelParameters();\r
- VxlanVni vni = vxlanTunnelParams.getVni();\r
- input.getBridgeDomainNode().forEach(\r
- nodeId -> {\r
- futures.add(bridgeDomainManager.createVxlanBridgeDomainOnVppNode(\r
- input.getBridgeDomainId(), vni, nodeId));\r
- });\r
- } else if (vBridgeAug.getTunnelParameters() instanceof VlanNetworkParameters) {\r
- LOG.debug("Clonning VLAN type bridge domain {} on nodes {}", input.getBridgeDomainId(),\r
- input.getBridgeDomainNode());\r
- VlanNetworkParameters vlanTunnelParams = (VlanNetworkParameters) vBridgeAug.getTunnelParameters();\r
- VlanId vlanId = vlanTunnelParams.getVlanId();\r
- input.getBridgeDomainNode().forEach(\r
- nodeId -> {\r
- futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(\r
- input.getBridgeDomainId(), vlanId, nodeId));\r
- });\r
- }\r
- return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());\r
- }\r
- });\r
- }\r
-\r
- public ListenableFuture<RpcResult<Void>> createInterfaceOnNodes(CreateInterfaceOnNodeInput input) {\r
- InterfaceTypeChoice interfaceType = input.getInterfaceTypeChoice();\r
- ConfigCommand ifaceCommand = null;\r
- if (interfaceType instanceof VhostUserCase) {\r
- VhostUserCommandBuilder vhostBuilder = VhostUserCommand.builder();\r
- vhostBuilder.setName(input.getVppInterfaceName());\r
- VhostUserCase vhostCase = (VhostUserCase) input.getInterfaceTypeChoice();\r
- vhostBuilder.setSocket(vhostCase.getSocket());\r
- vhostBuilder.setRole(VhostUserRole.Client);\r
- vhostBuilder.setDescription(input.getDescription());\r
- vhostBuilder.setOperation(Operations.PUT);\r
- ifaceCommand = vhostBuilder.build();\r
- }\r
- if (interfaceType instanceof TapCase) {\r
- TapPortCommand.TapPortCommandBuilder tapBuilder = TapPortCommand.builder();\r
- TapCase tapIface = (TapCase) input.getInterfaceTypeChoice();\r
- tapBuilder.setTapName(tapIface.getName());\r
- tapBuilder.setPhysAddress(tapIface.getPhysicalAddress());\r
- tapBuilder.setInterfaceName(input.getVppInterfaceName());\r
- tapBuilder.setDescription(input.getDescription());\r
- tapBuilder.setOperation(Operations.PUT);\r
- ifaceCommand = tapBuilder.build();\r
- }\r
- InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());\r
- Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);\r
- if (!optDataBroker.isPresent()) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(ErrorType.RPC, "Cannot find data broker for mount point " + vppNodeIid)\r
- .build());\r
- }\r
- return Futures.transform(interfaceManager.createInterfaceOnVpp(ifaceCommand, optDataBroker.get()),\r
- voidToRpcResult());\r
- }\r
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * 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.groupbasedpolicy.renderer.vpp.adapter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
+import java.util.stream.Collectors;
+
+import javax.annotation.Nonnull;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+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.TapPortCommand;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand.VhostUserCommandBuilder;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General.Operations;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.AddInterfaceToBridgeDomainInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateInterfaceOnNodeInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateVirtualBridgeDomainOnNodesInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DelInterfaceFromBridgeDomainInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteInterfaceFromNodeInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteVirtualBridgeDomainFromNodesInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CloneVirtualBridgeDomainOnNodesInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.bridge.domain.attributes.tunnel.type.Vlan;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.bridge.domain.attributes.tunnel.type.Vxlan;
+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.l2.types.rev130827.VlanId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUserRole;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.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.rev160429.network.topology.topology.tunnel.parameters.VlanNetworkParameters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vxlan.rev160429.network.topology.topology.tunnel.parameters.VxlanTunnelParameters;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Optional;
+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;
+
+public class VppRpcServiceImpl {
+
+ private static final Logger LOG = LoggerFactory.getLogger(VppRpcServiceImpl.class);
+
+ private final DataBroker dataBroker;
+ private final BridgeDomainManager bridgeDomainManager;
+ private final InterfaceManager interfaceManager;
+ private final MountedDataBrokerProvider mountDataProvider;
+
+ public VppRpcServiceImpl(@Nonnull DataBroker dataBroker, @Nonnull MountedDataBrokerProvider mountDataProvider,
+ BridgeDomainManager bridgeDomainManager, InterfaceManager interfaceManager) {
+ this.dataBroker = dataBroker;
+ this.bridgeDomainManager = bridgeDomainManager;
+ this.interfaceManager = interfaceManager;
+ this.mountDataProvider = mountDataProvider;
+ }
+
+ public Future<RpcResult<Void>> createVirtualBridgeDomain(CreateVirtualBridgeDomainOnNodesInput input) {
+ LOG.info("Processing a remote call for creating bridge domain {}", input.getId());
+ if (input.getTunnelType() == null) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(ErrorType.RPC,
+ "Failed to create bridge domain" + input.getId() + "." + "Tunnel type not specified")
+ .build());
+ }
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ List<NodeId> nodeIds = input.getPhysicalLocationRef()
+ .stream()
+ .map(locationRef -> locationRef.getNodeId())
+ .collect(Collectors.toList());
+ LOG.trace("Corresponding nodes for bridge-domain {}", input.getPhysicalLocationRef());
+ if (input.getTunnelType() instanceof Vxlan) {
+ LOG.trace("Detected VXLAN type for bridge domain {}", input.getId());
+ Vxlan tunnelType = (Vxlan) input.getTunnelType();
+ VxlanVni vxlanVni = new VxlanVni(tunnelType.getVni().getValue());
+ nodeIds.forEach(nodeId -> {
+ futures.add(bridgeDomainManager.createVxlanBridgeDomainOnVppNode(input.getId(), vxlanVni, nodeId));
+ });
+ } else if (input.getTunnelType() instanceof Vlan) {
+ LOG.trace("Detected VLAN type for bridge domain {}", input.getId());
+ Vlan vlan = (Vlan) input.getTunnelType();
+ VlanId vlanId = new VlanId(vlan.getVlanId().getValue());
+ nodeIds.forEach(nodeId -> {
+ futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(input.getId(), vlanId, nodeId));
+ });
+ }
+ return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());
+ }
+
+ public Future<RpcResult<Void>> deleteVirtualBridgeDomain(DeleteVirtualBridgeDomainFromNodesInput input) {
+ LOG.info("Processing a remote call for removing bridge domain {}", input.getBridgeDomainId());
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ input.getBridgeDomainNode().forEach(nodeId -> {
+ futures.add(bridgeDomainManager.removeBridgeDomainFromVppNode(input.getBridgeDomainId(), nodeId));
+ });
+ return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());
+ }
+
+ public ListenableFuture<RpcResult<Void>> cloneVirtualBridgeDomainOnNode(CloneVirtualBridgeDomainOnNodesInput input) {
+ LOG.info("Processing a remote call for clonning bridge domain {}", input.getBridgeDomainId());
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+ InstanceIdentifier<Topology> topologyIid = VppIidFactory.getTopologyIid(new TopologyKey(new TopologyId(
+ input.getBridgeDomainId())));
+ return Futures.transform(rTx.read(LogicalDatastoreType.CONFIGURATION, topologyIid),
+ new AsyncFunction<Optional<Topology>, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(Optional<Topology> optTopology) throws Exception {
+ if (!optTopology.isPresent()) {
+
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(
+ ErrorType.RPC,
+ "Failed to clone bridge domain. Bridge domain " + input.getBridgeDomainId()
+ + " does not exist.")
+ .build());
+ }
+ TopologyVbridgeAugment vBridgeAug = optTopology.get().getAugmentation(TopologyVbridgeAugment.class);
+ if (vBridgeAug == null) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(
+ ErrorType.RPC,
+ "Failed to clone bridge domain. Topology " + input.getBridgeDomainId()
+ + " is not bridge domain type.")
+ .build());
+ }
+ if (vBridgeAug.getTunnelParameters() instanceof VxlanTunnelParameters) {
+ LOG.debug("Clonning VXLAN type bridge domain {} on nodes {}", input.getBridgeDomainId(),
+ input.getBridgeDomainNode());
+ VxlanTunnelParameters vxlanTunnelParams = (VxlanTunnelParameters) vBridgeAug.getTunnelParameters();
+ VxlanVni vni = vxlanTunnelParams.getVni();
+ input.getBridgeDomainNode().forEach(
+ nodeId -> {
+ futures.add(bridgeDomainManager.createVxlanBridgeDomainOnVppNode(
+ input.getBridgeDomainId(), vni, nodeId));
+ });
+ } else if (vBridgeAug.getTunnelParameters() instanceof VlanNetworkParameters) {
+ LOG.debug("Clonning VLAN type bridge domain {} on nodes {}", input.getBridgeDomainId(),
+ input.getBridgeDomainNode());
+ VlanNetworkParameters vlanTunnelParams = (VlanNetworkParameters) vBridgeAug.getTunnelParameters();
+ VlanId vlanId = vlanTunnelParams.getVlanId();
+ input.getBridgeDomainNode().forEach(
+ nodeId -> {
+ futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(
+ input.getBridgeDomainId(), vlanId, nodeId));
+ });
+ }
+ return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());
+ }
+ });
+ }
+
+ public ListenableFuture<RpcResult<Void>> createInterfaceOnNodes(CreateInterfaceOnNodeInput input) {
+ InterfaceTypeChoice interfaceType = input.getInterfaceTypeChoice();
+ ConfigCommand ifaceCommand = null;
+ if (interfaceType instanceof VhostUserCase) {
+ VhostUserCommandBuilder vhostBuilder = VhostUserCommand.builder();
+ vhostBuilder.setName(input.getVppInterfaceName());
+ VhostUserCase vhostCase = (VhostUserCase) input.getInterfaceTypeChoice();
+ vhostBuilder.setSocket(vhostCase.getSocket());
+ vhostBuilder.setRole(VhostUserRole.Client);
+ vhostBuilder.setDescription(input.getDescription());
+ vhostBuilder.setOperation(Operations.PUT);
+ ifaceCommand = vhostBuilder.build();
+ }
+ if (interfaceType instanceof TapCase) {
+ TapPortCommand.TapPortCommandBuilder tapBuilder = TapPortCommand.builder();
+ TapCase tapIface = (TapCase) input.getInterfaceTypeChoice();
+ tapBuilder.setTapName(tapIface.getName());
+ tapBuilder.setPhysAddress(tapIface.getPhysicalAddress());
+ tapBuilder.setInterfaceName(input.getVppInterfaceName());
+ tapBuilder.setDescription(input.getDescription());
+ tapBuilder.setOperation(Operations.PUT);
+ 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());
+ }
public ListenableFuture<RpcResult<Void>> deleteInterfaceFromNodes(DeleteInterfaceFromNodeInput input) {
- InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());\r
- return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),\r
- new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {\r
- InterfaceKey iKey = new InterfaceKey(input.getVppInterfaceName());\r
- if (!optIface.isPresent()) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(\r
- ErrorType.RPC,\r
- "Cannot delete interface " + iKey + " on node " + vppNodeIid\r
- + ". Not found or already deleted.")\r
- .build());\r
- }\r
- Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);\r
- WriteTransaction wTx = dataBroker.get().newWriteOnlyTransaction();\r
- wTx.delete(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getInterfaceIID(iKey));\r
- return Futures.transform(wTx.submit(), voidToRpcResult());\r
- }\r
- });\r
- }\r
-\r
- public ListenableFuture<RpcResult<Void>> addInterfaceToBridgeDomain(AddInterfaceToBridgeDomainInput input) {\r
- InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());\r
- return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),\r
- new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {\r
- InterfaceKey iKey = new InterfaceKey(input.getVppInterfaceName());\r
- if (!optIface.isPresent()) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(\r
- ErrorType.RPC,\r
- "Cannot add interface " + iKey + " to bridge domain on node "\r
- + vppNodeIid + ". Not found or deleted.")\r
- .build());\r
- }\r
- Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);\r
- return Futures.transform(interfaceManager.configureInterface(dataBroker.get(), iKey,\r
- input.getBridgeDomainId(), null), voidToRpcResult());\r
- }\r
- });\r
- }\r
-\r
- public ListenableFuture<RpcResult<Void>> delInterfaceFromBridgeDomain(DelInterfaceFromBridgeDomainInput input) {\r
- InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());\r
- return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),\r
- new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {\r
- if (!optIface.isPresent()) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(\r
- ErrorType.RPC,\r
- "Cannot remove interface " + input.getVppInterfaceName()\r
- + " from bridge domain on node " + vppNodeIid\r
- + ". Not found or deleted.")\r
- .build());\r
- }\r
- Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);\r
- return Futures.transform(interfaceManager.removeInterfaceFromBridgeDomain(dataBroker.get(),\r
- optIface.get().getKey()), voidToRpcResult());\r
- }\r
- });\r
- }\r
-\r
- private CheckedFuture<Optional<Interface>, ReadFailedException> readInterface(InstanceIdentifier<?> nodeIid,\r
- String interfaceName) {\r
- Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(nodeIid);\r
- if (!optDataBroker.isPresent()) {\r
- LOG.error("Cannot find data broker for node {}", nodeIid);\r
- return Futures.immediateCheckedFuture(Optional.absent());\r
- }\r
- ReadOnlyTransaction rwTx = optDataBroker.get().newReadOnlyTransaction();\r
- InterfaceKey iKey = new InterfaceKey(interfaceName);\r
- InstanceIdentifier<Interface> interfaceIID = VppIidFactory.getInterfaceIID(iKey);\r
- CheckedFuture<Optional<Interface>, ReadFailedException> readInterface = rwTx.read(\r
- LogicalDatastoreType.CONFIGURATION, interfaceIID);\r
- rwTx.close();\r
- return readInterface;\r
- }\r
-\r
- private AsyncFunction<Void, RpcResult<Void>> voidToRpcResult() {\r
- return new AsyncFunction<Void, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(Void input) throws Exception {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());\r
- }\r
- };\r
- }\r
-\r
- private AsyncFunction<List<Void>, RpcResult<Void>> voidsToRpcResult() {\r
- return new AsyncFunction<List<Void>, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(List<Void> input) throws Exception {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());\r
- }\r
- };\r
- }\r
-}\r
+ InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
+ return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),
+ new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {
+ InterfaceKey iKey = new InterfaceKey(input.getVppInterfaceName());
+ if (!optIface.isPresent()) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(
+ ErrorType.RPC,
+ "Cannot delete interface " + iKey + " on node " + vppNodeIid
+ + ". Not found or already deleted.")
+ .build());
+ }
+ Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
+ WriteTransaction wTx = dataBroker.get().newWriteOnlyTransaction();
+ wTx.delete(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getInterfaceIID(iKey));
+ return Futures.transform(wTx.submit(), voidToRpcResult());
+ }
+ });
+ }
+
+ public ListenableFuture<RpcResult<Void>> addInterfaceToBridgeDomain(AddInterfaceToBridgeDomainInput input) {
+ InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
+ return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),
+ new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {
+ InterfaceKey iKey = new InterfaceKey(input.getVppInterfaceName());
+ if (!optIface.isPresent()) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(
+ ErrorType.RPC,
+ "Cannot add interface " + iKey + " to bridge domain on node "
+ + vppNodeIid + ". Not found or deleted.")
+ .build());
+ }
+ Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
+ return Futures.transform(interfaceManager.configureInterface(dataBroker.get(), iKey,
+ input.getBridgeDomainId(), null), voidToRpcResult());
+ }
+ });
+ }
+
+ public ListenableFuture<RpcResult<Void>> delInterfaceFromBridgeDomain(DelInterfaceFromBridgeDomainInput input) {
+ InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
+ return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),
+ new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {
+ if (!optIface.isPresent()) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(
+ ErrorType.RPC,
+ "Cannot remove interface " + input.getVppInterfaceName()
+ + " from bridge domain on node " + vppNodeIid
+ + ". Not found or deleted.")
+ .build());
+ }
+ Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
+ return Futures.transform(interfaceManager.removeInterfaceFromBridgeDomain(dataBroker.get(),
+ optIface.get().getKey()), voidToRpcResult());
+ }
+ });
+ }
+
+ private CheckedFuture<Optional<Interface>, ReadFailedException> readInterface(InstanceIdentifier<?> nodeIid,
+ String interfaceName) {
+ Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(nodeIid);
+ if (!optDataBroker.isPresent()) {
+ LOG.error("Cannot find data broker for node {}", nodeIid);
+ return Futures.immediateCheckedFuture(Optional.absent());
+ }
+ ReadOnlyTransaction rwTx = optDataBroker.get().newReadOnlyTransaction();
+ InterfaceKey iKey = new InterfaceKey(interfaceName);
+ InstanceIdentifier<Interface> interfaceIID = VppIidFactory.getInterfaceIID(iKey);
+ CheckedFuture<Optional<Interface>, ReadFailedException> readInterface = rwTx.read(
+ LogicalDatastoreType.CONFIGURATION, interfaceIID);
+ rwTx.close();
+ return readInterface;
+ }
+
+ private AsyncFunction<Void, RpcResult<Void>> voidToRpcResult() {
+ return new AsyncFunction<Void, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(Void input) throws Exception {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ }
+ };
+ }
+
+ private AsyncFunction<List<Void>, RpcResult<Void>> voidsToRpcResult() {
+ return new AsyncFunction<List<Void>, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(List<Void> input) throws Exception {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ }
+ };
+ }
+}
Code Review / groupbasedpolicy.git / commitdiff