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

   1 /*
   2  * Copyright (c) 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 package org.opendaylight.ovsdb.openstack.netvirt.impl;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.collect.ImmutableBiMap;
  12 import com.google.common.util.concurrent.CheckedFuture;
  13 import java.security.InvalidParameterException;
  14 import java.util.ArrayList;
  15 import java.util.List;
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  18 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  19 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  20 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  21 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  22 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  23 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  40 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  41 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  42 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  43 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  44 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  45 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  47 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 /**
  52  * Utility class to wrap mdsal transactions.
  53  *
  54  * @author Sam Hague (shague@redhat.com)
  55  */
  56 public class MdsalUtils {
  57     private static final Logger LOG = LoggerFactory.getLogger(MdsalUtils.class);
  58     private static DataBroker databroker = null;
  59     private static final int OVSDB_UPDATE_TIMEOUT = 500;
  60
  61     /**
  62      * Class constructor setting the data broker.
  63      *
  64      * @param dataBroker the {@link org.opendaylight.controller.md.sal.binding.api.DataBroker}
  65      */
  66     public MdsalUtils(DataBroker dataBroker) {
  67         this.databroker = dataBroker;
  68     }
  69
  70     /**
  71      * Executes delete as a blocking transaction.
  72      *
  73      * @param store {@link LogicalDatastoreType} which should be modified
  74      * @param path {@link InstanceIdentifier} to read from
  75      * @param <D> the data object type
  76      * @return the result of the request
  77      */
  78     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean delete(
  79             final LogicalDatastoreType store, final InstanceIdentifier<D> path)  {
  80         boolean result = false;
  81         final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
  82         transaction.delete(store, path);
  83         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
  84         try {
  85             future.checkedGet();
  86             result = true;
  87         } catch (TransactionCommitFailedException e) {
  88             LOG.warn("Failed to delete {} ", path, e);
  89         }
  90         return result;
  91     }
  92
  93     /**
  94      * Executes merge as a blocking transaction.
  95      *
  96      * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
  97      * @param path {@link InstanceIdentifier} for path to read
  98      * @param <D> the data object type
  99      * @return the result of the request
 100      */
 101     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean merge(
 102             final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data)  {
 103         boolean result = false;
 104         final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
 105         transaction.merge(logicalDatastoreType, path, data, true);
 106         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 107         try {
 108             future.checkedGet();
 109             result = true;
 110         } catch (TransactionCommitFailedException e) {
 111             LOG.warn("Failed to merge {} ", path, e);
 112         }
 113         return result;
 114     }
 115
 116     /**
 117      * Executes put as a blocking transaction.
 118      *
 119      * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
 120      * @param path {@link InstanceIdentifier} for path to read
 121      * @param <D> the data object type
 122      * @return the result of the request
 123      */
 124     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean put(
 125             final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data)  {
 126         boolean result = false;
 127         final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
 128         transaction.put(logicalDatastoreType, path, data, true);
 129         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 130         try {
 131             future.checkedGet();
 132             result = true;
 133         } catch (TransactionCommitFailedException e) {
 134             LOG.warn("Failed to put {} ", path, e);
 135         }
 136         return result;
 137     }
 138
 139     /**
 140      * Executes read as a blocking transaction.
 141      *
 142      * @param store {@link LogicalDatastoreType} to read
 143      * @param path {@link InstanceIdentifier} for path to read
 144      * @param <D> the data object type
 145      * @return the result as the data object requested
 146      */
 147     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> D read(
 148             final LogicalDatastoreType store, final InstanceIdentifier<D> path)  {
 149         D result = null;
 150         final ReadOnlyTransaction transaction = databroker.newReadOnlyTransaction();
 151         Optional<D> optionalDataObject;
 152         CheckedFuture<Optional<D>, ReadFailedException> future = transaction.read(store, path);
 153         try {
 154             optionalDataObject = future.checkedGet();
 155             if (optionalDataObject.isPresent()) {
 156                 result = optionalDataObject.get();
 157             } else {
 158                 LOG.debug("{}: Failed to read {}",
 159                         Thread.currentThread().getStackTrace()[1], path);
 160             }
 161         } catch (ReadFailedException e) {
 162             LOG.warn("Failed to read {} ", path, e);
 163         }
 164         transaction.close();
 165         return result;
 166     }
 167
 168     public static String getOptionsValue(List<Options> options, String key) {
 169         String value = null;
 170         for (Options option : options) {
 171             if (option.getKey().equals(key)) {
 172                 value = option.getValue();
 173             }
 174         }
 175         return value;
 176     }
 177
 178     public static String getInterfaceExternalIdsValue(OvsdbTerminationPointAugmentation terminationPointAugmentation,
 179                                                       String key) {
 180         String value = null;
 181         List<InterfaceExternalIds> pairs = terminationPointAugmentation.getInterfaceExternalIds();
 182         for (InterfaceExternalIds pair : pairs) {
 183             if (pair.getKey().equals(key)) {
 184                 value = pair.getExternalIdValue();
 185             }
 186         }
 187         return value;
 188     }
 189
 190     public static ConnectionInfo getConnectionInfo(Node node) {
 191         ConnectionInfo connectionInfo = null;
 192         OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
 193         if (ovsdbNodeAugmentation != null) {
 194             connectionInfo = ovsdbNodeAugmentation.getConnectionInfo();
 195         }
 196         return connectionInfo;
 197     }
 198
 199     public static OvsdbBridgeAugmentation getBridge(Node node, String name) {
 200         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = null;
 201         ConnectionInfo connectionInfo = getConnectionInfo(node);
 202         if (connectionInfo != null) {
 203             InstanceIdentifier<Node> bridgeIid =
 204                     SouthboundMapper.createInstanceIdentifier(connectionInfo,
 205                             new OvsdbBridgeName(name));
 206             Node bridgeNode = read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
 207             if (bridgeNode != null) {
 208                 ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
 209             }
 210         }
 211         return ovsdbBridgeAugmentation;
 212     }
 213
 214     public static Uuid getBridgeUuid(Node node, String name) {
 215         Uuid uuid = null;
 216         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = getBridge(node, name);
 217         if (ovsdbBridgeAugmentation != null) {
 218             uuid = ovsdbBridgeAugmentation.getBridgeUuid();
 219         }
 220         return uuid;
 221     }
 222
 223     public static boolean addBridge(Node ovsdbNode, String bridgeName, String target)
 224             throws InterruptedException, InvalidParameterException {
 225         boolean result = false;
 226
 227         LOG.info("addBridge: node: {}, bridgeName: {}, target: {}", ovsdbNode, bridgeName, target);
 228         ConnectionInfo connectionInfo = getConnectionInfo(ovsdbNode);
 229         if (connectionInfo != null) {
 230             NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 231             InstanceIdentifier<Node> bridgeIid =
 232                     SouthboundMapper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
 233             NodeId bridgeNodeId = SouthboundMapper.createManagedNodeId(bridgeIid);
 234             bridgeNodeBuilder.setNodeId(bridgeNodeId);
 235             OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 236             //ovsdbBridgeAugmentationBuilder.setControllerEntry(setControllerEntries(target));
 237             ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
 238             ovsdbBridgeAugmentationBuilder.setProtocolEntry(createMdsalProtocols());
 239             ovsdbBridgeAugmentationBuilder.setFailMode(
 240                     SouthboundConstants.OVSDB_FAIL_MODE_MAP.inverse().get("secure"));
 241             setManagedBy(ovsdbBridgeAugmentationBuilder, connectionInfo);
 242             bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
 243
 244             result = merge(LogicalDatastoreType.CONFIGURATION, bridgeIid, bridgeNodeBuilder.build());
 245             LOG.info("addBridge: result: {}", result);
 246             Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 247             addController(ovsdbNode, bridgeName, target);
 248             Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 249         } else {
 250             throw new InvalidParameterException("Could not find ConnectionInfo");
 251         }
 252
 253         return result;
 254     }
 255
 256     private static void setManagedBy(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder,
 257                                      ConnectionInfo connectionInfo) {
 258         InstanceIdentifier<Node> connectionNodePath = SouthboundMapper.createInstanceIdentifier(connectionInfo);
 259         ovsdbBridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(connectionNodePath));
 260     }
 261
 262     private static void addController(Node ovsdbNode, String bridgeName, String targetString) {
 263         ConnectionInfo connectionInfo = getConnectionInfo(ovsdbNode);
 264         if (connectionInfo != null) {
 265             for (ControllerEntry controllerEntry: setControllerEntries(targetString)) {
 266                 InstanceIdentifier<ControllerEntry> iid =
 267                         SouthboundMapper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName))
 268                                 .augmentation(OvsdbBridgeAugmentation.class)
 269                                 .child(ControllerEntry.class, controllerEntry.getKey());
 270
 271                 boolean result = put(LogicalDatastoreType.CONFIGURATION, iid, controllerEntry);
 272                 LOG.info("addController: result: {}", result);
 273             }
 274         }
 275     }
 276
 277     private static List<ControllerEntry> setControllerEntries(String targetString) {
 278         List<ControllerEntry> controllerEntries = new ArrayList<ControllerEntry>();
 279         ControllerEntryBuilder controllerEntryBuilder = new ControllerEntryBuilder();
 280         controllerEntryBuilder.setTarget(new Uri(targetString));
 281         controllerEntries.add(controllerEntryBuilder.build());
 282         return controllerEntries;
 283     }
 284
 285     private static List<ProtocolEntry> createMdsalProtocols() {
 286         List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
 287         ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
 288                 SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
 289         protocolList.add(new ProtocolEntryBuilder().
 290                 setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build());
 291         return protocolList;
 292     }
 293
 294     public static OvsdbTerminationPointAugmentation getTerminationPointAugmentation(Node bridgeNode, String portName) {
 295         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
 296         if (ovsdbBridgeAugmentation != null) {
 297             List<TerminationPoint> terminationPoints = bridgeNode.getTerminationPoint();
 298             for(TerminationPoint terminationPoint : terminationPoints) {
 299                 OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
 300                         terminationPoint.getAugmentation( OvsdbTerminationPointAugmentation.class);
 301                 if (ovsdbTerminationPointAugmentation != null
 302                         && ovsdbTerminationPointAugmentation.getName().equals(portName)) {
 303                     return ovsdbTerminationPointAugmentation;
 304                 }
 305             }
 306         }
 307         return null;
 308     }
 309
 310     private static Topology getOvsdbTopology() {
 311         InstanceIdentifier<Topology> path = InstanceIdentifier
 312                 .create(NetworkTopology.class)
 313                 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
 314
 315         Topology topology = read(LogicalDatastoreType.OPERATIONAL, path);
 316         return topology;
 317     }
 318
 319     public static String getDataPathId(Node node) {
 320         return (node.getAugmentation(OvsdbBridgeAugmentation.class).getDatapathId().getValue());
 321     }
 322
 323     public static String getBridgeName(Node node) {
 324         return (node.getAugmentation(OvsdbBridgeAugmentation.class).getBridgeName().getValue());
 325     }
 326 }