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

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