import org.opendaylight.neutron.spi.NeutronNetwork;
import org.opendaylight.ovsdb.openstack.netvirt.api.*;
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.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.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;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Sam Hague (shague@redhat.com)
*/
public class SouthboundHandler extends AbstractHandler
- implements NodeCacheListener, OvsdbInventoryListener {
- static final Logger logger = LoggerFactory.getLogger(SouthboundHandler.class);
+ implements ConfigInterface, NodeCacheListener, OvsdbInventoryListener {
+ private static final Logger LOG = LoggerFactory.getLogger(SouthboundHandler.class);
// The implementation for each of these services is resolved by the OSGi Service Manager
private volatile ConfigurationService configurationService;
private volatile TenantNetworkManager tenantNetworkManager;
private volatile NetworkingProviderManager networkingProviderManager;
private volatile NeutronL3Adapter neutronL3Adapter;
- private volatile NodeCacheManager nodeCacheManager = null;
-
- void start() {
- this.triggerUpdates();
- }
-
- void init() {
- logger.info(">>>>>> init {}", this.getClass());
- }
+ private volatile NodeCacheManager nodeCacheManager;
+ private volatile OvsdbInventoryService ovsdbInventoryService;
+ private volatile Southbound southbound;
private SouthboundEvent.Type ovsdbTypeToSouthboundEventType(OvsdbType ovsdbType) {
SouthboundEvent.Type type = SouthboundEvent.Type.NODE;
type = SouthboundEvent.Type.OPENVSWITCH;
break;
default:
- logger.warn("Invalid OvsdbType: {}", ovsdbType);
+ LOG.warn("Invalid OvsdbType: {}", ovsdbType);
break;
}
return type;
@Override
public void ovsdbUpdate(Node node, DataObject resourceAugmentationData, OvsdbType ovsdbType, Action action) {
- logger.info("ovsdbUpdate: {} - {} - <<{}>> <<{}>>", ovsdbType, action, node, resourceAugmentationData);
- this.enqueueEvent(new SouthboundEvent(node, resourceAugmentationData,
+ LOG.info("ovsdbUpdate: {} - {} - <<{}>> <<{}>>", ovsdbType, action, node, resourceAugmentationData);
+ enqueueEvent(new SouthboundEvent(node, resourceAugmentationData,
ovsdbTypeToSouthboundEventType(ovsdbType), action));
}
private void handleInterfaceUpdate (Node node, OvsdbTerminationPointAugmentation tp) {
- logger.debug("handleInterfaceUpdate <{}> <{}>", node, tp);
+ LOG.debug("handleInterfaceUpdate <{}> <{}>", node, tp);
NeutronNetwork network = tenantNetworkManager.getTenantNetwork(tp);
if (network != null && !network.getRouterExternal()) {
- logger.trace("handleInterfaceUpdate <{}> <{}> network: {}", node, tp, network.getNetworkUUID());
- neutronL3Adapter.handleInterfaceEvent(node, tp, network, Action.UPDATE);
+ LOG.trace("handleInterfaceUpdate <{}> <{}> network: {}", node, tp, network.getNetworkUUID());
if (bridgeConfigurationManager.createLocalNetwork(node, network)) {
networkingProviderManager.getProvider(node).handleInterfaceUpdate(network, node, tp);
}
} else {
- logger.debug("No tenant network found on node: <{}> for interface: <{}>", node, tp);
+ LOG.debug("No tenant network found on node: <{}> for interface: <{}>", node, tp);
}
+ neutronL3Adapter.handleInterfaceEvent(node, tp, network, Action.UPDATE);
}
private void handleInterfaceDelete (Node node, OvsdbTerminationPointAugmentation intf,
boolean isLastInstanceOnNode, NeutronNetwork network) {
- logger.debug("handleInterfaceDelete: node: <{}>, isLastInstanceOnNode: {}, interface: <{}>",
+ LOG.debug("handleInterfaceDelete: node: <{}>, isLastInstanceOnNode: {}, interface: <{}>",
node, isLastInstanceOnNode, intf);
neutronL3Adapter.handleInterfaceEvent(node, intf, network, Action.DELETE);
network, node, intf, isLastInstanceOnNode);
} else if (network != null) {
// vlan doesn't need a tunnel endpoint
- if (!network.getProviderNetworkType().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
- if (configurationService.getTunnelEndPoint(node) == null) {
- logger.error("Tunnel end-point configuration missing. Please configure it in OpenVSwitch Table");
- return;
- }
+ if (!network.getProviderNetworkType().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN) &&
+ configurationService.getTunnelEndPoint(node) == null) {
+ LOG.error("Tunnel end-point configuration missing. Please configure it in OpenVSwitch Table");
+ return;
}
networkingProviderManager.getProvider(node).handleInterfaceDelete(network.getProviderNetworkType(),
network, node, intf, isLastInstanceOnNode);
}
}
- private void triggerUpdates() {
- List<Node> nodes = null; // nodeCacheManager.getBridgeNodes();
- if (nodes == null) return;
- for (Node node : nodes) {
- OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
- if (bridge != null) {
- processBridgeUpdate(node, bridge);
- }
-
- List<TerminationPoint> tps = MdsalUtils.extractTerminationPoints(node);
- for (TerminationPoint tp : tps) {
- OvsdbTerminationPointAugmentation port = tp.getAugmentation(OvsdbTerminationPointAugmentation.class);
- if (port != null) {
- processPortUpdate(node, port);
- }
- }
+ @Override
+ public void triggerUpdates() {
+ LOG.info("triggerUpdates");
+ List<Node> ovsdbNodes = southbound.readOvsdbTopologyNodes();
+ for (Node node : ovsdbNodes) {
+ ovsdbUpdate(node, node.getAugmentation(OvsdbNodeAugmentation.class),
+ OvsdbInventoryListener.OvsdbType.NODE, Action.ADD);
}
}
private void processPortDelete(Node node, OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation,
Object context) {
- logger.debug("processPortDelete <{}> <{}>", node, ovsdbTerminationPointAugmentation);
+ LOG.debug("processPortDelete <{}> <{}>", node, ovsdbTerminationPointAugmentation);
NeutronNetwork network = null;
if (context == null) {
network = tenantNetworkManager.getTenantNetwork(ovsdbTerminationPointAugmentation);
if (network != null) {
this.handleInterfaceDelete(node, ovsdbTerminationPointAugmentation, false, network);
} else {
- logger.warn("processPortDelete: network was null, ignoring update");
+ LOG.warn("processPortDelete: network was null, ignoring update");
}
} else if (network != null && !network.getRouterExternal()) {
- logger.debug("Network {}: Delete interface {} attached to bridge {}", network.getNetworkUUID(),
+ LOG.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()){
}
}
} catch (Exception e) {
- logger.error("Error fetching Interface Rows for node " + node, e);
+ LOG.error("Error fetching Interface Rows for node {}", node, e);
}
}
}
private boolean isInterfaceOfInterest(OvsdbTerminationPointAugmentation terminationPoint, List<String> phyIfName) {
- logger.trace("SouthboundHandler#isInterfaceOfInterest: Interface : {}", terminationPoint);
+ LOG.trace("SouthboundHandler#isInterfaceOfInterest: Interface : {}", terminationPoint);
if(terminationPoint.getInterfaceType() == null){
// This is OK since eth ports don't have an interface type
- logger.info("No type found for the interface : {}", terminationPoint);
+ LOG.info("No type found for the interface : {}", terminationPoint);
return false;
}
- return (MdsalHelper.createOvsdbInterfaceType(
+ return MdsalHelper.createOvsdbInterfaceType(
terminationPoint.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_VXLAN)
- ||
- MdsalHelper.createOvsdbInterfaceType(
- terminationPoint.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_GRE)
- ||
- phyIfName.contains(terminationPoint.getName()));
+ ||
+ MdsalHelper.createOvsdbInterfaceType(
+ terminationPoint.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_GRE)
+ ||
+ phyIfName.contains(terminationPoint.getName());
}
/**
*/
@Override
public void notifyNode (Node node, Action action) {
- logger.info("notifyNode: action: {}, Node <{}>", action, node);
+ LOG.info("notifyNode: action: {}, Node <{}>", action, node);
- if (action.equals(Action.ADD)) {
- if (MdsalUtils.getBridge(node) != null) {
- networkingProviderManager.getProvider(node).initializeOFFlowRules(node);
- }
+ if ((action.equals(Action.ADD)) && (southbound.getBridge(node) != null)) {
+ networkingProviderManager.getProvider(node).initializeOFFlowRules(node);
}
}
@Override
public void processEvent(AbstractEvent abstractEvent) {
if (!(abstractEvent instanceof SouthboundEvent)) {
- logger.error("processEvent: Unable to process abstract event {}", abstractEvent);
+ LOG.error("processEvent: Unable to process abstract event {}", abstractEvent);
return;
}
SouthboundEvent ev = (SouthboundEvent) abstractEvent;
- logger.debug("processEvent: {}", ev);
+ LOG.trace("processEvent: {}", ev);
switch (ev.getType()) {
case NODE:
processOvsdbNodeEvent(ev);
break;
default:
- logger.warn("Unable to process type " + ev.getType() +
- " action " + ev.getAction() + " for node " + ev.getNode());
+ LOG.warn("Unable to process type {} action {} for node {}", ev.getType(), ev.getAction(), ev.getNode());
break;
}
- logger.warn("processEvent done");
}
private void processOvsdbNodeEvent(SouthboundEvent ev) {
}
private void processOvsdbNodeCreate(Node node, OvsdbNodeAugmentation ovsdbNode) {
- logger.info("processOvsdbNodeCreate <{}> <{}>", node, ovsdbNode);
+ LOG.info("processOvsdbNodeCreate <{}> <{}>", node, ovsdbNode);
nodeCacheManager.nodeAdded(node);
bridgeConfigurationManager.prepareNode(node);
}
private void processOvsdbNodeUpdate(Node node, OvsdbNodeAugmentation ovsdbNode) {
- logger.info("processOvsdbNodeUpdate <{}> <{}>", node, ovsdbNode);
+ LOG.info("processOvsdbNodeUpdate <{}> <{}>", node, ovsdbNode);
nodeCacheManager.nodeAdded(node);
}
private void processOvsdbNodeDelete(Node node, OvsdbNodeAugmentation ovsdbNode) {
- logger.info("processOvsdbNodeDelete <{}> <{}>", node, ovsdbNode);
+ LOG.info("processOvsdbNodeDelete <{}> <{}>", node, ovsdbNode);
nodeCacheManager.nodeRemoved(node);
/* TODO SB_MIGRATION
* I don't think we want to do this yet
InstanceIdentifier<Node> bridgeNodeIid =
MdsalHelper.createInstanceIdentifier(ovsdbNode.getConnectionInfo(),
Constants.INTEGRATION_BRIDGE);
- MdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, bridgeNodeIid);
+ southbound.delete(LogicalDatastoreType.CONFIGURATION, bridgeNodeIid);
*/
}
}
private void processPortUpdate(Node node, OvsdbTerminationPointAugmentation port) {
- logger.debug("processPortUpdate <{}> <{}>", node, port);
+ LOG.debug("processPortUpdate <{}> <{}>", node, port);
NeutronNetwork network = tenantNetworkManager.getTenantNetwork(port);
- if (network != null && !network.getRouterExternal()) {
- this.handleInterfaceUpdate(node, port);
+ if (network != null ){
+ if(!network.getRouterExternal()){
+ this.handleInterfaceUpdate(node, port);
+ }
}
}
}
private void processOpenVSwitchUpdate(Node node) {
- logger.debug("processOpenVSwitchUpdate {}", node);
+ LOG.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) {
+ // TODO: Either do something or remove this if statement.
+ // If there's only one termination point, is it a 1-port bridge?
}
- 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;
} else {
- logger.info("datapathId not found");
+ LOG.info("datapathId not found");
}
}
return rv;
}
private void processBridgeCreate(Node node, OvsdbBridgeAugmentation bridge) {
- logger.debug("processBridgeCreate <{}> <{}>", node, bridge);
- String datapathId = MdsalUtils.getDatapathId(bridge);
+ LOG.debug("processBridgeCreate <{}> <{}>", node, bridge);
+ String datapathId = southbound.getDatapathId(bridge);
// Having a datapathId means the ovsdb node has connected to ODL
if (datapathId != null) {
nodeCacheManager.nodeAdded(node);
} else {
- logger.info("processBridgeCreate datapathId not found");
+ LOG.info("processBridgeCreate datapathId not found");
}
}
private void processBridgeUpdate(Node node, OvsdbBridgeAugmentation bridge) {
- logger.debug("processBridgeUpdate <{}> <{}>", node, bridge);
- String datapathId = MdsalUtils.getDatapathId(bridge);
+ LOG.debug("processBridgeUpdate <{}> <{}>", node, bridge);
+ String datapathId = southbound.getDatapathId(bridge);
// Having a datapathId means the ovsdb node has connected to ODL
if (datapathId != null) {
nodeCacheManager.nodeAdded(node);
} else {
- logger.info("processBridgeUpdate datapathId not found");
+ LOG.info("processBridgeUpdate datapathId not found");
}
}
private void processBridgeDelete(Node node, OvsdbBridgeAugmentation bridge) {
- logger.debug("processBridgeDelete: Delete bridge from config data store: <{}> <{}>",
+ LOG.debug("processBridgeDelete: Delete bridge from config data store: <{}> <{}>",
node, bridge);
nodeCacheManager.nodeRemoved(node);
// TODO SB_MIGRATION
// Not sure if we want to do this yet
- MdsalUtils.deleteBridge(node);
+ southbound.deleteBridge(node);
+ }
+
+ @Override
+ public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
+ configurationService =
+ (ConfigurationService) ServiceHelper.getGlobalInstance(ConfigurationService.class, this);
+ networkingProviderManager =
+ (NetworkingProviderManager) ServiceHelper.getGlobalInstance(NetworkingProviderManager.class, this);
+ tenantNetworkManager =
+ (TenantNetworkManager) ServiceHelper.getGlobalInstance(TenantNetworkManager.class, this);
+ bridgeConfigurationManager =
+ (BridgeConfigurationManager) ServiceHelper.getGlobalInstance(BridgeConfigurationManager.class, this);
+ nodeCacheManager =
+ (NodeCacheManager) ServiceHelper.getGlobalInstance(NodeCacheManager.class, this);
+ nodeCacheManager.cacheListenerAdded(
+ 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(
+ bundleContext.getServiceReference(OvsdbInventoryListener.class.getName()), this);
+ ovsdbInventoryService =
+ (OvsdbInventoryService) ServiceHelper.getGlobalInstance(OvsdbInventoryService.class, this);
+ ovsdbInventoryService.listenerAdded(this);
+ }
+
+ @Override
+ public void setDependencies(Object impl) {
}
}
Code Review / ovsdb.git / blobdiff