import javax.annotation.Nonnull;
+import org.opendaylight.controller.config.yang.config.vpp_provider.impl.VppRenderer;
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.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;
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.VppAdapterService;
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.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.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.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.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.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;
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 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 {
+public class VppRpcServiceImpl implements VppAdapterService, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(VppRpcServiceImpl.class);
private final InterfaceManager interfaceManager;
private final MountedDataBrokerProvider mountDataProvider;
- public VppRpcServiceImpl(@Nonnull DataBroker dataBroker, @Nonnull MountedDataBrokerProvider mountDataProvider,
- BridgeDomainManager bridgeDomainManager, InterfaceManager interfaceManager) {
+ public VppRpcServiceImpl(@Nonnull DataBroker dataBroker, @Nonnull VppRenderer renderer) {
this.dataBroker = dataBroker;
- this.bridgeDomainManager = bridgeDomainManager;
- this.interfaceManager = interfaceManager;
- this.mountDataProvider = mountDataProvider;
+ this.bridgeDomainManager = renderer.getBridgeDomainManager();
+ this.interfaceManager = renderer.getInterfaceManager();
+ this.mountDataProvider = renderer.getMountedDataBroker();
}
- public Future<RpcResult<Void>> createVirtualBridgeDomain(CreateVirtualBridgeDomainOnNodesInput input) {
+ public Future<RpcResult<Void>> createVirtualBridgeDomainOnNodes(CreateVirtualBridgeDomainOnNodesInput input) {
LOG.info("Processing a remote call for creating bridge domain {}", input.getId());
if (input.getTunnelType() == null) {
return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
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>> deleteVirtualBridgeDomain(DeleteVirtualBridgeDomainFromNodesInput input) {
+ public Future<RpcResult<Void>> deleteVirtualBridgeDomainFromNodes(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());
+ return Futures.transformAsync(Futures.allAsList(futures), voidsToRpcResult(), MoreExecutors.directExecutor());
}
- public ListenableFuture<RpcResult<Void>> cloneVirtualBridgeDomainOnNode(CloneVirtualBridgeDomainOnNodesInput input) {
+ public ListenableFuture<RpcResult<Void>> cloneVirtualBridgeDomainOnNodes(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),
+ return Futures.transformAsync(rTx.read(LogicalDatastoreType.CONFIGURATION, topologyIid),
new AsyncFunction<Optional<Topology>, RpcResult<Void>>() {
@Override
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>> createInterfaceOnNodes(CreateInterfaceOnNodeInput input) {
+ public ListenableFuture<RpcResult<Void>> createInterfaceOnNode(CreateInterfaceOnNodeInput input) {
LOG.info("Processing a remote call for creating interface {} on node {}", input.getVppInterfaceName(),
input.getVppNodeId());
InterfaceTypeChoice interfaceType = input.getInterfaceTypeChoice();
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>> deleteInterfaceFromNodes(DeleteInterfaceFromNodeInput input) {
+ 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
+ ". 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
+ 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
+ ". 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());
}
};
}
+
+ @Override
+ public void close() throws Exception {
+ // NOOP
+ }
}
Code Review / groupbasedpolicy.git / blobdiff