openstack/net-virt/src/main/java/org/opendaylight/ovsdb/openstack/netvirt/SouthboundHandler.java

   1 /*
   2  * Copyright (c) 2013, 2015 Red Hat, Inc. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.ovsdb.openstack.netvirt;
  10
  11 import java.util.List;
  12
  13 import org.opendaylight.neutron.spi.NeutronNetwork;
  14 import org.opendaylight.ovsdb.openstack.netvirt.api.*;
  15 import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
  16 import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  20 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  21 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  22 import org.opendaylight.yangtools.yang.binding.DataObject;
  23 import org.osgi.framework.BundleContext;
  24 import org.osgi.framework.ServiceReference;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27
  28 /**
  29  * @author Madhu Venugopal
  30  * @author Brent Salisbury
  31  * @author Dave Tucker
  32  * @author Sam Hague (shague@redhat.com)
  33  */
  34 public class SouthboundHandler extends AbstractHandler
  35         implements ConfigInterface, NodeCacheListener, OvsdbInventoryListener {
  36     private static final Logger LOG = LoggerFactory.getLogger(SouthboundHandler.class);
  37
  38     // The implementation for each of these services is resolved by the OSGi Service Manager
  39     private volatile ConfigurationService configurationService;
  40     private volatile BridgeConfigurationManager bridgeConfigurationManager;
  41     private volatile TenantNetworkManager tenantNetworkManager;
  42     private volatile NetworkingProviderManager networkingProviderManager;
  43     private volatile NeutronL3Adapter neutronL3Adapter;
  44     private volatile NodeCacheManager nodeCacheManager;
  45     private volatile OvsdbInventoryService ovsdbInventoryService;
  46     private volatile Southbound southbound;
  47
  48     private SouthboundEvent.Type ovsdbTypeToSouthboundEventType(OvsdbType ovsdbType) {
  49         SouthboundEvent.Type type = SouthboundEvent.Type.NODE;
  50
  51         switch (ovsdbType) {
  52             case NODE:
  53                 type = SouthboundEvent.Type.NODE;
  54                 break;
  55             case BRIDGE:
  56                 type = SouthboundEvent.Type.BRIDGE;
  57                 break;
  58             case PORT:
  59                 type = SouthboundEvent.Type.PORT;
  60                 break;
  61             case CONTROLLER:
  62                 type = SouthboundEvent.Type.CONTROLLER;
  63                 break;
  64             case OPENVSWITCH:
  65                 type = SouthboundEvent.Type.OPENVSWITCH;
  66                 break;
  67             default:
  68                 LOG.warn("Invalid OvsdbType: {}", ovsdbType);
  69                 break;
  70         }
  71         return type;
  72     }
  73
  74     @Override
  75     public void ovsdbUpdate(Node node, DataObject resourceAugmentationData, OvsdbType ovsdbType, Action action) {
  76         LOG.info("ovsdbUpdate: {} - {} - <<{}>> <<{}>>", ovsdbType, action, node, resourceAugmentationData);
  77         enqueueEvent(new SouthboundEvent(node, resourceAugmentationData,
  78                 ovsdbTypeToSouthboundEventType(ovsdbType), action));
  79     }
  80
  81     private void handleInterfaceUpdate (Node node, OvsdbTerminationPointAugmentation tp) {
  82         LOG.debug("handleInterfaceUpdate <{}> <{}>", node, tp);
  83         NeutronNetwork network = tenantNetworkManager.getTenantNetwork(tp);
  84         if (network != null && !network.getRouterExternal()) {
  85             LOG.trace("handleInterfaceUpdate <{}> <{}> network: {}", node, tp, network.getNetworkUUID());
  86             if (bridgeConfigurationManager.createLocalNetwork(node, network)) {
  87                 networkingProviderManager.getProvider(node).handleInterfaceUpdate(network, node, tp);
  88             }
  89         } else {
  90             LOG.debug("No tenant network found on node: <{}> for interface: <{}>", node, tp);
  91         }
  92         neutronL3Adapter.handleInterfaceEvent(node, tp, network, Action.UPDATE);
  93     }
  94
  95     private void handleInterfaceDelete (Node node, OvsdbTerminationPointAugmentation intf,
  96                                         boolean isLastInstanceOnNode, NeutronNetwork network) {
  97         LOG.debug("handleInterfaceDelete: node: <{}>, isLastInstanceOnNode: {}, interface: <{}>",
  98                 node, isLastInstanceOnNode, intf);
  99
 100         neutronL3Adapter.handleInterfaceEvent(node, intf, network, Action.DELETE);
 101         List<String> phyIfName = bridgeConfigurationManager.getAllPhysicalInterfaceNames(node);
 102         if (isInterfaceOfInterest(intf, phyIfName)) {
 103             // delete tunnel or physical interfaces
 104             networkingProviderManager.getProvider(node).handleInterfaceDelete(network.getProviderNetworkType(),
 105                     network, node, intf, isLastInstanceOnNode);
 106         } else if (network != null) {
 107             // vlan doesn't need a tunnel endpoint
 108             if (!network.getProviderNetworkType().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN) &&
 109                     configurationService.getTunnelEndPoint(node) == null) {
 110                 LOG.error("Tunnel end-point configuration missing. Please configure it in OpenVSwitch Table");
 111                 return;
 112             }
 113             networkingProviderManager.getProvider(node).handleInterfaceDelete(network.getProviderNetworkType(),
 114                     network, node, intf, isLastInstanceOnNode);
 115         }
 116     }
 117
 118     @Override
 119     public void triggerUpdates() {
 120         LOG.info("triggerUpdates");
 121         List<Node> ovsdbNodes = southbound.readOvsdbTopologyNodes();
 122         for (Node node : ovsdbNodes) {
 123             ovsdbUpdate(node, node.getAugmentation(OvsdbNodeAugmentation.class),
 124                     OvsdbInventoryListener.OvsdbType.NODE, Action.ADD);
 125         }
 126     }
 127
 128     private void processPortDelete(Node node, OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation,
 129                                    Object context) {
 130         LOG.debug("processPortDelete <{}> <{}>", node, ovsdbTerminationPointAugmentation);
 131         NeutronNetwork network;
 132         if (context == null) {
 133             network = tenantNetworkManager.getTenantNetwork(ovsdbTerminationPointAugmentation);
 134         } else {
 135             network = (NeutronNetwork)context;
 136         }
 137         List<String> phyIfName = bridgeConfigurationManager.getAllPhysicalInterfaceNames(node);
 138         if (isInterfaceOfInterest(ovsdbTerminationPointAugmentation, phyIfName)) {
 139             if (network != null) {
 140                 this.handleInterfaceDelete(node, ovsdbTerminationPointAugmentation, false, network);
 141             } else {
 142                 LOG.warn("processPortDelete: network was null, ignoring update");
 143             }
 144         } else if (network != null && !network.getRouterExternal()) {
 145             LOG.debug("Network {}: Delete interface {} attached to bridge {}", network.getNetworkUUID(),
 146                     ovsdbTerminationPointAugmentation.getInterfaceUuid(), node.getNodeId());
 147             try {
 148                 OvsdbBridgeAugmentation ovsdbBridgeAugmentation = southbound.getBridge(node);
 149                 if (ovsdbBridgeAugmentation != null) {
 150                     List<TerminationPoint> terminationPoints = node.getTerminationPoint();
 151                     if (!terminationPoints.isEmpty()){
 152                         boolean isLastInstanceOnNode = true;
 153                         for (TerminationPoint terminationPoint : terminationPoints) {
 154                             OvsdbTerminationPointAugmentation tpAugmentation =
 155                                     terminationPoint.getAugmentation( OvsdbTerminationPointAugmentation.class);
 156                             if (tpAugmentation.getInterfaceUuid().equals(
 157                                     ovsdbTerminationPointAugmentation.getInterfaceUuid())) {
 158                                 continue;
 159                             }
 160                             NeutronNetwork neutronNetwork = tenantNetworkManager.getTenantNetwork(tpAugmentation);
 161                             if (neutronNetwork != null && neutronNetwork.equals(network)) {
 162                                 isLastInstanceOnNode = false;
 163                                 break;
 164                             }
 165                         }
 166                         this.handleInterfaceDelete(node, ovsdbTerminationPointAugmentation,
 167                                 isLastInstanceOnNode, network);
 168                     }
 169                 }
 170             } catch (Exception e) {
 171                 LOG.error("Error fetching Interface Rows for node {}", node, e);
 172             }
 173         }
 174     }
 175
 176     private boolean isInterfaceOfInterest(OvsdbTerminationPointAugmentation terminationPoint, List<String> phyIfName) {
 177         LOG.trace("SouthboundHandler#isInterfaceOfInterest: Interface : {}", terminationPoint);
 178
 179         if(terminationPoint.getInterfaceType() == null){
 180             // This is OK since eth ports don't have an interface type
 181             LOG.info("No type found for the interface : {}", terminationPoint);
 182             return false;
 183         }
 184         return MdsalHelper.createOvsdbInterfaceType(
 185                 terminationPoint.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_VXLAN)
 186                ||
 187                MdsalHelper.createOvsdbInterfaceType(
 188                        terminationPoint.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_GRE)
 189                ||
 190                phyIfName.contains(terminationPoint.getName());
 191     }
 192
 193     /**
 194      * Notification about an OpenFlow Node
 195      *
 196      * @param node the {@link Node Node} of interest in the notification
 197      * @param action the {@link Action}
 198      * @see NodeCacheListener#notifyNode
 199      */
 200     @Override
 201     public void notifyNode (Node node, Action action) {
 202         LOG.info("notifyNode: action: {}, Node <{}>", action, node);
 203
 204         if ((action.equals(Action.ADD)) && (southbound.getBridge(node) != null)) {
 205             networkingProviderManager.getProvider(node).initializeOFFlowRules(node);
 206         }
 207     }
 208
 209     /**
 210      * Process the event.
 211      *
 212      * @param abstractEvent the {@link org.opendaylight.ovsdb.openstack.netvirt.AbstractEvent} event to be handled.
 213      * @see org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher
 214      */
 215     @Override
 216     public void processEvent(AbstractEvent abstractEvent) {
 217         if (!(abstractEvent instanceof SouthboundEvent)) {
 218             LOG.error("processEvent: Unable to process abstract event {}", abstractEvent);
 219             return;
 220         }
 221         SouthboundEvent ev = (SouthboundEvent) abstractEvent;
 222         LOG.trace("processEvent: {}", ev);
 223         switch (ev.getType()) {
 224             case NODE:
 225                 processOvsdbNodeEvent(ev);
 226                 break;
 227
 228             case BRIDGE:
 229                 processBridgeEvent(ev);
 230                 break;
 231
 232             case PORT:
 233                 processPortEvent(ev);
 234                 break;
 235
 236             case OPENVSWITCH:
 237                 processOpenVSwitchEvent(ev);
 238                 break;
 239
 240             default:
 241                 LOG.warn("Unable to process type {} action {} for node {}", ev.getType(), ev.getAction(), ev.getNode());
 242                 break;
 243         }
 244     }
 245
 246     private void processOvsdbNodeEvent(SouthboundEvent ev) {
 247         switch (ev.getAction()) {
 248             case ADD:
 249                 processOvsdbNodeCreate(ev.getNode(), (OvsdbNodeAugmentation) ev.getAugmentationData());
 250                 break;
 251             case UPDATE:
 252                 processOvsdbNodeUpdate(ev.getNode(), (OvsdbNodeAugmentation) ev.getAugmentationData());
 253                 break;
 254             case DELETE:
 255                 processOvsdbNodeDelete(ev.getNode(), (OvsdbNodeAugmentation) ev.getAugmentationData());
 256                 break;
 257         }
 258     }
 259
 260     private void processOvsdbNodeCreate(Node node, OvsdbNodeAugmentation ovsdbNode) {
 261         LOG.info("processOvsdbNodeCreate <{}> <{}>", node, ovsdbNode);
 262         nodeCacheManager.nodeAdded(node);
 263         bridgeConfigurationManager.prepareNode(node);
 264     }
 265
 266     private void processOvsdbNodeUpdate(Node node, OvsdbNodeAugmentation ovsdbNode) {
 267         LOG.info("processOvsdbNodeUpdate <{}> <{}>", node, ovsdbNode);
 268         nodeCacheManager.nodeAdded(node);
 269     }
 270
 271     private void processOvsdbNodeDelete(Node node, OvsdbNodeAugmentation ovsdbNode) {
 272         LOG.info("processOvsdbNodeDelete <{}> <{}>", node, ovsdbNode);
 273         nodeCacheManager.nodeRemoved(node);
 274         /* TODO SB_MIGRATION
 275         * I don't think we want to do this yet
 276         InstanceIdentifier<Node> bridgeNodeIid =
 277                 MdsalHelper.createInstanceIdentifier(ovsdbNode.getConnectionInfo(),
 278                         Constants.INTEGRATION_BRIDGE);
 279         southbound.delete(LogicalDatastoreType.CONFIGURATION, bridgeNodeIid);
 280         */
 281     }
 282
 283     private void processPortEvent(SouthboundEvent ev) {
 284         switch (ev.getAction()) {
 285             case ADD:
 286             case UPDATE:
 287                 processPortUpdate(ev.getNode(), (OvsdbTerminationPointAugmentation) ev.getAugmentationData());
 288                 break;
 289             case DELETE:
 290                 processPortDelete(ev.getNode(), (OvsdbTerminationPointAugmentation) ev.getAugmentationData(), null);
 291                 break;
 292         }
 293     }
 294
 295     private void processPortUpdate(Node node, OvsdbTerminationPointAugmentation port) {
 296         LOG.debug("processPortUpdate <{}> <{}>", node, port);
 297         NeutronNetwork network = tenantNetworkManager.getTenantNetwork(port);
 298         if (network != null ){
 299             if(!network.getRouterExternal()){
 300                 this.handleInterfaceUpdate(node, port);
 301             }
 302         }
 303     }
 304
 305     private void processOpenVSwitchEvent(SouthboundEvent ev) {
 306         switch (ev.getAction()) {
 307             case ADD:
 308             case UPDATE:
 309                 processOpenVSwitchUpdate(ev.getNode());
 310                 break;
 311             case DELETE:
 312                 break;
 313         }
 314     }
 315
 316     private void processOpenVSwitchUpdate(Node node) {
 317         LOG.debug("processOpenVSwitchUpdate {}", node);
 318         // TODO this node might be the OvsdbNode and not have termination points
 319         // Would need to change listener or grab tp nodes in here.
 320         List<TerminationPoint> terminationPoints = southbound.extractTerminationPoints(node);
 321         for (TerminationPoint terminationPoint : terminationPoints) {
 322             processPortUpdate(node, terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class));
 323         }
 324     }
 325
 326     private void processBridgeEvent(SouthboundEvent ev) {
 327         switch (ev.getAction()) {
 328             case ADD:
 329                 processBridgeCreate(ev.getNode(), (OvsdbBridgeAugmentation) ev.getAugmentationData());
 330                 break;
 331             case UPDATE:
 332                 processBridgeUpdate(ev.getNode(), (OvsdbBridgeAugmentation) ev.getAugmentationData());
 333                 break;
 334             case DELETE:
 335                 processBridgeDelete(ev.getNode(), (OvsdbBridgeAugmentation) ev.getAugmentationData());
 336                 break;
 337         }
 338     }
 339
 340     private void processBridgeCreate(Node node, OvsdbBridgeAugmentation bridge) {
 341         LOG.debug("processBridgeCreate <{}> <{}>", node, bridge);
 342         String datapathId = southbound.getDatapathId(bridge);
 343         // Having a datapathId means the ovsdb node has connected to ODL
 344         if (datapathId != null) {
 345             nodeCacheManager.nodeAdded(node);
 346         } else {
 347             LOG.info("processBridgeCreate datapathId not found");
 348         }
 349     }
 350
 351     private void processBridgeUpdate(Node node, OvsdbBridgeAugmentation bridge) {
 352         LOG.debug("processBridgeUpdate <{}> <{}>", node, bridge);
 353         String datapathId = southbound.getDatapathId(bridge);
 354         // Having a datapathId means the ovsdb node has connected to ODL
 355         if (datapathId != null) {
 356             nodeCacheManager.nodeAdded(node);
 357         } else {
 358             LOG.info("processBridgeUpdate datapathId not found");
 359         }
 360     }
 361
 362     private void processBridgeDelete(Node node, OvsdbBridgeAugmentation bridge) {
 363         LOG.debug("processBridgeDelete: Delete bridge from config data store: <{}> <{}>",
 364                 node, bridge);
 365         nodeCacheManager.nodeRemoved(node);
 366         // TODO SB_MIGRATION
 367         // Not sure if we want to do this yet
 368         southbound.deleteBridge(node);
 369     }
 370
 371     @Override
 372     public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
 373         configurationService =
 374                 (ConfigurationService) ServiceHelper.getGlobalInstance(ConfigurationService.class, this);
 375         networkingProviderManager =
 376                 (NetworkingProviderManager) ServiceHelper.getGlobalInstance(NetworkingProviderManager.class, this);
 377         tenantNetworkManager =
 378                 (TenantNetworkManager) ServiceHelper.getGlobalInstance(TenantNetworkManager.class, this);
 379         bridgeConfigurationManager =
 380                 (BridgeConfigurationManager) ServiceHelper.getGlobalInstance(BridgeConfigurationManager.class, this);
 381         nodeCacheManager =
 382                 (NodeCacheManager) ServiceHelper.getGlobalInstance(NodeCacheManager.class, this);
 383         nodeCacheManager.cacheListenerAdded(
 384                 bundleContext.getServiceReference(OvsdbInventoryListener.class.getName()), this);
 385         neutronL3Adapter =
 386                 (NeutronL3Adapter) ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, this);
 387         southbound =
 388                 (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
 389         eventDispatcher =
 390                 (EventDispatcher) ServiceHelper.getGlobalInstance(EventDispatcher.class, this);
 391         eventDispatcher.eventHandlerAdded(
 392                 bundleContext.getServiceReference(OvsdbInventoryListener.class.getName()), this);
 393         ovsdbInventoryService =
 394                 (OvsdbInventoryService) ServiceHelper.getGlobalInstance(OvsdbInventoryService.class, this);
 395         ovsdbInventoryService.listenerAdded(this);
 396     }
 397
 398     @Override
 399     public void setDependencies(Object impl) {
 400     }
 401 }