southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TerminationPointUpdateCommand.java

   1 /*
   2  * Copyright © 2015, 2017 Brocade Communications 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.ovsdb.southbound.ovsdb.transact;
   9
  10 import static org.opendaylight.ovsdb.lib.operations.Operations.op;
  11 import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
  12
  13 import com.google.common.base.Optional;
  14 import com.google.common.util.concurrent.CheckedFuture;
  15 import java.util.Collection;
  16 import java.util.Collections;
  17 import java.util.HashMap;
  18 import java.util.HashSet;
  19 import java.util.List;
  20 import java.util.Map;
  21 import java.util.Map.Entry;
  22 import java.util.Set;
  23 import java.util.concurrent.ExecutionException;
  24 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
  25 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  26 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  27 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  28 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  29 import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
  30 import org.opendaylight.ovsdb.lib.notation.UUID;
  31 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
  32 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  33 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
  34 import org.opendaylight.ovsdb.schema.openvswitch.Port;
  35 import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
  36 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  37 import org.opendaylight.ovsdb.southbound.SouthboundProvider;
  38 import org.opendaylight.ovsdb.utils.yang.YangUtils;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbQosRef;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
  55 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  56 import org.opendaylight.yangtools.yang.binding.DataObject;
  57 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  58 import org.slf4j.Logger;
  59 import org.slf4j.LoggerFactory;
  60
  61 public class TerminationPointUpdateCommand implements TransactCommand {
  62
  63     private static final Logger LOG = LoggerFactory.getLogger(TerminationPointUpdateCommand.class);
  64
  65     @Override
  66     public void execute(TransactionBuilder transaction, BridgeOperationalState state,
  67             AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> events,
  68             InstanceIdentifierCodec instanceIdentifierCodec) {
  69         execute(transaction, state,
  70                 TransactUtils.extractCreatedOrUpdated(events, OvsdbTerminationPointAugmentation.class),
  71                 instanceIdentifierCodec);
  72     }
  73
  74     @Override
  75     public void execute(TransactionBuilder transaction, BridgeOperationalState state,
  76             Collection<DataTreeModification<Node>> modifications, InstanceIdentifierCodec instanceIdentifierCodec) {
  77         execute(transaction, state,
  78                 TransactUtils.extractCreatedOrUpdated(modifications, OvsdbTerminationPointAugmentation.class),
  79                 instanceIdentifierCodec);
  80     }
  81
  82     private void execute(TransactionBuilder transaction, BridgeOperationalState state,
  83             Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
  84                     createdOrUpdated,
  85             InstanceIdentifierCodec instanceIdentifierCodec) {
  86         for (Entry<InstanceIdentifier<OvsdbTerminationPointAugmentation>,
  87                  OvsdbTerminationPointAugmentation> terminationPointEntry : createdOrUpdated.entrySet()) {
  88             updateTerminationPoint(transaction, state, terminationPointEntry.getKey(),
  89                     terminationPointEntry.getValue(), instanceIdentifierCodec);
  90         }
  91     }
  92
  93     public void updateTerminationPoint(TransactionBuilder transaction, BridgeOperationalState state,
  94             InstanceIdentifier<OvsdbTerminationPointAugmentation> iid,
  95             OvsdbTerminationPointAugmentation terminationPoint, InstanceIdentifierCodec instanceIdentifierCodec) {
  96
  97         if (terminationPoint != null) {
  98             LOG.debug("Received request to update termination point {}",
  99                    terminationPoint.getName());
 100
 101             // Update interface
 102             Interface ovsInterface =
 103                     TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Interface.class);
 104             updateInterface(terminationPoint, ovsInterface);
 105             Interface extraInterface = TyperUtils.getTypedRowWrapper(
 106                     transaction.getDatabaseSchema(), Interface.class);
 107             extraInterface.setName("");
 108             transaction.add(op.update(ovsInterface)
 109                     .where(extraInterface.getNameColumn().getSchema().opEqual(terminationPoint.getName()))
 110                     .build());
 111
 112             TerminationPointCreateCommand.stampInstanceIdentifier(transaction,
 113                     iid.firstIdentifierOf(OvsdbTerminationPointAugmentation.class), terminationPoint.getName(),
 114                     instanceIdentifierCodec);
 115
 116             // Update port
 117             // Bug#6136
 118             Optional<OvsdbBridgeAugmentation> ovsdbBridgeOptional = state.getOvsdbBridgeAugmentation(iid);
 119             if (ovsdbBridgeOptional != null && ovsdbBridgeOptional.isPresent()) {
 120                 OvsdbBridgeAugmentation operBridge = ovsdbBridgeOptional.get();
 121                 if (operBridge != null) {
 122                     Port port = TyperUtils.getTypedRowWrapper(
 123                         transaction.getDatabaseSchema(), Port.class);
 124                     updatePort(terminationPoint, port, operBridge);
 125                     Port extraPort = TyperUtils.getTypedRowWrapper(
 126                         transaction.getDatabaseSchema(), Port.class);
 127                     extraPort.setName("");
 128                     transaction.add(op.update(port)
 129                         .where(extraPort.getNameColumn().getSchema().opEqual(terminationPoint.getName()))
 130                         .build());
 131                     LOG.info("Updated Termination Point : {}  with Uuid : {}",
 132                         terminationPoint.getName(), terminationPoint.getPortUuid());
 133                 }
 134             } else {
 135                 LOG.warn("OVSDB bridge node was not found: {}", iid);
 136             }
 137         }
 138     }
 139
 140     private void updateInterface(
 141             final OvsdbTerminationPointAugmentation terminationPoint,
 142             final Interface ovsInterface) {
 143         updateOfPort(terminationPoint, ovsInterface);
 144         updateOfPortRequest(terminationPoint, ovsInterface);
 145         updateInterfaceOptions(terminationPoint, ovsInterface);
 146         updateInterfaceOtherConfig(terminationPoint, ovsInterface);
 147         updateInterfaceExternalIds(terminationPoint, ovsInterface);
 148         updateInterfaceLldp(terminationPoint, ovsInterface);
 149         updateInterfaceBfd(terminationPoint, ovsInterface);
 150         updateInterfacePolicing(terminationPoint, ovsInterface);
 151     }
 152
 153     private void updatePort(
 154             final OvsdbTerminationPointAugmentation terminationPoint,
 155             final Port port,
 156             final OvsdbBridgeAugmentation operBridge) {
 157
 158         updatePortOtherConfig(terminationPoint, port);
 159         updatePortVlanTag(terminationPoint, port);
 160         updatePortVlanTrunk(terminationPoint, port);
 161         updatePortVlanMode(terminationPoint, port);
 162         updatePortExternalIds(terminationPoint, port);
 163         updatePortQos(terminationPoint, port, operBridge);
 164     }
 165
 166     private void updatePortQos(
 167             final OvsdbTerminationPointAugmentation terminationPoint,
 168             final Port port,
 169             final OvsdbBridgeAugmentation operBridge) {
 170
 171         Set<UUID> uuidSet = new HashSet<>();
 172
 173         // First check if QosEntry is present and use that
 174         if (terminationPoint.getQosEntry() != null && !terminationPoint.getQosEntry().isEmpty()) {
 175             OvsdbQosRef qosRef = terminationPoint.getQosEntry().iterator().next().getQosRef();
 176             Uri qosId = qosRef.getValue().firstKeyOf(QosEntries.class).getQosId();
 177             OvsdbNodeAugmentation operNode = getOperNode(operBridge);
 178             if (operNode != null && operNode.getQosEntries() != null
 179                     && !operNode.getQosEntries().isEmpty()) {
 180                 for (QosEntries qosEntry : operNode.getQosEntries()) {
 181                     if (qosEntry.getQosId().equals(qosId)) {
 182                         uuidSet.add(new UUID(qosEntry.getQosUuid().getValue()));
 183                     }
 184                 }
 185             }
 186             if (uuidSet.size() == 0) {
 187                 uuidSet.add(new UUID(SouthboundConstants.QOS_NAMED_UUID_PREFIX
 188                         + TransactUtils.bytesToHexString(qosId.getValue().getBytes())));
 189             }
 190         } else {
 191             // Second check if Qos is present and use that (deprecated)
 192             // Do not bother to check if QosEntry and Qos are consistent if both are present
 193             Uuid qosUuid = terminationPoint.getQos();
 194             if (qosUuid != null) {
 195                 uuidSet.add(new UUID(qosUuid.getValue()));
 196             }
 197         }
 198         port.setQos(uuidSet);
 199     }
 200
 201     private OvsdbNodeAugmentation getOperNode(final OvsdbBridgeAugmentation operBridge) {
 202         @SuppressWarnings("unchecked")
 203         InstanceIdentifier<Node> iidNode = (InstanceIdentifier<Node>)operBridge.getManagedBy().getValue();
 204         OvsdbNodeAugmentation operNode = null;
 205         ReadOnlyTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction();
 206         CheckedFuture<Optional<Node>, ReadFailedException> future =
 207                 transaction.read(LogicalDatastoreType.OPERATIONAL, iidNode);
 208         try {
 209             Optional<Node> nodeOptional = future.get();
 210             if (nodeOptional.isPresent()) {
 211                 operNode = nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class);
 212             }
 213         } catch (InterruptedException | ExecutionException e) {
 214             LOG.warn("Error reading from datastore", e);
 215         }
 216         return operNode;
 217     }
 218
 219     private void updateOfPort(
 220             final OvsdbTerminationPointAugmentation terminationPoint,
 221             final Interface ovsInterface) {
 222
 223         Long ofPort = terminationPoint.getOfport();
 224         if (ofPort != null) {
 225             ovsInterface.setOpenFlowPort(Collections.singleton(ofPort));
 226         }
 227     }
 228
 229     private void updateOfPortRequest(
 230             final OvsdbTerminationPointAugmentation terminationPoint,
 231             final Interface ovsInterface) {
 232
 233         Integer ofPortRequest = terminationPoint.getOfportRequest();
 234         if (ofPortRequest != null) {
 235             ovsInterface.setOpenFlowPortRequest(Collections.singleton(ofPortRequest.longValue()));
 236         }
 237     }
 238
 239     private void updateInterfaceOptions(
 240             final OvsdbTerminationPointAugmentation terminationPoint,
 241             final Interface ovsInterface) {
 242
 243         //Configure optional input
 244         if (terminationPoint.getOptions() != null) {
 245             try {
 246                 ovsInterface.setOptions(YangUtils.convertYangKeyValueListToMap(terminationPoint.getOptions(),
 247                         Options::getOption, Options::getValue));
 248             } catch (NullPointerException e) {
 249                 LOG.warn("Incomplete OVSDB interface options", e);
 250             }
 251         }
 252     }
 253
 254     private void updateInterfaceExternalIds(
 255             final OvsdbTerminationPointAugmentation terminationPoint,
 256             final Interface ovsInterface) {
 257
 258         List<InterfaceExternalIds> interfaceExternalIds =
 259                 terminationPoint.getInterfaceExternalIds();
 260         if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
 261             try {
 262                 ovsInterface.setExternalIds(YangUtils.convertYangKeyValueListToMap(interfaceExternalIds,
 263                         InterfaceExternalIds::getExternalIdKey, InterfaceExternalIds::getExternalIdValue));
 264             } catch (NullPointerException e) {
 265                 LOG.warn("Incomplete OVSDB interface external_ids", e);
 266             }
 267         }
 268     }
 269
 270     private void updateInterfaceLldp(
 271             final OvsdbTerminationPointAugmentation terminationPoint,
 272             final Interface ovsInterface) {
 273
 274         try {
 275             List<InterfaceLldp> interfaceLldpList =
 276                     terminationPoint.getInterfaceLldp();
 277             if (interfaceLldpList != null && !interfaceLldpList.isEmpty()) {
 278                 try {
 279                     ovsInterface.setLldp(YangUtils.convertYangKeyValueListToMap(interfaceLldpList,
 280                             InterfaceLldp::getLldpKey, InterfaceLldp::getLldpValue));
 281                 } catch (NullPointerException e) {
 282                     LOG.warn("Incomplete OVSDB interface lldp", e);
 283                 }
 284             }
 285         } catch (SchemaVersionMismatchException e) {
 286             schemaMismatchLog("lldp", "Interface", e);
 287         }
 288     }
 289
 290     private void updateInterfaceOtherConfig(
 291             final OvsdbTerminationPointAugmentation terminationPoint,
 292             final Interface ovsInterface) {
 293
 294         List<InterfaceOtherConfigs> interfaceOtherConfigs =
 295                 terminationPoint.getInterfaceOtherConfigs();
 296         if (interfaceOtherConfigs != null && !interfaceOtherConfigs.isEmpty()) {
 297             Map<String, String> otherConfigsMap = new HashMap<>();
 298             for (InterfaceOtherConfigs interfaceOtherConfig : interfaceOtherConfigs) {
 299                 otherConfigsMap.put(interfaceOtherConfig.getOtherConfigKey(),
 300                         interfaceOtherConfig.getOtherConfigValue());
 301             }
 302             try {
 303                 ovsInterface.setOtherConfig(otherConfigsMap);
 304             } catch (NullPointerException e) {
 305                 LOG.warn("Incomplete OVSDB interface other_config", e);
 306             }
 307         }
 308     }
 309
 310     private void updateInterfaceBfd(
 311             final OvsdbTerminationPointAugmentation terminationPoint,
 312             final Interface ovsInterface) {
 313
 314         try {
 315             List<InterfaceBfd> interfaceBfdList =
 316                     terminationPoint.getInterfaceBfd();
 317             if (interfaceBfdList != null && !interfaceBfdList.isEmpty()) {
 318                 try {
 319                     ovsInterface.setBfd(YangUtils.convertYangKeyValueListToMap(interfaceBfdList,
 320                             InterfaceBfd::getBfdKey, InterfaceBfd::getBfdValue));
 321                 } catch (NullPointerException e) {
 322                     LOG.warn("Incomplete OVSDB interface bfd", e);
 323                 }
 324             }
 325         } catch (SchemaVersionMismatchException e) {
 326             schemaMismatchLog("bfd", "Interface", e);
 327         }
 328     }
 329
 330     private void updateInterfacePolicing(
 331             final OvsdbTerminationPointAugmentation terminationPoint,
 332             final Interface ovsInterface) {
 333
 334         Long ingressPolicingRate = terminationPoint.getIngressPolicingRate();
 335         if (ingressPolicingRate != null) {
 336             ovsInterface.setIngressPolicingRate(ingressPolicingRate);
 337         }
 338         Long ingressPolicingBurst = terminationPoint.getIngressPolicingBurst();
 339         if (ingressPolicingBurst != null) {
 340             ovsInterface.setIngressPolicingBurst(ingressPolicingBurst);
 341         }
 342     }
 343
 344     private void updatePortExternalIds(
 345             final OvsdbTerminationPointAugmentation terminationPoint,
 346             final Port port) {
 347
 348         List<PortExternalIds> portExternalIds = terminationPoint.getPortExternalIds();
 349         if (portExternalIds != null && !portExternalIds.isEmpty()) {
 350             try {
 351                 port.setExternalIds(YangUtils.convertYangKeyValueListToMap(portExternalIds,
 352                         PortExternalIds::getExternalIdKey, PortExternalIds::getExternalIdValue));
 353             } catch (NullPointerException e) {
 354                 LOG.warn("Incomplete OVSDB port external_ids", e);
 355             }
 356         }
 357     }
 358
 359     private void updatePortVlanTag(
 360             final OvsdbTerminationPointAugmentation terminationPoint,
 361             final Port port) {
 362
 363         if (terminationPoint.getVlanTag() != null) {
 364             Set<Long> vlanTag = new HashSet<>();
 365             vlanTag.add(terminationPoint.getVlanTag().getValue().longValue());
 366             port.setTag(vlanTag);
 367         }
 368     }
 369
 370     private void updatePortVlanTrunk(
 371             final OvsdbTerminationPointAugmentation terminationPoint,
 372             final Port port) {
 373
 374         if (terminationPoint.getTrunks() != null && terminationPoint.getTrunks().size() > 0) {
 375             Set<Long> portTrunks = new HashSet<>();
 376             List<Trunks> modelTrunks = terminationPoint.getTrunks();
 377             for (Trunks trunk : modelTrunks) {
 378                 if (trunk.getTrunk() != null) {
 379                     portTrunks.add(trunk.getTrunk().getValue().longValue());
 380                 }
 381             }
 382             port.setTrunks(portTrunks);
 383         }
 384     }
 385
 386     private void updatePortVlanMode(
 387             final OvsdbTerminationPointAugmentation terminationPoint,
 388             final Port port) {
 389         if (terminationPoint.getVlanMode() != null) {
 390             Set<String> portVlanMode = new HashSet<>();
 391             VlanMode modelVlanMode = terminationPoint.getVlanMode();
 392             portVlanMode.add(SouthboundConstants.VlanModes.values()[modelVlanMode.getIntValue() - 1].getMode());
 393             port.setVlanMode(portVlanMode);
 394         }
 395     }
 396
 397     private void updatePortOtherConfig(
 398             final OvsdbTerminationPointAugmentation terminationPoint,
 399             final Port ovsPort) {
 400         List<PortOtherConfigs> portOtherConfigs =
 401                 terminationPoint.getPortOtherConfigs();
 402         if (portOtherConfigs != null && !portOtherConfigs.isEmpty()) {
 403             try {
 404                 ovsPort.setOtherConfig(YangUtils.convertYangKeyValueListToMap(portOtherConfigs,
 405                         PortOtherConfigs::getOtherConfigKey, PortOtherConfigs::getOtherConfigValue));
 406             } catch (NullPointerException e) {
 407                 LOG.warn("Incomplete OVSDB port other_config", e);
 408             }
 409         }
 410     }
 411
 412 }