import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
+import java.util.concurrent.atomic.AtomicBoolean;
import javax.inject.Inject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.*;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.*;
private static String addressStr;
private static String portStr;
private static String connectionType;
- private static Boolean setup = false;
+ private static AtomicBoolean setup = new AtomicBoolean(false);
private static MdsalUtils mdsalUtils = null;
+ private static Southbound southbound = null;
private static final String NETVIRT = "org.opendaylight.ovsdb.openstack.net-virt";
private static final String NETVIRTPROVIDERS = "org.opendaylight.ovsdb.openstack.net-virt-providers";
@Before
public void setUp() throws InterruptedException {
- if (setup == true) {
+ if (setup.get()) {
LOG.info("Skipping setUp, already initialized");
return;
}
//dataBroker = getSession().getSALService(DataBroker.class);
//Thread.sleep(3000);
//dataBroker = OvsdbInventoryServiceImpl.getDataBroker();
- for (int i=0; i<10; i++) {
- dataBroker = org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils.getDatabroker();
- if (dataBroker == null) {
- LOG.warn("NetvirtIT: dataBroker is null");
- Thread.sleep(5000);
- continue;
- } else {
- break;
+ for (int i=0; i<20; i++) {
+ southbound = (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
+ if (southbound != null) {
+ dataBroker = southbound.getDatabroker();
+ if (dataBroker != null) {
+ break;
+ }
}
+ LOG.warn("NetvirtIT: dataBroker is null");
+ Thread.sleep(5000);
}
Assert.assertNotNull("dataBroker should not be null", dataBroker);
Thread.sleep(5000);
mdsalUtils = new MdsalUtils(dataBroker);
- setup = true;
+ setup.set(true);
}
/**
Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
}
+ @Ignore
@Test
public void testNetVirt2() throws InterruptedException {
Thread.sleep(60000);
@Test
public void testReadOvsdbTopologyNodes() throws InterruptedException {
Thread.sleep(10000);
- List<Node> ovsdbNodes = org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils.readOvsdbTopologyNodes();
+ List<Node> ovsdbNodes = southbound.readOvsdbTopologyNodes();
for (Node node : ovsdbNodes) {
LOG.info(">>>>> node: {}", node);
}
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.TransactionCommitFailedException;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.providers.NetvirtProvidersProvider;
import org.opendaylight.ovsdb.utils.mdsal.openflow.InstructionUtils;
import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
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 com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.CheckedFuture;
import java.util.List;
private DataBroker dataBroker = null;
// OSGi Services that we are dependent on.
private volatile PipelineOrchestrator orchestrator;
+ private volatile Southbound southbound;
// Concrete Service that this AbstractServiceInstance represents
private Service service;
this.dataBroker = NetvirtProvidersProvider.getDataBroker();
}
- protected void setOrchestrator(final ServiceReference ref, AbstractServiceInstance serviceInstance) {
+ protected void setDependencies(final ServiceReference ref, AbstractServiceInstance serviceInstance) {
this.orchestrator =
(PipelineOrchestrator) ServiceHelper.getGlobalInstance(PipelineOrchestrator.class, serviceInstance);
orchestrator.registerService(ref, serviceInstance);
+ this.southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, serviceInstance);
}
-
+
public boolean isBridgeInPipeline (Node node){
- String bridgeName = MdsalUtils.getBridgeName(node);
+ String bridgeName = southbound.getBridgeName(node);
if (bridgeName != null && Constants.INTEGRATION_BRIDGE.equals(bridgeName)) {
return true;
}
private Long getDpid(Node node) {
Long dpid = 0L;
- dpid = MdsalUtils.getDataPathId(node);
+ dpid = southbound.getDataPathId(node);
if (dpid == 0) {
logger.warn("getDpid: dpid not found: {}", node);
}
import org.opendaylight.neutron.spi.NeutronNetwork;
import org.opendaylight.ovsdb.openstack.netvirt.MdsalHelper;
import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
-import org.opendaylight.ovsdb.openstack.netvirt.api.*;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
+import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.ClassifierProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EgressAclProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.IngressAclProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.L2ForwardingProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.SecurityServicesManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
+import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
+import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
import org.opendaylight.ovsdb.openstack.netvirt.providers.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.providers.NetvirtProvidersProvider;
import org.opendaylight.ovsdb.utils.mdsal.openflow.InstructionUtils;
public static final String NAME = "OF13Provider";
private volatile NetworkingProviderManager networkingProviderManager;
private volatile BundleContext bundleContext;
+ private volatile Southbound southbound;
public OF13Provider() {
this.dataBroker = NetvirtProvidersProvider.getDataBroker();
String tunnelBridgeName = configurationService.getIntegrationBridgeName();
String portName = getTunnelName(tunnelType, dst);
logger.info("addTunnelPort enter: portName: {}", portName);
- if (MdsalUtils.extractTerminationPointAugmentation(node, portName) != null
- || MdsalUtils.isTunnelTerminationPointExist(node,tunnelBridgeName,portName)) {
+ if (southbound.extractTerminationPointAugmentation(node, portName) != null
+ || southbound.isTunnelTerminationPointExist(node, tunnelBridgeName, portName)) {
logger.info("Tunnel {} is present in {} of {}", portName, tunnelBridgeName, node.getNodeId().getValue());
return true;
}
options.put("local_ip", src.getHostAddress());
options.put("remote_ip", dst.getHostAddress());
- if (!MdsalUtils.addTunnelTerminationPoint(node, tunnelBridgeName, portName, tunnelType, options)) {
+ if (!southbound.addTunnelTerminationPoint(node, tunnelBridgeName, portName, tunnelType, options)) {
logger.error("Failed to insert Tunnel port {} in {}", portName, tunnelBridgeName);
return false;
}
- logger.info("addTunnelPort exit: portName: {}", portName);
+ logger.info("addTunnelPort exit: portName: {}", portName);
return true;
}
private boolean deletePort(Node node, String bridgeName, String portName) {
// TODO SB_MIGRATION
// might need to convert from ovsdb node to bridge node
- return MdsalUtils.deleteTerminationPoint(node, portName);
+ return southbound.deleteTerminationPoint(node, portName);
}
private boolean deleteTunnelPort(Node node, String tunnelType, InetAddress src, InetAddress dst) {
private Long getDpid(Node node) {
Long dpid = 0L;
- dpid = MdsalUtils.getDataPathId(node);
+ dpid = southbound.getDataPathId(node);
if (dpid == 0) {
logger.warn("getDpid: dpid not found: {}", node);
}
private Long getIntegrationBridgeOFDPID(Node node) {
Long dpid = 0L;
- if (MdsalUtils.getBridgeName(node).equals(configurationService.getIntegrationBridgeName())) {
+ if (southbound.getBridgeName(node).equals(configurationService.getIntegrationBridgeName())) {
dpid = getDpid(node);
}
return dpid;
private Long getExternalBridgeDpid(Node node) {
Long dpid = 0L;
- if (MdsalUtils.getBridgeName(node).equals(configurationService.getExternalBridgeName())) {
+ if (southbound.getBridgeName(node).equals(configurationService.getExternalBridgeName())) {
dpid = getDpid(node);
}
return dpid;
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
logger.info("programLocalRules: could not find ofPort");
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.warn("No AttachedMac seen in {}", intf);
return;
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
logger.info("removeLocalRules: could not find ofPort");
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.warn("No AttachedMac seen in {}", intf);
return;
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
logger.info("programTunnelRules: could not find ofPort");
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.warn("programTunnelRules: No AttachedMac seen in {}", intf);
return;
}
- List<OvsdbTerminationPointAugmentation> intfs = MdsalUtils.getTerminationPointsOfBridge(node);
+ List<OvsdbTerminationPointAugmentation> intfs = southbound.getTerminationPointsOfBridge(node);
for (OvsdbTerminationPointAugmentation tunIntf : intfs) {
if (tunIntf.getName().equals(getTunnelName(tunnelType, dst))) {
- long tunnelOFPort = MdsalUtils.getOFPort(tunIntf);
+ long tunnelOFPort = southbound.getOFPort(tunIntf);
if (tunnelOFPort == 0) {
logger.error("programTunnelRules: Could not Identify Tunnel port {} -> OF ({}) on {}",
tunIntf.getName(), tunnelOFPort, node);
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
logger.info("removeTunnelRules: could not find ofPort");
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.error("removeTunnelRules: No AttachedMac seen in {}", intf);
return;
}
- List<OvsdbTerminationPointAugmentation> intfs = MdsalUtils.getTerminationPointsOfBridge(node);
+ List<OvsdbTerminationPointAugmentation> intfs = southbound.getTerminationPointsOfBridge(node);
for (OvsdbTerminationPointAugmentation tunIntf : intfs) {
if (tunIntf.getName().equals(getTunnelName(tunnelType, dst))) {
- long tunnelOFPort = MdsalUtils.getOFPort(tunIntf);
+ long tunnelOFPort = southbound.getOFPort(tunIntf);
if (tunnelOFPort == -1) {
logger.error("Could not Identify Tunnel port {} -> OF ({}) on {}",
tunIntf.getName(), tunnelOFPort, node);
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
logger.debug("programVlanRules: could not find ofPort for {}", intf.getName());
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.debug("programVlanRules: No AttachedMac seen in {}", intf);
return;
String phyIfName =
bridgeConfigurationManager.getPhysicalInterfaceName(node, network.getProviderPhysicalNetwork());
- long ethOFPort = MdsalUtils.getOFPort(node, phyIfName);
+ long ethOFPort = southbound.getOFPort(node, phyIfName);
if (ethOFPort == 0) {
logger.warn("programVlanRules: could not find ofPort for physical port {}", phyIfName);
return;
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
logger.debug("removeVlanRules: programVlanRules: could not find ofPort for {}", intf.getName());
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.debug("removeVlanRules: No AttachedMac seen in {}", intf);
return;
String phyIfName =
bridgeConfigurationManager.getPhysicalInterfaceName(node, network.getProviderPhysicalNetwork());
- long ethOFPort = MdsalUtils.getOFPort(node, phyIfName);
+ long ethOFPort = southbound.getOFPort(node, phyIfName);
if (ethOFPort == 0) {
logger.warn("removeVlanRules: could not find ofPort for physical port {}", phyIfName);
return;
Preconditions.checkNotNull(nodeCacheManager);
Map<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId,Node> nodes =
nodeCacheManager.getOvsdbNodes();
- nodes.remove(MdsalUtils.extractBridgeOvsdbNodeId(srcNode));
+ nodes.remove(southbound.extractBridgeOvsdbNodeId(srcNode));
String networkType = network.getProviderNetworkType();
String segmentationId = network.getProviderSegmentationID();
- Node srcBridgeNode = MdsalUtils.getBridgeNode(srcNode,configurationService.getIntegrationBridgeName());
+ Node srcBridgeNode = southbound.getBridgeNode(srcNode, configurationService.getIntegrationBridgeName());
programLocalRules(networkType, network.getProviderSegmentationID(), srcBridgeNode, intf);
if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
InetAddress src = configurationService.getTunnelEndPoint(srcNode);
InetAddress dst = configurationService.getTunnelEndPoint(dstNode);
if ((src != null) && (dst != null)) {
- Node dstBridgeNode = MdsalUtils.getBridgeNode(dstNode,
+ Node dstBridgeNode = southbound.getBridgeNode(dstNode,
configurationService.getIntegrationBridgeName());
if (addTunnelPort(srcBridgeNode, networkType, src, dst)) {
programTunnelRules(networkType, segmentationId, dst, srcBridgeNode, intf, true);
private void triggerInterfaceUpdates(Node node) {
logger.debug("enter triggerInterfaceUpdates for {}", node.getNodeId());
- List<OvsdbTerminationPointAugmentation> ports = MdsalUtils.extractTerminationPointAugmentations(node);
+ List<OvsdbTerminationPointAugmentation> ports = southbound.extractTerminationPointAugmentations(node);
if (ports != null && !ports.isEmpty()) {
for (OvsdbTerminationPointAugmentation port : ports) {
NeutronNetwork neutronNetwork = tenantNetworkManager.getTenantNetwork(port);
OvsdbTerminationPointAugmentation intf, boolean isLastInstanceOnNode) {
Map<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId,Node> nodes =
nodeCacheManager.getOvsdbNodes();
- nodes.remove(MdsalUtils.extractBridgeOvsdbNodeId(srcNode));
+ nodes.remove(southbound.extractBridgeOvsdbNodeId(srcNode));
logger.info("Delete intf " + intf.getName() + " isLastInstanceOnNode " + isLastInstanceOnNode);
List<String> phyIfName = bridgeConfigurationManager.getAllPhysicalInterfaceNames(srcNode);
- if (MdsalUtils.isTunnel(intf)) {
+ if (southbound.isTunnel(intf)) {
// Delete tunnel port
try {
InetAddress src = InetAddress.getByName(
- MdsalUtils.getOptionsValue(intf.getOptions(), "local_ip"));
+ southbound.getOptionsValue(intf.getOptions(), "local_ip"));
InetAddress dst = InetAddress.getByName(
- MdsalUtils.getOptionsValue(intf.getOptions(), "remote_ip"));
+ southbound.getOptionsValue(intf.getOptions(), "remote_ip"));
deleteTunnelPort(srcNode,
MdsalHelper.createOvsdbInterfaceType(intf.getInterfaceType()),
src, dst);
+ intf.getName() + " on srcNode " + srcNode.getNodeId().getValue());
removeTunnelRules(tunnelType, network.getProviderSegmentationID(),
dst, srcNode, intf, true, isLastInstanceOnNode);
- Node dstBridgeNode = MdsalUtils.getBridgeNode(dstNode, Constants.INTEGRATION_BRIDGE);
+ Node dstBridgeNode = southbound.getBridgeNode(dstNode, Constants.INTEGRATION_BRIDGE);
if(dstBridgeNode != null){
logger.info("Remove tunnel rules for interface "
+ intf.getName() + " on dstNode " + dstNode.getNodeId().getValue());
}
private void initializeFlowRules(Node node, String bridgeName) {
- Long dpid = MdsalUtils.getDataPathId(node);
- String datapathId = MdsalUtils.getDatapathId(node);
+ Long dpid = southbound.getDataPathId(node);
+ String datapathId = southbound.getDatapathId(node);
logger.info("initializeFlowRules: bridgeName: {}, dpid: {} - {}",
bridgeName, dpid, datapathId);
@Override
public void initializeOFFlowRules(Node openflowNode) {
- String bridgeName = MdsalUtils.getBridgeName(openflowNode);
+ String bridgeName = southbound.getBridgeName(openflowNode);
logger.info("initializeOFFlowRules: bridgeName: {}", bridgeName);
if (bridgeName.equals(configurationService.getIntegrationBridgeName())) {
initializeFlowRules(openflowNode, configurationService.getIntegrationBridgeName());
(L2ForwardingProvider) ServiceHelper.getGlobalInstance(L2ForwardingProvider.class, this);
securityServicesManager =
(SecurityServicesManager) ServiceHelper.getGlobalInstance(SecurityServicesManager.class, this);
-
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
}
@Override
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheListener;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
Map<Service, AbstractServiceInstance> serviceRegistry = Maps.newConcurrentMap();
private volatile BlockingQueue<Node> queue;
private ExecutorService eventHandler;
+ private Southbound southbound;
public PipelineOrchestratorImpl() {
eventHandler = Executors.newSingleThreadExecutor();
AbstractServiceInstance serviceInstance = getServiceInstance(service);
//logger.info("pipeline: {} - {}", service, serviceInstance);
if (serviceInstance != null) {
- if (MdsalUtils.getBridge(node) != null) {
+ if (southbound.getBridge(node) != null) {
serviceInstance.programDefaultPipelineRule(node);
}
}
(NodeCacheManager) ServiceHelper.getGlobalInstance(NodeCacheManager.class, this);
nodeCacheManager.cacheListenerAdded(
bundleContext.getServiceReference(PipelineOrchestrator.class.getName()), this);
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
}
@Override
- public void setDependencies(Object impl) {
-
- }
+ public void setDependencies(Object impl) {}
}
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
import org.opendaylight.ovsdb.openstack.netvirt.api.ArpProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
-import org.opendaylight.ovsdb.openstack.netvirt.api.RoutingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
import org.opendaylight.ovsdb.openstack.netvirt.providers.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.Service;
import org.opendaylight.ovsdb.utils.mdsal.openflow.ActionUtils;
import org.opendaylight.ovsdb.utils.mdsal.openflow.MatchUtils;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(ArpProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(ArpProvider.class.getName()), this);
}
@Override
import java.math.BigInteger;
import java.util.List;
-import java.util.concurrent.Executors;
-import java.util.concurrent.LinkedBlockingQueue;
import org.opendaylight.ovsdb.openstack.netvirt.api.ClassifierProvider;
-import org.opendaylight.ovsdb.openstack.netvirt.api.RoutingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.providers.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.AbstractServiceInstance;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.Service;
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(ClassifierProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(ClassifierProvider.class.getName()), this);
}
@Override
import org.opendaylight.neutron.spi.NeutronSecurityRule;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
import org.opendaylight.ovsdb.openstack.netvirt.api.EgressAclProvider;
-import org.opendaylight.ovsdb.openstack.netvirt.api.RoutingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.providers.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.AbstractServiceInstance;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.Service;
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(EgressAclProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(EgressAclProvider.class.getName()), this);
}
@Override
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(InboundNatProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(InboundNatProvider.class.getName()), this);
}
@Override
import org.opendaylight.neutron.spi.NeutronSecurityGroup;
import org.opendaylight.neutron.spi.NeutronSecurityRule;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
-import org.opendaylight.ovsdb.openstack.netvirt.api.InboundNatProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.IngressAclProvider;
import org.opendaylight.ovsdb.openstack.netvirt.providers.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.AbstractServiceInstance;
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(IngressAclProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(IngressAclProvider.class.getName()), this);
}
@Override
import java.math.BigInteger;
import java.util.List;
-import org.opendaylight.ovsdb.openstack.netvirt.api.IngressAclProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.L2ForwardingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.providers.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.AbstractServiceInstance;
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(L2ForwardingProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(L2ForwardingProvider.class.getName()), this);
}
@Override
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(L2RewriteProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(L2RewriteProvider.class.getName()), this);
}
@Override
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
-import org.opendaylight.ovsdb.openstack.netvirt.api.L2ForwardingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.L3ForwardingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.Service;
import org.opendaylight.ovsdb.utils.mdsal.openflow.InstructionUtils;
import org.opendaylight.ovsdb.utils.mdsal.openflow.MatchUtils;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
import com.google.common.collect.Lists;
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(L3ForwardingProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(L3ForwardingProvider.class.getName()), this);
}
@Override
import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
-import org.opendaylight.ovsdb.openstack.netvirt.api.L3ForwardingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration.LoadBalancerPoolMember;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerProvider;
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(LoadBalancerProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(LoadBalancerProvider.class.getName()), this);
}
@Override
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
-import org.opendaylight.ovsdb.openstack.netvirt.api.L3ForwardingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.OutboundNatProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(OutboundNatProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(OutboundNatProvider.class.getName()), this);
}
@Override
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
-import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
-import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbInventoryListener;
import org.opendaylight.ovsdb.openstack.netvirt.api.RoutingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.providers.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.AbstractServiceInstance;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.OF13Provider;
-import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.PipelineOrchestrator;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.Service;
import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
import org.opendaylight.ovsdb.utils.mdsal.openflow.ActionUtils;
import org.opendaylight.ovsdb.utils.mdsal.openflow.MatchUtils;
-import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
- super.setOrchestrator(bundleContext.getServiceReference(RoutingProvider.class.getName()), this);
+ super.setDependencies(bundleContext.getServiceReference(RoutingProvider.class.getName()), this);
}
@Override
<snapshot>
<required-capabilities>
<capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding?module=opendaylight-md-sal-binding&revision=2013-10-28</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:southbound:impl?module=southbound-impl&revision=2014-12-10</capability>
<capability>urn:opendaylight:params:xml:ns:yang:netvirt:impl?module=netvirt-impl&revision=2015-05-13</capability>
</required-capabilities>
<configuration>
import java.util.Dictionary;
import java.util.Hashtable;
import java.util.List;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.*;
import org.opendaylight.ovsdb.openstack.netvirt.api.*;
registerService(context,
new String[]{MultiTenantAwareRouter.class.getName()}, null, openstackRouter);
+ Southbound southbound = new SouthboundImpl(providerContext.getSALService(DataBroker.class));
+ registerService(context,
+ new String[]{Southbound.class.getName()}, null, southbound);
+
Dictionary<String, Object> nodeCacheManagerProperties = new Hashtable<>();
nodeCacheManagerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.NODE);
NodeCacheManagerImpl nodeCacheManager = new NodeCacheManagerImpl();
import com.google.common.collect.ImmutableBiMap;
public class MdsalHelper {
- private static final Logger LOG = LoggerFactory.getLogger(MdsalUtils.class);
+ private static final Logger LOG = LoggerFactory.getLogger(MdsalHelper.class);
public static final TopologyId OVSDB_TOPOLOGY_ID = new TopologyId(new Uri("ovsdb:1"));
public static final String OVSDB_URI_PREFIX = "ovsdb";
public static final String BRIDGE_URI_PREFIX = "bridge";
import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
private volatile INeutronNetworkCRUD neutronNetworkCache;
private volatile NeutronL3Adapter neutronL3Adapter;
private volatile EventDispatcher eventDispatcher;
+ private volatile Southbound southbound;
/**
* Invoked when a network creation is requested
for (Node node : nodes) {
List<String> phyIfName = bridgeConfigurationManager.getAllPhysicalInterfaceNames(node);
try {
- List<OvsdbTerminationPointAugmentation> ports = MdsalUtils.getTerminationPointsOfBridge(node);
+ List<OvsdbTerminationPointAugmentation> ports = southbound.getTerminationPointsOfBridge(node);
for (OvsdbTerminationPointAugmentation port : ports) {
- if (MdsalUtils.isTunnel(port)) {
+ if (southbound.isTunnel(port)) {
logger.trace("Delete tunnel interface {}", port.getName());
- MdsalUtils.deleteTerminationPoint(node, port.getName());
+ southbound.deleteTerminationPoint(node, port.getName());
} else if (!phyIfName.isEmpty() && phyIfName.contains(port.getName())) {
logger.trace("Delete physical interface {}", port.getName());
- MdsalUtils.deleteTerminationPoint(node, port.getName());
+ southbound.deleteTerminationPoint(node, port.getName());
}
}
} catch (Exception e) {
(NodeCacheManager) ServiceHelper.getGlobalInstance(NodeCacheManager.class, this);
neutronL3Adapter =
(NeutronL3Adapter) ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, this);
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
eventDispatcher =
(EventDispatcher) ServiceHelper.getGlobalInstance(EventDispatcher.class, this);
eventDispatcher.eventHandlerAdded(
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
private volatile NodeCacheManager nodeCacheManager;
private volatile NeutronL3Adapter neutronL3Adapter;
private volatile EventDispatcher eventDispatcher;
+ private volatile Southbound southbound;
/**
* Invoked when a port creation is requested
List<Node> nodes = nodeCacheManager.getNodes();
for (Node node : nodes) {
try {
- List<OvsdbTerminationPointAugmentation> ports = MdsalUtils.getTerminationPointsOfBridge(node);
+ List<OvsdbTerminationPointAugmentation> ports = southbound.getTerminationPointsOfBridge(node);
for (OvsdbTerminationPointAugmentation port : ports) {
String neutronPortId =
- MdsalUtils.getInterfaceExternalIdsValue(port, Constants.EXTERNAL_ID_INTERFACE_ID);
+ southbound.getInterfaceExternalIdsValue(port, Constants.EXTERNAL_ID_INTERFACE_ID);
if (neutronPortId != null && neutronPortId.equalsIgnoreCase(neutronPort.getPortUUID())) {
logger.trace("neutronPortDeleted: Delete interface {}", port.getName());
- MdsalUtils.deleteTerminationPoint(node, port.getName());
+ southbound.deleteTerminationPoint(node, port.getName());
break;
}
}
(NodeCacheManager) ServiceHelper.getGlobalInstance(NodeCacheManager.class, this);
neutronL3Adapter =
(NeutronL3Adapter) ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, this);
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
eventDispatcher =
(EventDispatcher) ServiceHelper.getGlobalInstance(EventDispatcher.class, this);
eventDispatcher.eventHandlerAdded(
private volatile TenantNetworkManager tenantNetworkManager;
private volatile NetworkingProviderManager networkingProviderManager;
private volatile NeutronL3Adapter neutronL3Adapter;
- private volatile NodeCacheManager nodeCacheManager = null;
+ private volatile NodeCacheManager nodeCacheManager;
private volatile EventDispatcher eventDispatcher;
private volatile OvsdbInventoryService ovsdbInventoryService;
+ private volatile Southbound southbound;
private SouthboundEvent.Type ovsdbTypeToSouthboundEventType(OvsdbType ovsdbType) {
SouthboundEvent.Type type = SouthboundEvent.Type.NODE;
@Override
public void triggerUpdates() {
logger.info("triggerUpdates");
- List<Node> ovsdbNodes = MdsalUtils.readOvsdbTopologyNodes();
+ List<Node> ovsdbNodes = southbound.readOvsdbTopologyNodes();
for (Node node : ovsdbNodes) {
ovsdbUpdate(node, node.getAugmentation(OvsdbNodeAugmentation.class),
OvsdbInventoryListener.OvsdbType.NODE, Action.ADD);
logger.debug("Network {}: Delete interface {} attached to bridge {}", network.getNetworkUUID(),
ovsdbTerminationPointAugmentation.getInterfaceUuid(), node.getNodeId());
try {
- OvsdbBridgeAugmentation ovsdbBridgeAugmentation = MdsalUtils.getBridge(node);
+ OvsdbBridgeAugmentation ovsdbBridgeAugmentation = southbound.getBridge(node);
if (ovsdbBridgeAugmentation != null) {
List<TerminationPoint> terminationPoints = node.getTerminationPoint();
if (!terminationPoints.isEmpty()){
logger.info("notifyNode: action: {}, Node <{}>", action, node);
if (action.equals(Action.ADD)) {
- if (MdsalUtils.getBridge(node) != null) {
+ if (southbound.getBridge(node) != null) {
networkingProviderManager.getProvider(node).initializeOFFlowRules(node);
}
}
InstanceIdentifier<Node> bridgeNodeIid =
MdsalHelper.createInstanceIdentifier(ovsdbNode.getConnectionInfo(),
Constants.INTEGRATION_BRIDGE);
- MdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, bridgeNodeIid);
+ southbound.delete(LogicalDatastoreType.CONFIGURATION, bridgeNodeIid);
*/
}
logger.debug("processOpenVSwitchUpdate {}", node);
// TODO this node might be the OvsdbNode and not have termination points
// Would need to change listener or grab tp nodes in here.
- List<TerminationPoint> terminationPoints = MdsalUtils.extractTerminationPoints(node);
+ List<TerminationPoint> terminationPoints = southbound.extractTerminationPoints(node);
for (TerminationPoint terminationPoint : terminationPoints) {
processPortUpdate(node, terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class));
}
boolean rv = false;
String nodeIdStr = node.getNodeId().getValue();
String bridgeName = nodeIdStr.substring(nodeIdStr.lastIndexOf('/') + 1);
- List<TerminationPoint> terminationPoints = MdsalUtils.extractTerminationPoints(node);
+ List<TerminationPoint> terminationPoints = southbound.extractTerminationPoints(node);
if (terminationPoints != null && terminationPoints.size() == 1) {
}
- OvsdbTerminationPointAugmentation port = MdsalUtils.extractTerminationPointAugmentation(node, bridgeName);
+ OvsdbTerminationPointAugmentation port = southbound.extractTerminationPointAugmentation(node, bridgeName);
if (port != null) {
- String datapathId = MdsalUtils.getDatapathId(bridge);
+ String datapathId = southbound.getDatapathId(bridge);
// Having a datapathId means the ovsdb node has connected to ODL
if (datapathId != null) {
rv = true;
private void processBridgeCreate(Node node, OvsdbBridgeAugmentation bridge) {
logger.debug("processBridgeCreate <{}> <{}>", node, bridge);
- String datapathId = MdsalUtils.getDatapathId(bridge);
+ String datapathId = southbound.getDatapathId(bridge);
// Having a datapathId means the ovsdb node has connected to ODL
if (datapathId != null) {
nodeCacheManager.nodeAdded(node);
private void processBridgeUpdate(Node node, OvsdbBridgeAugmentation bridge) {
logger.debug("processBridgeUpdate <{}> <{}>", node, bridge);
- String datapathId = MdsalUtils.getDatapathId(bridge);
+ String datapathId = southbound.getDatapathId(bridge);
// Having a datapathId means the ovsdb node has connected to ODL
if (datapathId != null) {
nodeCacheManager.nodeAdded(node);
nodeCacheManager.nodeRemoved(node);
// TODO SB_MIGRATION
// Not sure if we want to do this yet
- MdsalUtils.deleteBridge(node);
+ southbound.deleteBridge(node);
}
@Override
bundleContext.getServiceReference(OvsdbInventoryListener.class.getName()), this);
neutronL3Adapter =
(NeutronL3Adapter) ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, this);
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
eventDispatcher =
(EventDispatcher) ServiceHelper.getGlobalInstance(EventDispatcher.class, this);
eventDispatcher.eventHandlerAdded(
--- /dev/null
+/*
+ * Copyright (c) 2015 Red Hat, 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.ovsdb.openstack.netvirt.api;
+
+import java.util.List;
+import java.util.Map;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
+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.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
+
+/**
+ * Utility class to wrap southbound transactions.
+ *
+ * @author Sam Hague (shague@redhat.com)
+ */
+public interface Southbound {
+ ConnectionInfo getConnectionInfo(Node node);
+ OvsdbNodeAugmentation extractOvsdbNode(Node node);
+ NodeId extractBridgeOvsdbNodeId(Node bridgeNode);
+ List<Node> readOvsdbTopologyNodes();
+ OvsdbNodeAugmentation readOvsdbNode(Node bridgeNode);
+ String getOvsdbNodeUUID(Node node);
+ String getOsdbNodeExternalIdsValue(OvsdbNodeAugmentation ovsdbNodeAugmentation, String key);
+ boolean addBridge(Node ovsdbNode, String bridgeName, String target);
+ boolean deleteBridge(Node ovsdbNode);
+ OvsdbBridgeAugmentation readBridge(Node node, String name);
+ Node readBridgeNode(Node node, String name);
+ Node getBridgeNode(Node node, String bridgeName);
+ String getBridgeUuid(Node node, String name);
+ long getDataPathId(Node node);
+ String getDatapathId(Node node);
+ String getDatapathId(OvsdbBridgeAugmentation ovsdbBridgeAugmentation);
+ OvsdbBridgeAugmentation getBridge(Node node, String name);
+ OvsdbBridgeAugmentation getBridge(Node node);
+ String getBridgeName(Node node);
+ String extractBridgeName(Node node);
+ OvsdbBridgeAugmentation extractBridgeAugmentation(Node node);
+ List<Node> getAllBridgesOnOvsdbNode(Node node);
+ OvsdbNodeAugmentation extractNodeAugmentation(Node node);
+ List<OvsdbTerminationPointAugmentation> getTerminationPointsOfBridge(Node node);
+ OvsdbTerminationPointAugmentation extractTerminationPointAugmentation(Node bridgeNode, String portName);
+ List<TerminationPoint> extractTerminationPoints(Node node);
+ List<OvsdbTerminationPointAugmentation> extractTerminationPointAugmentations(Node node);
+ List<OvsdbTerminationPointAugmentation> readTerminationPointAugmentations(Node node);
+ String getInterfaceExternalIdsValue(
+ OvsdbTerminationPointAugmentation terminationPointAugmentation, String key);
+ Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type);
+ Boolean deleteTerminationPoint(Node bridgeNode, String portName);
+ Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName,
+ String type, Map<String, String> options);
+ TerminationPoint readTerminationPoint(Node bridgeNode, String bridgeName, String portName);
+ Boolean addTunnelTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type,
+ Map<String, String> options);
+ Boolean isTunnelTerminationPointExist(Node bridgeNode, String bridgeName, String portName);
+ Boolean addPatchTerminationPoint(Node node, String bridgeName, String portName, String peerPortName);
+ String getExternalId(Node node, OvsdbTables table, String key);
+ String getOtherConfig(Node node, OvsdbTables table, String key);
+ boolean addVlanToTp(long vlan);
+ boolean isTunnel(OvsdbTerminationPointAugmentation port);
+ String getOptionsValue(List<Options> options, String key);
+ Topology getOvsdbTopology();
+ Long getOFPort(OvsdbTerminationPointAugmentation port);
+ Long getOFPort(Node bridgeNode, String portName);
+ DataBroker getDatabroker();
+}
import org.opendaylight.neutron.spi.NeutronNetwork;
import org.opendaylight.ovsdb.openstack.netvirt.ConfigInterface;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbTables;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.utils.config.ConfigProperties;
import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
// The implementation for each of these services is resolved by the OSGi Service Manager
private volatile ConfigurationService configurationService;
private volatile NetworkingProviderManager networkingProviderManager;
+ private volatile Southbound southbound;
public void setConfigurationService(ConfigurationService configurationService) {
this.configurationService = configurationService;
}
+ public void setSouthbound(Southbound southbound) {
+ this.southbound = southbound;
+ }
+
@Override
public String getBridgeUuid(Node node, String bridgeName) {
- return MdsalUtils.getBridgeUuid(node, bridgeName);
+ return southbound.getBridgeUuid(node, bridgeName);
}
@Override
public boolean isNodeNeutronReady(Node node) {
Preconditions.checkNotNull(configurationService);
- return MdsalUtils.getBridge(node, configurationService.getIntegrationBridgeName()) != null;
+ return southbound.getBridge(node, configurationService.getIntegrationBridgeName()) != null;
}
@Override
public boolean isNodeOverlayReady(Node node) {
Preconditions.checkNotNull(configurationService);
return isNodeNeutronReady(node)
- && MdsalUtils.getBridge(node, configurationService.getNetworkBridgeName()) != null;
+ && southbound.getBridge(node, configurationService.getNetworkBridgeName()) != null;
}
@Override
public boolean isPortOnBridge (Node node, String portName) {
- return MdsalUtils.extractTerminationPointAugmentation(node, portName) != null;
+ return southbound.extractTerminationPointAugmentation(node, portName) != null;
}
@Override
public boolean isNodeTunnelReady(Node node) {
Preconditions.checkNotNull(configurationService);
- return MdsalUtils.getBridge(node, configurationService.getIntegrationBridgeName()) != null;
+ return southbound.getBridge(node, configurationService.getIntegrationBridgeName()) != null;
}
@Override
Preconditions.checkNotNull(configurationService);
/* is br-int created */
- OvsdbBridgeAugmentation intBridge = MdsalUtils.getBridge(node, configurationService.getIntegrationBridgeName());
+ OvsdbBridgeAugmentation intBridge = southbound.getBridge(node, configurationService.getIntegrationBridgeName());
if (intBridge == null) {
LOGGER.trace("isNodeVlanReady: node: {}, br-int missing", node);
return false;
/* Check if physical device is added to br-int. */
String phyNetName = getPhysicalInterfaceName(node, network.getProviderPhysicalNetwork());
- if (MdsalUtils.extractTerminationPointAugmentation(node, phyNetName) == null) {
+ if (southbound.extractTerminationPointAugmentation(node, phyNetName) == null) {
LOGGER.trace("isNodeVlanReady: node: {}, eth missing", node);
return false;
}
@Override
public String getPhysicalInterfaceName (Node node, String physicalNetwork) {
String phyIf = null;
- String providerMaps = MdsalUtils.getOtherConfig(node, OvsdbTables.OPENVSWITCH,
+ String providerMaps = southbound.getOtherConfig(node, OvsdbTables.OPENVSWITCH,
configurationService.getProviderMappingsKey());
if (providerMaps == null) {
providerMaps = configurationService.getDefaultProviderMapping();
public List<String> getAllPhysicalInterfaceNames(Node node) {
List<String> phyIfName = Lists.newArrayList();
String phyIf = null;
- String providerMaps = MdsalUtils.getOtherConfig(node, OvsdbTables.OPENVSWITCH,
+ String providerMaps = southbound.getOtherConfig(node, OvsdbTables.OPENVSWITCH,
configurationService.getProviderMappingsKey());
if (providerMaps == null) {
providerMaps = configurationService.getDefaultProviderMapping();
private boolean addPortToBridge (Node node, String bridgeName, String portName) throws Exception {
boolean rv = true;
- if (MdsalUtils.extractTerminationPointAugmentation(node, portName) == null) {
- rv = MdsalUtils.addTerminationPoint(node, bridgeName, portName, null);
+ if (southbound.extractTerminationPointAugmentation(node, portName) == null) {
+ rv = southbound.addTerminationPoint(node, bridgeName, portName, null);
}
return rv;
private boolean addPatchPort (Node node, String bridgeName, String portName, String peerPortName) throws Exception {
boolean rv = true;
- if (MdsalUtils.extractTerminationPointAugmentation(node, portName) == null) {
- rv = MdsalUtils.addPatchTerminationPoint(node, bridgeName, portName, peerPortName);
+ if (southbound.extractTerminationPointAugmentation(node, portName) == null) {
+ rv = southbound.addPatchTerminationPoint(node, bridgeName, portName, peerPortName);
}
return rv;
private boolean addBridge(Node node, String bridgeName,
String localPatchName, String remotePatchName) throws Exception {
boolean rv = true;
- if (MdsalUtils.getBridge(node, bridgeName) == null) {
- rv = MdsalUtils.addBridge(node, bridgeName, getControllerTarget(node));
+ if (southbound.getBridge(node, bridgeName) == null) {
+ rv = southbound.addBridge(node, bridgeName, getControllerTarget(node));
}
return rv;
}
private String getControllerTarget(Node node) {
String target = null;
- OvsdbNodeAugmentation ovsdbNodeAugmentation = MdsalUtils.extractOvsdbNode(node);
+ OvsdbNodeAugmentation ovsdbNodeAugmentation = southbound.extractOvsdbNode(node);
if (ovsdbNodeAugmentation != null) {
ConnectionInfo connectionInfo = ovsdbNodeAugmentation.getConnectionInfo();
String addressStr = new String(connectionInfo.getLocalIp().getValue());
(ConfigurationService) ServiceHelper.getGlobalInstance(ConfigurationService.class, this);
networkingProviderManager =
(NetworkingProviderManager) ServiceHelper.getGlobalInstance(NetworkingProviderManager.class, this);
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
}
@Override
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.opendaylight.ovsdb.openstack.netvirt.ConfigInterface;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbTables;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.utils.config.ConfigProperties;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
private Map<Pair<String, String>, String> patchPortNames = Maps.newHashMap();
private String providerMappingsKey;
private String providerMapping;
+ private Southbound southbound;
public ConfigurationServiceImpl() {
tunnelEndpointKey = Constants.TUNNEL_ENDPOINT_KEY;
@Override
public InetAddress getTunnelEndPoint(Node node) {
InetAddress address = null;
- String tunnelEndpoint = MdsalUtils.getOtherConfig(node, OvsdbTables.OPENVSWITCH, tunnelEndpointKey);
+ String tunnelEndpoint = southbound.getOtherConfig(node, OvsdbTables.OPENVSWITCH, tunnelEndpointKey);
if (tunnelEndpoint != null) {
try {
address = InetAddress.getByName(tunnelEndpoint);
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
}
@Override
--- /dev/null
+package org.opendaylight.ovsdb.openstack.netvirt.impl;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+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.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MdsalUtils {
+ private static final Logger LOG = LoggerFactory.getLogger(MdsalUtils.class);
+ private DataBroker databroker = null;
+
+ /**
+ * Class constructor setting the data broker.
+ *
+ * @param dataBroker the {@link org.opendaylight.controller.md.sal.binding.api.DataBroker}
+ */
+ public MdsalUtils(DataBroker dataBroker) {
+ this.databroker = dataBroker;
+ }
+
+ /**
+ * Executes delete as a blocking transaction.
+ *
+ * @param store {@link LogicalDatastoreType} which should be modified
+ * @param path {@link InstanceIdentifier} to read from
+ * @param <D> the data object type
+ * @return the result of the request
+ */
+ public <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean delete(
+ final LogicalDatastoreType store, final InstanceIdentifier<D> path) {
+ boolean result = false;
+ final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
+ transaction.delete(store, path);
+ CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
+ try {
+ future.checkedGet();
+ result = true;
+ } catch (TransactionCommitFailedException e) {
+ LOG.warn("Failed to delete {} ", path, e);
+ }
+ return result;
+ }
+
+ /**
+ * Executes merge as a blocking transaction.
+ *
+ * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
+ * @param path {@link InstanceIdentifier} for path to read
+ * @param <D> the data object type
+ * @return the result of the request
+ */
+ public <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean merge(
+ final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
+ boolean result = false;
+ final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
+ transaction.merge(logicalDatastoreType, path, data, true);
+ CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
+ try {
+ future.checkedGet();
+ result = true;
+ } catch (TransactionCommitFailedException e) {
+ LOG.warn("Failed to merge {} ", path, e);
+ }
+ return result;
+ }
+
+ /**
+ * Executes put as a blocking transaction.
+ *
+ * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
+ * @param path {@link InstanceIdentifier} for path to read
+ * @param <D> the data object type
+ * @return the result of the request
+ */
+ public <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean put(
+ final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
+ boolean result = false;
+ final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
+ transaction.put(logicalDatastoreType, path, data, true);
+ CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
+ try {
+ future.checkedGet();
+ result = true;
+ } catch (TransactionCommitFailedException e) {
+ LOG.warn("Failed to put {} ", path, e);
+ }
+ return result;
+ }
+
+ /**
+ * Executes read as a blocking transaction.
+ *
+ * @param store {@link LogicalDatastoreType} to read
+ * @param path {@link InstanceIdentifier} for path to read
+ * @param <D> the data object type
+ * @return the result as the data object requested
+ */
+ public <D extends org.opendaylight.yangtools.yang.binding.DataObject> D read(
+ final LogicalDatastoreType store, final InstanceIdentifier<D> path) {
+ D result = null;
+ final ReadOnlyTransaction transaction = databroker.newReadOnlyTransaction();
+ Optional<D> optionalDataObject;
+ CheckedFuture<Optional<D>, ReadFailedException> future = transaction.read(store, path);
+ try {
+ optionalDataObject = future.checkedGet();
+ if (optionalDataObject.isPresent()) {
+ result = optionalDataObject.get();
+ } else {
+ LOG.debug("{}: Failed to read {}",
+ Thread.currentThread().getStackTrace()[1], path);
+ }
+ } catch (ReadFailedException e) {
+ LOG.warn("Failed to read {} ", path, e);
+ }
+ transaction.close();
+ return result;
+ }
+}
import org.opendaylight.neutron.spi.NeutronRouter_Interface;
import org.opendaylight.neutron.spi.NeutronSubnet;
import org.opendaylight.neutron.spi.Neutron_IPs;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.api.*;
import org.opendaylight.ovsdb.utils.config.ConfigProperties;
private Map<String, String> networkIdToRouterMacCache;
private Map<String, NeutronRouter_Interface> subnetIdToRouterInterfaceCache;
private Boolean enabled = false;
+ private Southbound southbound;
public NeutronL3Adapter() {
logger.info(">>>>>> NeutronL3Adapter constructor {}", this.getClass());
private Long getDpidForIntegrationBridge(Node node) {
// Check if node is integration bridge; and only then return its dpid
- if (MdsalUtils.getBridge(node, configurationService.getIntegrationBridgeName()) != null) {
- return MdsalUtils.getDataPathId(node);
+ if (southbound.getBridge(node, configurationService.getIntegrationBridgeName()) != null) {
+ return southbound.getDataPathId(node);
}
return null;
}
(L3ForwardingProvider) ServiceHelper.getGlobalInstance(L3ForwardingProvider.class, this);
nodeCacheManager =
(NodeCacheManager) ServiceHelper.getGlobalInstance(NodeCacheManager.class, this);
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
}
@Override
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.ovsdb.openstack.netvirt.AbstractEvent;
import org.opendaylight.ovsdb.openstack.netvirt.AbstractHandler;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.NodeCacheManagerEvent;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheListener;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
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.network.topology.topology.Node;
private final Object nodeCacheLock = new Object();
private Map<NodeId, Node> nodeCache = new ConcurrentHashMap<>();
private Map<Long, NodeCacheListener> handlers = Maps.newHashMap();
- private EventDispatcher eventDispatcher;
+ private volatile EventDispatcher eventDispatcher;
+ private volatile Southbound southbound;
@Override
public void nodeAdded(Node node) {
logger.debug("processNodeUpdate: {} Node type {} {}: {}",
nodeCache.size(),
- MdsalUtils.getBridge(node) != null ? "BridgeNode" : "OvsdbNode",
+ southbound.getBridge(node) != null ? "BridgeNode" : "OvsdbNode",
action == Action.ADD ? "ADD" : "UPDATE",
node);
public Map<NodeId,Node> getOvsdbNodes() {
Map<NodeId,Node> ovsdbNodesMap = new ConcurrentHashMap<NodeId,Node>();
for (Map.Entry<NodeId, Node> ovsdbNodeEntry : nodeCache.entrySet()) {
- if (MdsalUtils.extractOvsdbNode(ovsdbNodeEntry.getValue()) != null) {
+ if (southbound.extractOvsdbNode(ovsdbNodeEntry.getValue()) != null) {
ovsdbNodesMap.put(ovsdbNodeEntry.getKey(), ovsdbNodeEntry.getValue());
}
}
public List<Node> getBridgeNodes() {
List<Node> nodes = Lists.newArrayList();
for (Node node : nodeCache.values()) {
- if (MdsalUtils.getBridge(node) != null) {
+ if (southbound.getBridge(node) != null) {
nodes.add(node);
}
}
@Override
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
eventDispatcher =
(EventDispatcher) ServiceHelper.getGlobalInstance(EventDispatcher.class, this);
eventDispatcher.eventHandlerAdded(
private ListenerRegistration<DataChangeListener> registration;
private final ExecutorService executorService = Executors.newFixedThreadPool(1);
-
public OvsdbDataChangeListener (DataBroker dataBroker) {
this.dataBroker = dataBroker;
}
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbInventoryService;
import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbInventoryListener;
private static DataBroker dataBroker = null;
private static Set<OvsdbInventoryListener> mdsalConsumerListeners = Sets.newCopyOnWriteArraySet();
private OvsdbDataChangeListener ovsdbDataChangeListener = null;
- private static MdsalUtils mdsalUtils = null;
- private volatile BindingAwareBroker broker; // dependency injection
- //private ConsumerContext consumerContext = null;
+ //private static SouthboundImpl southboundImpl = null;
+ private volatile BindingAwareBroker broker;
public OvsdbInventoryServiceImpl(ProviderContext providerContext) {
dataBroker = providerContext.getSALService(DataBroker.class);
LOG.info("netvirt MdsalConsumer initialized");
ovsdbDataChangeListener = new OvsdbDataChangeListener(dataBroker);
- mdsalUtils = new MdsalUtils(dataBroker);
+ //southboundImpl = new SouthboundImpl(dataBroker);
}
- /*void init(Component c) {
- LOG.info(">>>>> init OvsdbInventoryServiceImpl");
- LOG.info(">>>>> Netvirt Provider Registered with MD-SAL");
- broker.registerConsumer(this, c.getDependencyManager().getBundleContext());
- }
-
- void start() {
- LOG.info(">>>>> start OvsdbInventoryServiceImpl");
- }
-
- void destroy() {
- // Now lets close MDSAL session
- if (this.consumerContext != null) {
- //this.consumerContext.close();
- this.dataBroker = null;
- this.consumerContext = null;
- }
- }
- @Override
- public void onSessionInitialized (ConsumerContext consumerContext) {
- this.consumerContext = consumerContext;
- dataBroker = consumerContext.getSALService(DataBroker.class);
- LOG.info("netvirt MdsalConsumer initialized");
- ovsdbDataChangeListener = new OvsdbDataChangeListener(dataBroker);
- mdsalUtils = new MdsalUtils(dataBroker);
- }*/
-
- //@Override
- /*public static DataBroker getDataBroker() {
- return dataBroker;
- }*/
-
@Override
public void listenerAdded(OvsdbInventoryListener listener) {
mdsalConsumerListeners.add(listener);
import org.opendaylight.neutron.spi.INeutronPortCRUD;
import org.opendaylight.neutron.spi.NeutronPort;
import org.opendaylight.neutron.spi.NeutronSecurityGroup;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.ConfigInterface;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
import org.opendaylight.ovsdb.openstack.netvirt.api.SecurityServicesManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.*;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
public class SecurityServicesImpl implements ConfigInterface, SecurityServicesManager {
static final Logger logger = LoggerFactory.getLogger(TenantNetworkManagerImpl.class);
private volatile INeutronPortCRUD neutronPortCache;
+ private volatile Southbound southbound;
/**
* Is security group ready.
return false;
}
logger.trace("isPortSecurityReady for {}", terminationPointAugmentation.getName());
- String neutronPortId = MdsalUtils.getInterfaceExternalIdsValue(terminationPointAugmentation,
+ String neutronPortId = southbound.getInterfaceExternalIdsValue(terminationPointAugmentation,
Constants.EXTERNAL_ID_INTERFACE_ID);
if (neutronPortId == null) {
return false;
neutronPortId);
return false;
}
- String vmPort = MdsalUtils.getInterfaceExternalIdsValue(terminationPointAugmentation,
+ String vmPort = southbound.getInterfaceExternalIdsValue(terminationPointAugmentation,
Constants.EXTERNAL_ID_VM_MAC);
logger.debug("Security Group Check {} DOES contain a Neutron Security Group", neutronPortId);
return true;
return null;
}
logger.trace("isPortSecurityReady for {}", terminationPointAugmentation.getName());
- String neutronPortId = MdsalUtils.getInterfaceExternalIdsValue(terminationPointAugmentation,
+ String neutronPortId = southbound.getInterfaceExternalIdsValue(terminationPointAugmentation,
Constants.EXTERNAL_ID_INTERFACE_ID);
if (neutronPortId == null) {
return null;
}
@Override
- public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {}
+ public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
+ }
@Override
public void setDependencies(Object impl) {
* 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.ovsdb.openstack.netvirt;
+package org.opendaylight.ovsdb.openstack.netvirt.impl;
import java.math.BigInteger;
import java.security.InvalidParameterException;
import java.util.Map;
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.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.ovsdb.openstack.netvirt.MdsalHelper;
+import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbTables;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableBiMap;
-import com.google.common.util.concurrent.CheckedFuture;
/**
* Utility class to wrap mdsal transactions.
*
* @author Sam Hague (shague@redhat.com)
*/
-public class MdsalUtils {
- private static final Logger LOG = LoggerFactory.getLogger(MdsalUtils.class);
-
- public static DataBroker getDatabroker() {
- return databroker;
- }
-
- private static DataBroker databroker = null;
- private static final int OVSDB_UPDATE_TIMEOUT = 500;
+public class SouthboundImpl implements Southbound {
+ private static final Logger LOG = LoggerFactory.getLogger(SouthboundImpl.class);
+ private DataBroker databroker = null;
private static final String PATCH_PORT_TYPE = "patch";
+ private MdsalUtils mdsalUtils = null;
/**
* Class constructor setting the data broker.
*
* @param dataBroker the {@link org.opendaylight.controller.md.sal.binding.api.DataBroker}
*/
- public MdsalUtils(DataBroker dataBroker) {
+ public SouthboundImpl(DataBroker dataBroker) {
this.databroker = dataBroker;
+ mdsalUtils = new MdsalUtils(dataBroker);
}
- /**
- * Executes delete as a blocking transaction.
- *
- * @param store {@link LogicalDatastoreType} which should be modified
- * @param path {@link InstanceIdentifier} to read from
- * @param <D> the data object type
- * @return the result of the request
- */
- public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean delete(
- final LogicalDatastoreType store, final InstanceIdentifier<D> path) {
- boolean result = false;
- final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
- transaction.delete(store, path);
- CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
- try {
- future.checkedGet();
- result = true;
- } catch (TransactionCommitFailedException e) {
- LOG.warn("Failed to delete {} ", path, e);
- }
- return result;
- }
-
- /**
- * Executes merge as a blocking transaction.
- *
- * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
- * @param path {@link InstanceIdentifier} for path to read
- * @param <D> the data object type
- * @return the result of the request
- */
- public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean merge(
- final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
- boolean result = false;
- final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
- transaction.merge(logicalDatastoreType, path, data, true);
- CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
- try {
- future.checkedGet();
- result = true;
- } catch (TransactionCommitFailedException e) {
- LOG.warn("Failed to merge {} ", path, e);
- }
- return result;
- }
-
- /**
- * Executes put as a blocking transaction.
- *
- * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
- * @param path {@link InstanceIdentifier} for path to read
- * @param <D> the data object type
- * @return the result of the request
- */
- public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean put(
- final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
- boolean result = false;
- final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
- transaction.put(logicalDatastoreType, path, data, true);
- CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
- try {
- future.checkedGet();
- result = true;
- } catch (TransactionCommitFailedException e) {
- LOG.warn("Failed to put {} ", path, e);
- }
- return result;
- }
-
- /**
- * Executes read as a blocking transaction.
- *
- * @param store {@link LogicalDatastoreType} to read
- * @param path {@link InstanceIdentifier} for path to read
- * @param <D> the data object type
- * @return the result as the data object requested
- */
- public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> D read(
- final LogicalDatastoreType store, final InstanceIdentifier<D> path) {
- D result = null;
- final ReadOnlyTransaction transaction = databroker.newReadOnlyTransaction();
- Optional<D> optionalDataObject;
- CheckedFuture<Optional<D>, ReadFailedException> future = transaction.read(store, path);
- try {
- optionalDataObject = future.checkedGet();
- if (optionalDataObject.isPresent()) {
- result = optionalDataObject.get();
- } else {
- LOG.debug("{}: Failed to read {}",
- Thread.currentThread().getStackTrace()[1], path);
- }
- } catch (ReadFailedException e) {
- LOG.warn("Failed to read {} ", path, e);
- }
- transaction.close();
- return result;
+ public DataBroker getDatabroker() {
+ return databroker;
}
- public static ConnectionInfo getConnectionInfo(Node node) {
+ public ConnectionInfo getConnectionInfo(Node node) {
ConnectionInfo connectionInfo = null;
OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
if (ovsdbNodeAugmentation != null) {
return connectionInfo;
}
- public static OvsdbNodeAugmentation extractOvsdbNode(Node node) {
+ public OvsdbNodeAugmentation extractOvsdbNode(Node node) {
return node.getAugmentation(OvsdbNodeAugmentation.class);
}
- public static NodeId extractBridgeOvsdbNodeId(Node bridgeNode) {
+ public NodeId extractBridgeOvsdbNodeId(Node bridgeNode) {
NodeId ovsdbNodeId = null;
OvsdbBridgeAugmentation bridgeAugmentation = extractBridgeAugmentation(bridgeNode);
if (bridgeAugmentation != null) {
return ovsdbNodeId;
}
- public static List<Node> readOvsdbTopologyNodes() {
+ public List<Node> readOvsdbTopologyNodes() {
List<Node> ovsdbNodes = new ArrayList<>();
InstanceIdentifier<Topology> topologyInstanceIdentifier = MdsalHelper.createInstanceIdentifier();
- Topology topology = read(LogicalDatastoreType.OPERATIONAL, topologyInstanceIdentifier);
+ Topology topology = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, topologyInstanceIdentifier);
if (topology != null && topology.getNode() != null) {
for (Node node : topology.getNode()) {
OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
return ovsdbNodes;
}
- public static OvsdbNodeAugmentation readOvsdbNode(Node bridgeNode) {
+ public OvsdbNodeAugmentation readOvsdbNode(Node bridgeNode) {
OvsdbNodeAugmentation nodeAugmentation = null;
OvsdbBridgeAugmentation bridgeAugmentation = extractBridgeAugmentation(bridgeNode);
if(bridgeAugmentation != null){
InstanceIdentifier<Node> ovsdbNodeIid =
(InstanceIdentifier<Node>) bridgeAugmentation.getManagedBy().getValue();
- Node node = read(LogicalDatastoreType.OPERATIONAL, ovsdbNodeIid);
+ Node node = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, ovsdbNodeIid);
if (node != null){
nodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
LOG.debug("readOvsdbNode: Ovsdb node {} found that manages bridge {}",
return nodeAugmentation;
}
- public static String getOvsdbNodeUUID(Node node) {
+ public String getOvsdbNodeUUID(Node node) {
String nodeUUID = null;
OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
if (ovsdbNodeAugmentation != null) {
return nodeUUID;
}
- public static String getOsdbNodeExternalIdsValue(OvsdbNodeAugmentation ovsdbNodeAugmentation, String key) {
+ public String getOsdbNodeExternalIdsValue(OvsdbNodeAugmentation ovsdbNodeAugmentation, String key) {
String value = null;
List<OpenvswitchExternalIds> pairs = ovsdbNodeAugmentation.getOpenvswitchExternalIds();
if (pairs != null && !pairs.isEmpty()) {
return value;
}
- public static boolean addBridge(Node ovsdbNode, String bridgeName, String target)
- throws InterruptedException, InvalidParameterException {
+ public boolean addBridge(Node ovsdbNode, String bridgeName, String target) throws InvalidParameterException {
boolean result = false;
LOG.info("addBridge: node: {}, bridgeName: {}, target: {}", ovsdbNode, bridgeName, target);
setManagedByForBridge(ovsdbBridgeAugmentationBuilder, ovsdbNode.getKey());
bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
- result = put(LogicalDatastoreType.CONFIGURATION, bridgeIid, bridgeNodeBuilder.build());
+ result = mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, bridgeIid, bridgeNodeBuilder.build());
LOG.info("addBridge: result: {}", result);
} else {
throw new InvalidParameterException("Could not find ConnectionInfo");
return result;
}
- public static boolean deleteBridge(Node ovsdbNode) {
+ public boolean deleteBridge(Node ovsdbNode) {
boolean result = false;
InstanceIdentifier<Node> bridgeIid =
MdsalHelper.createInstanceIdentifier(ovsdbNode.getNodeId());
- result = delete(LogicalDatastoreType.CONFIGURATION, bridgeIid);
+ result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, bridgeIid);
LOG.info("deleteBridge node: {}, bridgeName: {} result : {}", ovsdbNode, ovsdbNode.getNodeId(),result);
return result;
}
- public static OvsdbBridgeAugmentation readBridge(Node node, String name) {
+ public OvsdbBridgeAugmentation readBridge(Node node, String name) {
OvsdbBridgeAugmentation ovsdbBridgeAugmentation = null;
ConnectionInfo connectionInfo = getConnectionInfo(node);
if (connectionInfo != null) {
InstanceIdentifier<Node> bridgeIid =
- MdsalHelper.createInstanceIdentifier(node.getKey(), name);
- Node bridgeNode = read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
+ MdsalHelper.createInstanceIdentifier(node.getKey(), name);
+ Node bridgeNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
if (bridgeNode != null) {
ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
}
return ovsdbBridgeAugmentation;
}
- public static Node readBridgeNode(Node node, String name) {
+ public Node readBridgeNode(Node node, String name) {
Node bridgeNode = null;
ConnectionInfo connectionInfo = getConnectionInfo(node);
if (connectionInfo != null) {
InstanceIdentifier<Node> bridgeIid =
- MdsalHelper.createInstanceIdentifier(node.getKey(), name);
- bridgeNode = read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
+ MdsalHelper.createInstanceIdentifier(node.getKey(), name);
+ bridgeNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
}
return bridgeNode;
}
- public static Node getBridgeNode(Node node, String bridgeName) {
+ public Node getBridgeNode(Node node, String bridgeName) {
Node bridgeNode = null;
OvsdbBridgeAugmentation bridge = extractBridgeAugmentation(node);
if (bridge != null) {
return bridgeNode;
}
- public static String getBridgeUuid(Node node, String name) {
+ public String getBridgeUuid(Node node, String name) {
String uuid = null;
OvsdbBridgeAugmentation ovsdbBridgeAugmentation = readBridge(node, name);
if (ovsdbBridgeAugmentation != null) {
return uuid;
}
- private static void setManagedByForBridge(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder,
- NodeKey ovsdbNodeKey) {
- InstanceIdentifier<Node> connectionNodePath = MdsalHelper.createInstanceIdentifier(ovsdbNodeKey.getNodeId());
+ private void setManagedByForBridge(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder,
+ NodeKey ovsdbNodeKey) {
+ InstanceIdentifier<Node> connectionNodePath = MdsalHelper.createInstanceIdentifier(ovsdbNodeKey.getNodeId());
ovsdbBridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(connectionNodePath));
}
- private static void setControllerForBridge(Node ovsdbNode, String bridgeName, String targetString) {
+ private void setControllerForBridge(Node ovsdbNode, String bridgeName, String targetString) {
ConnectionInfo connectionInfo = getConnectionInfo(ovsdbNode);
if (connectionInfo != null) {
for (ControllerEntry controllerEntry: createControllerEntries(targetString)) {
.augmentation(OvsdbBridgeAugmentation.class)
.child(ControllerEntry.class, controllerEntry.getKey());
- boolean result = put(LogicalDatastoreType.CONFIGURATION, iid, controllerEntry);
+ boolean result = mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, iid, controllerEntry);
LOG.info("addController: result: {}", result);
}
}
}
- private static List<ControllerEntry> createControllerEntries(String targetString) {
+ private List<ControllerEntry> createControllerEntries(String targetString) {
List<ControllerEntry> controllerEntries = new ArrayList<ControllerEntry>();
ControllerEntryBuilder controllerEntryBuilder = new ControllerEntryBuilder();
controllerEntryBuilder.setTarget(new Uri(targetString));
return controllerEntries;
}
- private
static List<ProtocolEntry> createMdsalProtocols() {
+ private List<ProtocolEntry> createMdsalProtocols() {
List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
MdsalHelper.OVSDB_PROTOCOL_MAP.inverse();
return protocolList;
}
- public static long getDataPathId(Node node) {
+ public long getDataPathId(Node node) {
long dpid = 0L;
String datapathId = getDatapathId(node);
if (datapathId != null) {
return dpid;
}
- public static String getDatapathId(Node node) {
+ public String getDatapathId(Node node) {
String datapathId = null;
OvsdbBridgeAugmentation ovsdbBridgeAugmentation = node.getAugmentation(OvsdbBridgeAugmentation.class);
if (ovsdbBridgeAugmentation != null && ovsdbBridgeAugmentation.getDatapathId() != null) {
return datapathId;
}
- public static String getDatapathId(OvsdbBridgeAugmentation ovsdbBridgeAugmentation) {
+ public String getDatapathId(OvsdbBridgeAugmentation ovsdbBridgeAugmentation) {
String datapathId = null;
if (ovsdbBridgeAugmentation != null && ovsdbBridgeAugmentation.getDatapathId() != null) {
datapathId = ovsdbBridgeAugmentation.getDatapathId().getValue();
return datapathId;
}
- public static OvsdbBridgeAugmentation getBridge(Node node, String name) {
+ public OvsdbBridgeAugmentation getBridge(Node node, String name) {
OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
if (bridge != null) {
if (!bridge.getBridgeName().getValue().equals(name)) {
return bridge;
}
- public static OvsdbBridgeAugmentation getBridge(Node node) {
+ public OvsdbBridgeAugmentation getBridge(Node node) {
OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
return bridge;
}
- public static String getBridgeName(Node node) {
+ public String getBridgeName(Node node) {
String bridgeName = null;
OvsdbBridgeAugmentation bridge = getBridge(node);
if (bridge != null) {
return bridgeName;
}
- public static String extractBridgeName(Node node) {
+ public String extractBridgeName(Node node) {
return (node.getAugmentation(OvsdbBridgeAugmentation.class).getBridgeName().getValue());
}
- public static OvsdbBridgeAugmentation extractBridgeAugmentation(Node node) {
+ public OvsdbBridgeAugmentation extractBridgeAugmentation(Node node) {
return node.getAugmentation(OvsdbBridgeAugmentation.class);
}
- public static List<Node> getAllBridgesOnOvsdbNode(Node node) {
+ public List<Node> getAllBridgesOnOvsdbNode(Node node) {
List<Node> nodes = new ArrayList<Node>();
List<ManagedNodeEntry> managedNodes = node.getAugmentation(OvsdbNodeAugmentation.class).getManagedNodeEntry();
for (ManagedNodeEntry managedNode : managedNodes) {
InstanceIdentifier<?> bridgeIid = managedNode.getBridgeRef().getValue();
- Node bridgeNode = (Node) read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
+ Node bridgeNode = (Node) mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
if (bridgeNode != null) {
nodes.add(bridgeNode);
}
return nodes;
}
- public static OvsdbNodeAugmentation extractNodeAugmentation(Node node) {
+ public OvsdbNodeAugmentation extractNodeAugmentation(Node node) {
return node.getAugmentation(OvsdbNodeAugmentation.class);
}
* @param node
* @return
*/
- public static List<OvsdbTerminationPointAugmentation> getTerminationPointsOfBridge(Node node) {
+ public List<OvsdbTerminationPointAugmentation> getTerminationPointsOfBridge(Node node) {
List<OvsdbTerminationPointAugmentation> tpAugmentations = extractTerminationPointAugmentations(node);
if(tpAugmentations.isEmpty()){
tpAugmentations = readTerminationPointAugmentations(node);
return tpAugmentations;
}
- public static OvsdbTerminationPointAugmentation extractTerminationPointAugmentation(Node bridgeNode, String portName) {
+ public OvsdbTerminationPointAugmentation extractTerminationPointAugmentation(Node bridgeNode, String portName) {
OvsdbBridgeAugmentation ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
if (ovsdbBridgeAugmentation != null) {
List<TerminationPoint> terminationPoints = bridgeNode.getTerminationPoint();
return null;
}
- public static List<TerminationPoint> extractTerminationPoints(Node node) {
+ public List<TerminationPoint> extractTerminationPoints(Node node) {
List<TerminationPoint> terminationPoints = new ArrayList<TerminationPoint>();
OvsdbBridgeAugmentation ovsdbBridgeAugmentation = node.getAugmentation(OvsdbBridgeAugmentation.class);
if (ovsdbBridgeAugmentation != null) {
return terminationPoints;
}
- public static List<OvsdbTerminationPointAugmentation> extractTerminationPointAugmentations( Node node ) {
+ public List<OvsdbTerminationPointAugmentation> extractTerminationPointAugmentations( Node node ) {
List<OvsdbTerminationPointAugmentation> tpAugmentations = new ArrayList<OvsdbTerminationPointAugmentation>();
List<TerminationPoint> terminationPoints = node.getTerminationPoint();
if(terminationPoints != null && !terminationPoints.isEmpty()){
return tpAugmentations;
}
- public static List<OvsdbTerminationPointAugmentation> readTerminationPointAugmentations(Node node) {
+ public List<OvsdbTerminationPointAugmentation> readTerminationPointAugmentations(Node node) {
InstanceIdentifier<Node> bridgeNodeIid = MdsalHelper.createInstanceIdentifier(node.getNodeId());
- Node operNode = read(LogicalDatastoreType.OPERATIONAL, bridgeNodeIid);
+ Node operNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, bridgeNodeIid);
if(operNode != null){
return extractTerminationPointAugmentations(operNode);
}
return new ArrayList<OvsdbTerminationPointAugmentation>();
}
- public static String getInterfaceExternalIdsValue(
+ public String getInterfaceExternalIdsValue(
OvsdbTerminationPointAugmentation terminationPointAugmentation, String key) {
String value = null;
List<InterfaceExternalIds> pairs = terminationPointAugmentation.getInterfaceExternalIds();
return value;
}
- public static Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type) {
+ public Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type) {
InstanceIdentifier<TerminationPoint> tpIid =
MdsalHelper.createTerminationPointInstanceIdentifier(bridgeNode, portName);
OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
- return put(LogicalDatastoreType.CONFIGURATION, tpIid, tpBuilder.build());
+ return mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, tpIid, tpBuilder.build());
}
- public static Boolean deleteTerminationPoint(Node bridgeNode, String portName) {
+ public Boolean deleteTerminationPoint(Node bridgeNode, String portName) {
InstanceIdentifier<TerminationPoint> tpIid =
MdsalHelper.createTerminationPointInstanceIdentifier(bridgeNode, portName);
- return delete(LogicalDatastoreType.CONFIGURATION, tpIid);
+ return mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, tpIid);
}
- public static Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName,
+ public Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName,
String type, Map<String, String> options) {
InstanceIdentifier<TerminationPoint> tpIid = MdsalHelper.createTerminationPointInstanceIdentifier(
bridgeNode, portName);
TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
- /* TODO SB_MIGRATION should this be merge or put */
- return put(LogicalDatastoreType.CONFIGURATION, tpIid, tpBuilder.build());
+ /* TODO SB_MIGRATION should this be merge or mdsalUtils.put */
+ return mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, tpIid, tpBuilder.build());
}
- public static TerminationPoint readTerminationPoint(Node bridgeNode, String bridgeName, String portName) {
+ public TerminationPoint readTerminationPoint(Node bridgeNode, String bridgeName, String portName) {
InstanceIdentifier<TerminationPoint> tpIid = MdsalHelper.createTerminationPointInstanceIdentifier(
bridgeNode, portName);
- return read(LogicalDatastoreType.OPERATIONAL, tpIid);
+ return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, tpIid);
}
- public static Boolean addTunnelTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type,
+ public Boolean addTunnelTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type,
Map<String, String> options) {
return addTerminationPoint(bridgeNode, bridgeName, portName, type, options);
}
- public static Boolean isTunnelTerminationPointExist(Node bridgeNode, String bridgeName, String portName){
+ public Boolean isTunnelTerminationPointExist(Node bridgeNode, String bridgeName, String portName){
return readTerminationPoint(bridgeNode, bridgeName, portName) != null;
}
- public static Boolean addPatchTerminationPoint(Node node, String bridgeName, String portName, String peerPortName) {
+ public Boolean addPatchTerminationPoint(Node node, String bridgeName, String portName, String peerPortName) {
Map<String, String> option = new HashMap<String, String>();
option.put("peer", peerPortName);
return addTerminationPoint(node, bridgeName, portName, PATCH_PORT_TYPE, option);
}
- public static String getExternalId(Node node, OvsdbTables table, String key) {
+ public String getExternalId(Node node, OvsdbTables table, String key) {
switch (table) {
case BRIDGE:
OvsdbBridgeAugmentation bridge = extractBridgeAugmentation(node);
return null;
}
- public static String getOtherConfig(Node node, OvsdbTables table, String key) {
+ public String getOtherConfig(Node node, OvsdbTables table, String key) {
switch (table) {
case BRIDGE:
OvsdbBridgeAugmentation bridge = extractBridgeAugmentation(node);
return null;
}
- public static boolean addVlanToTp(long vlan) {
+ public boolean addVlanToTp(long vlan) {
return false;
}
- public static boolean isTunnel(OvsdbTerminationPointAugmentation port) {
- LOG.trace("MdsalUtils#isTunnel: Interface : {}", port);
+ public boolean isTunnel(OvsdbTerminationPointAugmentation port) {
+ LOG.trace("SouthboundImpl#isTunnel: Interface : {}", port);
if(port.getInterfaceType() == null){
LOG.warn("No type found for the interface : {}", port);
port.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_GRE);
}
- public static String getOptionsValue(List<Options> options, String key) {
+ public String getOptionsValue(List<Options> options, String key) {
String value = null;
for (Options option : options) {
if (option.getKey().equals(key)) {
return value;
}
- private static Topology getOvsdbTopology() {
+ public Topology getOvsdbTopology() {
InstanceIdentifier<Topology> path = InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(MdsalHelper.OVSDB_TOPOLOGY_ID));
- Topology topology = read(LogicalDatastoreType.OPERATIONAL, path);
+ Topology topology = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, path);
return topology;
}
- public static Long getOFPort(OvsdbTerminationPointAugmentation port) {
+ public Long getOFPort(OvsdbTerminationPointAugmentation port) {
Long ofPort = 0L;
if (port.getOfport() != null) {
ofPort = port.getOfport();
return ofPort;
}
- public static Long getOFPort(Node bridgeNode, String portName) {
+ public Long getOFPort(Node bridgeNode, String portName) {
Long ofPort = 0L;
OvsdbTerminationPointAugmentation port = extractTerminationPointAugmentation(bridgeNode, portName);
if (port != null) {
import org.opendaylight.neutron.spi.NeutronNetwork;
import org.opendaylight.neutron.spi.NeutronPort;
import org.opendaylight.ovsdb.openstack.netvirt.ConfigInterface;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.VlanConfigurationCache;
import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
public class TenantNetworkManagerImpl implements ConfigInterface, TenantNetworkManager {
static final Logger logger = LoggerFactory.getLogger(TenantNetworkManagerImpl.class);
- private volatile INeutronNetworkCRUD neutronNetworkCache;
- private volatile INeutronPortCRUD neutronPortCache;
- private volatile VlanConfigurationCache vlanConfigurationCache;
+ private INeutronNetworkCRUD neutronNetworkCache;
+ private INeutronPortCRUD neutronPortCache;
+ private VlanConfigurationCache vlanConfigurationCache;
+ private Southbound southbound;
@Override
public int getInternalVlan(Node node, String networkId) {
return;
}
- MdsalUtils.addVlanToTp(vlan);
+ southbound.addVlanToTp(vlan);
}
@Override
}
try {
- List<OvsdbTerminationPointAugmentation> ports = MdsalUtils.getTerminationPointsOfBridge(node);
+ List<OvsdbTerminationPointAugmentation> ports = southbound.getTerminationPointsOfBridge(node);
for (OvsdbTerminationPointAugmentation port : ports) {
- String ifaceId = MdsalUtils.getInterfaceExternalIdsValue(port, Constants.EXTERNAL_ID_INTERFACE_ID);
+ String ifaceId = southbound.getInterfaceExternalIdsValue(port, Constants.EXTERNAL_ID_INTERFACE_ID);
if (ifaceId != null && isInterfacePresentInTenantNetwork(ifaceId, networkId)) {
logger.debug("Tenant Network {} with Segmentation-id {} is present in Node {} / Interface {}",
networkId, segmentationId, node, port);
NeutronNetwork neutronNetwork = null;
logger.debug("getTenantNetwork for {}", terminationPointAugmentation);
- String neutronPortId = MdsalUtils.getInterfaceExternalIdsValue(terminationPointAugmentation,
+ String neutronPortId = southbound.getInterfaceExternalIdsValue(terminationPointAugmentation,
Constants.EXTERNAL_ID_INTERFACE_ID);
if (neutronPortId != null) {
NeutronPort neutronPort = neutronPortCache.getPort(neutronPortId);
NeutronPort neutronPort = null;
logger.trace("getTenantPort for {}", terminationPointAugmentation.getName());
- String neutronPortId = MdsalUtils.getInterfaceExternalIdsValue(terminationPointAugmentation,
- Constants.EXTERNAL_ID_INTERFACE_ID);
+ String neutronPortId = southbound.getInterfaceExternalIdsValue(terminationPointAugmentation,
+ Constants.EXTERNAL_ID_INTERFACE_ID);
if (neutronPortId != null) {
neutronPort = neutronPortCache.getPort(neutronPortId);
}
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
vlanConfigurationCache =
(VlanConfigurationCache) ServiceHelper.getGlobalInstance(VlanConfigurationCache.class, this);
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
}
@Override
package org.opendaylight.ovsdb.openstack.netvirt.impl;
import org.opendaylight.ovsdb.openstack.netvirt.ConfigInterface;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.NodeConfiguration;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.VlanConfigurationCache;
import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
static final Logger logger = LoggerFactory.getLogger(VlanConfigurationCacheImpl.class);
private Map<String, NodeConfiguration> configurationCache = Maps.newConcurrentMap();
private volatile TenantNetworkManager tenantNetworkManager;
+ private volatile Southbound southbound;
private NodeConfiguration getNodeConfiguration(Node node){
String nodeUuid = getNodeUUID(node);
}
private String getNodeUUID(Node node) {
- return MdsalUtils.getOvsdbNodeUUID(node);
+ return southbound.getOvsdbNodeUUID(node);
}
private void initializeNodeConfiguration(Node node, String nodeUuid) {
NodeConfiguration nodeConfiguration = new NodeConfiguration();
Integer vlan = 0;
String networkId = null;
- List<OvsdbTerminationPointAugmentation> ports = MdsalUtils.getTerminationPointsOfBridge(node);
+ List<OvsdbTerminationPointAugmentation> ports = southbound.getTerminationPointsOfBridge(node);
for (OvsdbTerminationPointAugmentation port : ports) {
vlan = port.getVlanTag().getValue();
networkId = tenantNetworkManager.getTenantNetwork(port).getNetworkUUID();
public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
tenantNetworkManager =
(TenantNetworkManager) ServiceHelper.getGlobalInstance(TenantNetworkManager.class, this);
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
}
@Override
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
-import static org.powermock.api.mockito.PowerMockito.verifyStatic;
import java.util.List;
import org.junit.runner.RunWith;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.opendaylight.neutron.spi.NeutronNetwork;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbTables;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
* @author Sam Hague (shague@redhat.com)
*/
@RunWith(PowerMockRunner.class)
-@PrepareForTest(MdsalUtils.class)
public class BridgeConfigurationManagerImplTest {
@Mock private Node node;
@Mock private OvsdbBridgeAugmentation bridge;
@Mock private OvsdbTerminationPointAugmentation port;
@Mock private NeutronNetwork neutronNetwork;
@Mock private ConfigurationService configurationService;
+ @Mock private Southbound southbound;
@InjectMocks public static BridgeConfigurationManagerImpl bridgeConfigurationManagerImpl;
private static final String BR_INT = "br-int";
@Test
public void testGetBridgeUuid() {
- mockStatic(MdsalUtils.class);
- when(MdsalUtils.getBridgeUuid(any(Node.class), anyString()))
+ when(southbound.getBridgeUuid(any(Node.class), anyString()))
.thenReturn(null)
.thenReturn(BRIDGE_UUID);
bridgeConfigurationManagerImpl.getBridgeUuid(node, BR_INT));
assertEquals("Error, did not return UUID of correct bridge", BRIDGE_UUID,
bridgeConfigurationManagerImpl.getBridgeUuid(node, BR_INT));
- verifyStatic(times(2));
- MdsalUtils.getBridgeUuid(any(Node.class), anyString());
+ verify(southbound, times(2)).getBridgeUuid(any(Node.class), anyString());
}
@Test
public void testIsNodeNeutronReady() throws Exception {
- mockStatic(MdsalUtils.class);
- when(MdsalUtils.getBridge(any(Node.class), anyString()))
+ when(southbound.getBridge(any(Node.class), anyString()))
.thenReturn(null)
.thenReturn(bridge);
bridgeConfigurationManagerImpl.isNodeNeutronReady(node));
verify(configurationService, times(2)).getIntegrationBridgeName();
- verifyStatic(times(2));
- MdsalUtils.getBridge(any(Node.class), anyString());
+ verify(southbound, times(2)).getBridge(any(Node.class), anyString());
}
@Test
public void testIsNodeOverlayReady() throws Exception {
- mockStatic(MdsalUtils.class);
- when(MdsalUtils.getBridge(any(Node.class), anyString()))
+ when(southbound.getBridge(any(Node.class), anyString()))
.thenReturn(null)
.thenReturn(bridge);
PowerMockito.spy(new BridgeConfigurationManagerImpl());
doReturn(false).when(bridgeConfigurationManagerImplSpy).isNodeNeutronReady(any(Node.class));
bridgeConfigurationManagerImplSpy.setConfigurationService(configurationService);
+ bridgeConfigurationManagerImplSpy.setSouthbound(southbound);
verifyNoMoreInteractions(configurationService);
bridgeConfigurationManagerImplSpy.isNodeOverlayReady(node));
verify(configurationService, times(2)).getNetworkBridgeName();
- verifyStatic(times(2));
- MdsalUtils.getBridge(any(Node.class), anyString());
+ verify(southbound, times(2)).getBridge(any(Node.class), anyString());
}
@Test
public void testIsPortOnBridge() throws Exception {
- mockStatic(MdsalUtils.class);
- when(MdsalUtils.extractTerminationPointAugmentation(any(Node.class), anyString()))
+ when(southbound.extractTerminationPointAugmentation(any(Node.class), anyString()))
.thenReturn(null)
.thenReturn(port);
bridgeConfigurationManagerImpl.isPortOnBridge(node, PORT_BR_INT));
assertTrue("Error, port " + PORT_BR_INT + " should be found",
bridgeConfigurationManagerImpl.isPortOnBridge(node, PORT_BR_INT));
- verifyStatic(times(2));
- MdsalUtils.extractTerminationPointAugmentation(any(Node.class), anyString());
+ verify(southbound, times(2)).extractTerminationPointAugmentation(any(Node.class), anyString());
}
@Test
public void testIsNodeTunnelReady() throws Exception {
- mockStatic(MdsalUtils.class);
- when(MdsalUtils.getBridge(any(Node.class), anyString()))
+ when(southbound.getBridge(any(Node.class), anyString()))
.thenReturn(null)
.thenReturn(bridge);
bridgeConfigurationManagerImpl.isNodeNeutronReady(node));
verify(configurationService, times(2)).getIntegrationBridgeName();
- verifyStatic(times(2));
- MdsalUtils.getBridge(any(Node.class), anyString());
+ verify(southbound, times(2)).getBridge(any(Node.class), anyString());
}
@Test
public void testIsNodeVlanReady() throws Exception {
- mockStatic(MdsalUtils.class);
- when(MdsalUtils.getBridge(any(Node.class), anyString()))
+ when(southbound.getBridge(any(Node.class), anyString()))
.thenReturn(null)
.thenReturn(bridge);
- when(MdsalUtils.extractTerminationPointAugmentation(any(Node.class), anyString()))
+ when(southbound.extractTerminationPointAugmentation(any(Node.class), anyString()))
.thenReturn(null)
.thenReturn(port);
PowerMockito.spy(new BridgeConfigurationManagerImpl());
doReturn(ETH1).when(bridgeConfigurationManagerImplSpy).getPhysicalInterfaceName(any(Node.class), anyString());
bridgeConfigurationManagerImplSpy.setConfigurationService(configurationService);
+ bridgeConfigurationManagerImplSpy.setSouthbound(southbound);
assertFalse("Error, did not return correct boolean from isNodeVlanReady",
bridgeConfigurationManagerImpl.isNodeVlanReady(node, neutronNetwork));
verify(configurationService, times(3)).getIntegrationBridgeName();
verify(neutronNetwork, times(2)).getProviderPhysicalNetwork();
- verifyStatic(times(3));
- MdsalUtils.getBridge(any(Node.class), anyString());
- verifyStatic(times(2));
- MdsalUtils.extractTerminationPointAugmentation(any(Node.class), anyString());
}
@Test
@Test
public void testGetPhysicalInterfaceName() throws Exception {
- mockStatic(MdsalUtils.class);
- when(MdsalUtils.getOtherConfig(any(Node.class), eq(OvsdbTables.OPENVSWITCH), anyString()))
+ when(southbound.getOtherConfig(any(Node.class), eq(OvsdbTables.OPENVSWITCH), anyString()))
.thenReturn(null)
.thenReturn(null)
.thenReturn(PROVIDER_MAPPINGS);
assertNull(PHYSNET1, bridgeConfigurationManagerImpl.getPhysicalInterfaceName(node, PHYSNET3));
verify(configurationService, times(5)).getProviderMappingsKey();
verify(configurationService, times(2)).getDefaultProviderMapping();
+ verify(southbound, times(5)).getOtherConfig(any(Node.class), eq(OvsdbTables.OPENVSWITCH), anyString());
}
@Test
public void testGetAllPhysicalInterfaceNames() throws Exception {
- mockStatic(MdsalUtils.class);
- when(MdsalUtils.getOtherConfig(any(Node.class), eq(OvsdbTables.OPENVSWITCH), anyString()))
+ when(southbound.getOtherConfig(any(Node.class), eq(OvsdbTables.OPENVSWITCH), anyString()))
.thenReturn(null)
.thenReturn(PROVIDER_MAPPINGS);
verify(configurationService, times(2)).getProviderMappingsKey();
verify(configurationService, times(1)).getDefaultProviderMapping();
- verifyStatic(times(2));
- MdsalUtils.getOtherConfig(any(Node.class), eq(OvsdbTables.OPENVSWITCH), anyString());
+ verify(southbound, times(2)).getOtherConfig(any(Node.class), eq(OvsdbTables.OPENVSWITCH), anyString());
}
}
\ No newline at end of file
Code Review / netvirt.git / commitdiff