neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/InventoryHelper.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, 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 package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util;
   9
  10 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getOvsdbBridgeFromTerminationPoint;
  11 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getOvsdbTerminationPoint;
  12 import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
  13 import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.submitToDs;
  14
  15 import com.google.common.base.Optional;
  16
  17 import java.util.ArrayList;
  18 import java.util.HashSet;
  19 import java.util.List;
  20 import java.util.Set;
  21
  22 import org.apache.commons.lang3.StringUtils;
  23 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  24 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  25 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  26 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  27 import org.opendaylight.groupbasedpolicy.neutron.ovsdb.AbstractTunnelType;
  28 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfig;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfigBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.ExternalInterfaces;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.ExternalInterfacesBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.ExternalInterfacesKey;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.Tunnel;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.TunnelBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  45 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48
  49 public class InventoryHelper {
  50
  51     private static final Logger LOG = LoggerFactory.getLogger(InventoryHelper.class);
  52     private static final String HEX = "0x";
  53
  54     /**
  55      * Convert an OpenFlow Datapath ID to a Long.
  56      *
  57      * @param dpid The OpenFlow Datapath ID
  58      * @return The Long representation of the DPID
  59      */
  60     public static Long getLongFromDpid(String dpid) {
  61         String[] addressInBytes = dpid.split(":");
  62         Long address = (Long.decode(HEX + addressInBytes[2]) << 40) | (Long.decode(HEX + addressInBytes[3]) << 32)
  63                 | (Long.decode(HEX + addressInBytes[4]) << 24) | (Long.decode(HEX + addressInBytes[5]) << 16)
  64                 | (Long.decode(HEX + addressInBytes[6]) << 8) | (Long.decode(HEX + addressInBytes[7]));
  65         return address;
  66     }
  67
  68     private static final Long MAX_OF_PORT = 65534L;
  69
  70     /**
  71      * Construct a String that can be used to create a {@link NodeId}.
  72      * The String is constructed by getting the Datapath ID from the OVSDB bridge
  73      * augmentation, converting that to a Long, and prepending it with the
  74      * "openflow:" prefix.
  75      *
  76      * @param ovsdbBridge The {@link OvsdbBridgeAugmentation}
  77      * @param ovsdbTpIid the {@link OvsdbTerminationPointAugmentation}
  78      * @param dataBroker the {@link DataBroker}
  79      * @return String representation of the Inventory NodeId, null if it fails
  80      */
  81     public static String getInventoryNodeIdString(OvsdbBridgeAugmentation ovsdbBridge,
  82             InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid, DataBroker dataBroker) {
  83         DatapathId dpid = ovsdbBridge.getDatapathId();
  84         if (dpid == null) {
  85             OvsdbBridgeAugmentation bridgeData = getOvsdbBridgeFromTerminationPoint(ovsdbTpIid, dataBroker);
  86             dpid = bridgeData.getDatapathId();
  87             if (dpid == null) {
  88                 LOG.error("No Data Path ID for OVSDB Bridge {}", ovsdbBridge);
  89                 return null;
  90             }
  91         }
  92         Long macLong = getLongFromDpid(ovsdbBridge.getDatapathId().getValue());
  93         String nodeIdString = "openflow:" + String.valueOf(macLong);
  94         if (StringUtils.countMatches(nodeIdString, ":") != 1) {
  95             LOG.error("{} is not correct format for NodeId.", nodeIdString);
  96             return null;
  97         }
  98         return nodeIdString;
  99     }
 100
 101     /**
 102      * Construct a string that can be used to create a
 103      * {@link org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId}.
 104      * The String is constructed by first getting the inventory Node ID string, and then
 105      * adding the port number obtained by the OVSDB augmentation.
 106      *
 107      * @param inventoryNodeId The string representation of the Inventory NodeId
 108      * @param ovsdbTp The {@link OvsdbTerminationPointAugmentation}
 109      * @param tpIid the InstanceIdentifier for OvsdbTerminationPointAugmentation
 110      * @param dataBroker the {@link DataBroker}
 111      * @return String representation of the Inventory NodeConnectorId, null if it fails
 112      */
 113     public static String getInventoryNodeConnectorIdString(String inventoryNodeId,
 114             OvsdbTerminationPointAugmentation ovsdbTp, InstanceIdentifier<OvsdbTerminationPointAugmentation> tpIid,
 115             DataBroker dataBroker) {
 116         Long ofport = null;
 117         if (ovsdbTp.getOfport() != null && ovsdbTp.getOfport() > MAX_OF_PORT) {
 118             LOG.debug("Invalid OpenFlow port {} for {}", ovsdbTp.getOfport(), ovsdbTp);
 119             return null;
 120         }
 121         if (ovsdbTp.getOfport() == null) {
 122             OvsdbTerminationPointAugmentation readOvsdbTp = getOvsdbTerminationPoint(tpIid, dataBroker);
 123             if (readOvsdbTp == null || readOvsdbTp.getOfport() == null || readOvsdbTp.getOfport() > MAX_OF_PORT) {
 124                 LOG.debug("Couldn't get OpenFlow port for {}", ovsdbTp);
 125                 return null;
 126             }
 127             ofport = readOvsdbTp.getOfport();
 128         } else {
 129             ofport = ovsdbTp.getOfport();
 130         }
 131         String nodeConnectorIdString = inventoryNodeId + ":" + String.valueOf(ofport);
 132
 133         if (StringUtils.countMatches(nodeConnectorIdString, ":") != 2) {
 134             LOG.error("{} is not correct format for NodeConnectorId.", nodeConnectorIdString);
 135             return null;
 136         }
 137         return nodeConnectorIdString;
 138     }
 139
 140     /**
 141      * Read the {@link OfOverlayNodeConfig} augmentation from the
 142      * Inventory Node, and verify that the tunnel types we need
 143      * are present.
 144      *
 145      * @param nodeIdString The inventory node id string
 146      * @param requiredTunnelTypes the list of tunnel types
 147      * @param dataBroker the {@link DataBroker}
 148      * @return true if tunnel types are present, false otherwise
 149      */
 150     public static boolean checkOfOverlayConfig(String nodeIdString, List<AbstractTunnelType> requiredTunnelTypes,
 151             DataBroker dataBroker) {
 152         OfOverlayNodeConfig config = getOfOverlayConfig(nodeIdString, dataBroker);
 153         if (config == null || config.getTunnel() == null) {
 154             LOG.debug("No OfOverlay config for {}", nodeIdString);
 155             return false;
 156         }
 157
 158         /*
 159          * See if the OfOverlayNodeConfig has the
 160          * tunnel type information.
 161          */
 162         for (AbstractTunnelType tunnelType : requiredTunnelTypes) {
 163             boolean tunnelPresent = false;
 164             for (Tunnel tunnel : config.getTunnel()) {
 165                 if (tunnelType.getTunnelType().equals(tunnel.getTunnelType())) {
 166                     tunnelPresent = true;
 167                     break;
 168                 }
 169             }
 170             if (tunnelPresent == false) {
 171                 return false;
 172             }
 173         }
 174         return true;
 175     }
 176
 177     public static InstanceIdentifier<ExternalInterfaces> addOfOverlayExternalPort(NodeId nodeId, NodeConnectorId ncId,
 178         DataBroker dataBroker) {
 179         InstanceIdentifier<ExternalInterfaces> nodeExternalInterfacesIid = InstanceIdentifier.builder(Nodes.class)
 180             .child(Node.class, new NodeKey(nodeId))
 181             .augmentation(OfOverlayNodeConfig.class)
 182             .child(ExternalInterfaces.class, new ExternalInterfacesKey(ncId))
 183             .build();
 184
 185         ExternalInterfaces externalInterfaces = new ExternalInterfacesBuilder().setKey(new ExternalInterfacesKey(ncId))
 186             .setNodeConnectorId(ncId)
 187             .build();
 188         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 189         transaction.put(LogicalDatastoreType.CONFIGURATION, nodeExternalInterfacesIid, externalInterfaces, true);
 190         DataStoreHelper.submitToDs(transaction);
 191         LOG.trace("Added external interface node connector {} to node {}", ncId.getValue(), nodeId.getValue());
 192         return nodeExternalInterfacesIid;
 193     }
 194
 195     public static OfOverlayNodeConfig getOfOverlayConfig(String nodeIdString, DataBroker dataBroker) {
 196         InstanceIdentifier<OfOverlayNodeConfig> ofOverlayNodeIid = InstanceIdentifier.builder(Nodes.class)
 197             .child(Node.class, new NodeKey(new NodeId(nodeIdString)))
 198             .augmentation(OfOverlayNodeConfig.class)
 199             .build();
 200
 201         ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
 202         Optional<OfOverlayNodeConfig> overlayConfig = readFromDs(LogicalDatastoreType.CONFIGURATION, ofOverlayNodeIid,
 203                 transaction);
 204         if (overlayConfig.isPresent()) {
 205             return overlayConfig.get();
 206         }
 207         return null;
 208     }
 209
 210     /**
 211      * Update the {@link OfOverlayNodeConfig} of an Inventory Node
 212      * using the new tunnel state.
 213      *
 214      * @param ip the ipaddress
 215      * @param nodeIdString the string representation of the inventory NodeId
 216      * @param nodeConnectorIdString the string representation of the inventory NodeConnectorId
 217      * @param tunnelType the tunnel type
 218      * @param dataBroker the {@link DataBroker}
 219      */
 220     public static void updateOfOverlayConfig(IpAddress ip, String nodeIdString, String nodeConnectorIdString,
 221             AbstractTunnelType tunnelType, DataBroker dataBroker) {
 222
 223         if ((ip == null) || (nodeIdString == null) || (nodeConnectorIdString == null)) {
 224             LOG.debug("Can't update OfOverlay: requisite information not present");
 225             return;
 226         }
 227         NodeConnectorId nodeConnectorId = new NodeConnectorId(nodeConnectorIdString);
 228
 229
 230         // Pull existing augmentation
 231         OfOverlayNodeConfig ofConfig = getOfOverlayConfig(nodeIdString, dataBroker);
 232
 233         // If it exists, use it in new augmentation constructor, else new augmentation
 234         OfOverlayNodeConfigBuilder ofOverlayNodeConfigBuilder;
 235         Set<Tunnel> existingTunnels = new HashSet<Tunnel>();
 236         if (ofConfig != null) {
 237             ofOverlayNodeConfigBuilder = new OfOverlayNodeConfigBuilder(ofConfig);
 238             if (ofConfig.getTunnel() != null) {
 239                 existingTunnels.addAll(ofConfig.getTunnel());
 240             }
 241         } else {
 242             ofOverlayNodeConfigBuilder = new OfOverlayNodeConfigBuilder();
 243         }
 244
 245         // Determine if this is an update to existing tunnel of this type or a new tunnel
 246         boolean tunnelsUpdated = false;
 247         TunnelBuilder tunnelBuilder = new TunnelBuilder();
 248
 249         boolean tunnelFound = false;
 250         for (Tunnel currentTun : existingTunnels) {
 251             if (tunnelType.getTunnelType().equals(currentTun.getTunnelType())) {
 252                 // tunnel update
 253                 tunnelBuilder.setIp(ip);
 254                 tunnelBuilder.setPort(tunnelType.getPortNumber());
 255                 tunnelBuilder.setNodeConnectorId(nodeConnectorId);
 256                 tunnelBuilder.setTunnelType(tunnelType.getTunnelType());
 257                 tunnelFound = true;
 258                 tunnelsUpdated = true;
 259                 break;
 260             }
 261         }
 262         // new tunnel
 263         if (tunnelFound == false) {
 264             tunnelBuilder.setIp(ip);
 265             tunnelBuilder.setPort(tunnelType.getPortNumber());
 266             tunnelBuilder.setNodeConnectorId(nodeConnectorId);
 267             tunnelBuilder.setTunnelType(tunnelType.getTunnelType());
 268             tunnelsUpdated = true;
 269         }
 270
 271         // Nothing was updated, nothing to see here, move along...
 272         if (tunnelsUpdated == false) {
 273             return;
 274         }
 275
 276         existingTunnels.add(tunnelBuilder.build());
 277
 278         // Update the OfOverlayNodeConfig with the new tunnel information
 279         if (!existingTunnels.isEmpty()) {
 280             ofOverlayNodeConfigBuilder.setTunnel(new ArrayList<Tunnel>(existingTunnels));
 281         }
 282         OfOverlayNodeConfig newConfig = ofOverlayNodeConfigBuilder.build();
 283         if (addOfOverlayConfig(newConfig, new NodeId(nodeIdString), dataBroker)) {
 284             LOG.trace("updateOfOverlayConfig - Added Tunnel: {} to Node: {} at NodeConnector: {}",
 285                 tunnelBuilder.build(), nodeIdString, nodeConnectorIdString);
 286         } else {
 287             LOG.error("updateOfOverlayConfig - could not write OfOverlayNodeConfig: {} to datastore.", newConfig);
 288         }
 289     }
 290
 291     public static void removeTunnelsOfOverlayConfig(String nodeIdString,
 292                                                     List<AbstractTunnelType> tunnels,
 293                                                     DataBroker dataBroker) {
 294
 295         if (nodeIdString == null) {
 296             LOG.debug("Can't update OfOverlay: requisite information not present");
 297             return;
 298         }
 299         List<Tunnel> existingTunnels = new ArrayList<>();
 300         OfOverlayNodeConfig ofConfig = getOfOverlayConfig(nodeIdString, dataBroker);
 301         if (ofConfig != null) {
 302             existingTunnels = ofConfig.getTunnel();
 303         }
 304         Set<Tunnel> tunnelsToRemove = new HashSet<>();
 305         for (AbstractTunnelType tunnelType : tunnels) {
 306             for (Tunnel currentTun : existingTunnels) {
 307                 if (tunnelType.getTunnelType().equals(currentTun.getTunnelType())) {
 308                     tunnelsToRemove.add(currentTun);
 309                 }
 310             }
 311         }
 312
 313         // runs only if some tunnels were really removed
 314         if (existingTunnels.removeAll(tunnelsToRemove)) {
 315             ReadWriteTransaction writeTx = dataBroker.newReadWriteTransaction();
 316             for (Tunnel tunnel : tunnelsToRemove) {
 317                 InstanceIdentifier<Tunnel> tunnelIid = InstanceIdentifier.builder(Nodes.class)
 318                     .child(Node.class, new NodeKey(new NodeId(nodeIdString)))
 319                     .augmentation(OfOverlayNodeConfig.class)
 320                     .child(Tunnel.class, tunnel.getKey())
 321                     .build();
 322                 writeTx.delete(LogicalDatastoreType.CONFIGURATION, tunnelIid);
 323                 LOG.trace("Removing tunnel: {} from node {}",tunnel, nodeIdString);
 324             }
 325             submitToDs(writeTx);
 326         }
 327     }
 328
 329     private static boolean addOfOverlayConfig(OfOverlayNodeConfig newConfig, NodeId nodeId, DataBroker dataBroker) {
 330         ReadWriteTransaction writeTx = dataBroker.newReadWriteTransaction();
 331         InstanceIdentifier<OfOverlayNodeConfig> ofOverlayNodeIid = InstanceIdentifier.builder(Nodes.class)
 332             .child(Node.class, new NodeKey(nodeId))
 333             .augmentation(OfOverlayNodeConfig.class)
 334             .build();
 335         writeTx.put(LogicalDatastoreType.CONFIGURATION, ofOverlayNodeIid, newConfig, true);
 336         LOG.trace("Adding tunnel: {} to node {}", newConfig, nodeId.getValue());
 337         return submitToDs(writeTx);
 338     }
 339
 340     private static boolean addTunnelsOfOverlayConfig(List<Tunnel> tunnels, NodeId nodeId, DataBroker dataBroker) {
 341         ReadWriteTransaction writeTx = dataBroker.newReadWriteTransaction();
 342         for (Tunnel tunnel : tunnels) {
 343             InstanceIdentifier<Tunnel> tunnelIid = InstanceIdentifier.builder(Nodes.class)
 344                 .child(Node.class, new NodeKey(nodeId))
 345                 .augmentation(OfOverlayNodeConfig.class)
 346                 .child(Tunnel.class, tunnel.getKey())
 347                 .build();
 348             writeTx.put(LogicalDatastoreType.CONFIGURATION, tunnelIid, tunnel, true);
 349             LOG.trace("Adding tunnel: {} to node {}",tunnel, nodeId.getValue());
 350         }
 351         return submitToDs(writeTx);
 352     }
 353 }