*/
public class SouthboundHandler extends AbstractHandler
implements ConfigInterface, NodeCacheListener, OvsdbInventoryListener {
- static final Logger logger = LoggerFactory.getLogger(SouthboundHandler.class);
+ private static final Logger LOGGER = 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;
- private volatile EventDispatcher eventDispatcher;
+ 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);
+ LOGGER.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);
+ LOGGER.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);
+ LOGGER.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);
+ LOGGER.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);
+ LOGGER.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: <{}>",
+ LOGGER.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) {
+ LOGGER.error("Tunnel end-point configuration missing. Please configure it in OpenVSwitch Table");
+ return;
}
networkingProviderManager.getProvider(node).handleInterfaceDelete(network.getProviderNetworkType(),
network, node, intf, isLastInstanceOnNode);
@Override
public void triggerUpdates() {
- logger.info("triggerUpdates");
- List<Node> ovsdbNodes = MdsalUtils.readOvsdbTopologyNodes();
+ LOGGER.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);
+ LOGGER.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");
+ LOGGER.warn("processPortDelete: network was null, ignoring update");
}
} else if (network != null && !network.getRouterExternal()) {
- logger.debug("Network {}: Delete interface {} attached to bridge {}", network.getNetworkUUID(),
+ 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()){
}
}
} catch (Exception e) {
- logger.error("Error fetching Interface Rows for node " + node, e);
+ LOGGER.error("Error fetching Interface Rows for node " + node, e);
}
}
}
private boolean isInterfaceOfInterest(OvsdbTerminationPointAugmentation terminationPoint, List<String> phyIfName) {
- logger.trace("SouthboundHandler#isInterfaceOfInterest: Interface : {}", terminationPoint);
+ LOGGER.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);
+ LOGGER.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);
+ LOGGER.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);
+ LOGGER.error("processEvent: Unable to process abstract event {}", abstractEvent);
return;
}
SouthboundEvent ev = (SouthboundEvent) abstractEvent;
- logger.trace("processEvent: {}", ev);
+ LOGGER.trace("processEvent: {}", ev);
switch (ev.getType()) {
case NODE:
processOvsdbNodeEvent(ev);
break;
default:
- logger.warn("Unable to process type " + ev.getType() +
+ LOGGER.warn("Unable to process type " + ev.getType() +
" action " + ev.getAction() + " for node " + ev.getNode());
break;
}
}
private void processOvsdbNodeCreate(Node node, OvsdbNodeAugmentation ovsdbNode) {
- logger.info("processOvsdbNodeCreate <{}> <{}>", node, ovsdbNode);
+ LOGGER.info("processOvsdbNodeCreate <{}> <{}>", node, ovsdbNode);
nodeCacheManager.nodeAdded(node);
bridgeConfigurationManager.prepareNode(node);
}
private void processOvsdbNodeUpdate(Node node, OvsdbNodeAugmentation ovsdbNode) {
- logger.info("processOvsdbNodeUpdate <{}> <{}>", node, ovsdbNode);
+ LOGGER.info("processOvsdbNodeUpdate <{}> <{}>", node, ovsdbNode);
nodeCacheManager.nodeAdded(node);
}
private void processOvsdbNodeDelete(Node node, OvsdbNodeAugmentation ovsdbNode) {
- logger.info("processOvsdbNodeDelete <{}> <{}>", node, ovsdbNode);
+ LOGGER.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);
+ LOGGER.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);
+ 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) {
+ // 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");
+ LOGGER.info("datapathId not found");
}
}
return rv;
}
private void processBridgeCreate(Node node, OvsdbBridgeAugmentation bridge) {
- logger.debug("processBridgeCreate <{}> <{}>", node, bridge);
- String datapathId = MdsalUtils.getDatapathId(bridge);
+ LOGGER.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");
+ LOGGER.info("processBridgeCreate datapathId not found");
}
}
private void processBridgeUpdate(Node node, OvsdbBridgeAugmentation bridge) {
- logger.debug("processBridgeUpdate <{}> <{}>", node, bridge);
- String datapathId = MdsalUtils.getDatapathId(bridge);
+ LOGGER.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");
+ LOGGER.info("processBridgeUpdate datapathId not found");
}
}
private void processBridgeDelete(Node node, OvsdbBridgeAugmentation bridge) {
- logger.debug("processBridgeDelete: Delete bridge from config data store: <{}> <{}>",
+ LOGGER.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
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);
- super.setDispatcher(eventDispatcher);
ovsdbInventoryService =
(OvsdbInventoryService) ServiceHelper.getGlobalInstance(OvsdbInventoryService.class, this);
ovsdbInventoryService.listenerAdded(this);
}
@Override
- public void setDependencies(Object impl) {}
+ public void setDependencies(Object impl) {
+ }
}