southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TerminationPointCreateCommand.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 edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  14 import java.util.Collection;
  15 import java.util.Collections;
  16 import java.util.HashMap;
  17 import java.util.HashSet;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Map.Entry;
  21 import java.util.Optional;
  22 import java.util.Set;
  23 import org.opendaylight.mdsal.binding.api.DataTreeModification;
  24 import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
  25 import org.opendaylight.ovsdb.lib.notation.Mutator;
  26 import org.opendaylight.ovsdb.lib.notation.UUID;
  27 import org.opendaylight.ovsdb.lib.operations.Mutate;
  28 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
  29 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  30 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
  31 import org.opendaylight.ovsdb.schema.openvswitch.Port;
  32 import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
  33 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  34 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  35 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
  36 import org.opendaylight.ovsdb.utils.yang.YangUtils;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdKey;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsKey;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpKey;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsKey;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsKey;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsKey;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
  54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  55 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  56 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  57 import org.opendaylight.yangtools.yang.common.Uint16;
  58 import org.opendaylight.yangtools.yang.common.Uint32;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 public class TerminationPointCreateCommand implements TransactCommand {
  63     private static final Logger LOG = LoggerFactory.getLogger(TerminationPointCreateCommand.class);
  64
  65     @Override
  66     public void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
  67             final DataChangeEvent events, final InstanceIdentifierCodec instanceIdentifierCodec) {
  68         execute(transaction, state, TransactUtils.extractCreated(events, OvsdbTerminationPointAugmentation.class),
  69                 TransactUtils.extractCreatedOrUpdated(events, Node.class), instanceIdentifierCodec);
  70     }
  71
  72     @Override
  73     public void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
  74             final Collection<DataTreeModification<Node>> modifications,
  75             final InstanceIdentifierCodec instanceIdentifierCodec) {
  76         execute(transaction, state,
  77                 TransactUtils.extractCreated(modifications, OvsdbTerminationPointAugmentation.class),
  78                 TransactUtils.extractCreatedOrUpdated(modifications, Node.class), instanceIdentifierCodec);
  79     }
  80
  81     private static void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
  82             final Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
  83                     createdTerminationPoints,
  84             final Map<InstanceIdentifier<Node>, Node> nodes, final InstanceIdentifierCodec instanceIdentifierCodec) {
  85         for (Entry<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation> entry :
  86                 createdTerminationPoints.entrySet()) {
  87             OvsdbTerminationPointAugmentation terminationPoint = entry.getValue();
  88             LOG.debug("Received request to create termination point {}",
  89                     terminationPoint.getName());
  90             InstanceIdentifier<?> terminationPointIid = entry.getKey();
  91             Optional<TerminationPoint> terminationPointOptional =
  92                     state.getBridgeTerminationPoint(terminationPointIid);
  93             if (!terminationPointOptional.isPresent()) {
  94                 // Configure interface
  95                 String interfaceUuid = "Interface_" + SouthboundMapper.getRandomUuid();
  96                 Interface ovsInterface = transaction.getTypedRowWrapper(Interface.class);
  97                 createInterface(terminationPoint, ovsInterface);
  98                 transaction.add(op.insert(ovsInterface).withId(interfaceUuid));
  99
 100                 stampInstanceIdentifier(transaction, entry.getKey(), ovsInterface.getName(), instanceIdentifierCodec);
 101
 102                 // Configure port with the above interface details
 103                 String portUuid = "Port_" + SouthboundMapper.getRandomUuid();
 104                 Port port = transaction.getTypedRowWrapper(Port.class);
 105                 final String opendaylightIid = instanceIdentifierCodec.serialize(terminationPointIid);
 106                 createPort(terminationPoint, port, interfaceUuid, opendaylightIid);
 107                 transaction.add(op.insert(port).withId(portUuid));
 108                 LOG.info("Created Termination Point : {} with Uuid : {}",
 109                         terminationPoint.getName(),portUuid);
 110                 //Configure bridge with the above port details
 111                 Bridge bridge = transaction.getTypedRowWrapper(Bridge.class);
 112                 String bridgeName = SouthboundUtil
 113                     .getBridgeNameFromOvsdbNodeId(entry.getKey().firstIdentifierOf(Node.class));
 114                 if (bridgeName != null) {
 115                     LOG.trace("Updating bridge {} for newly added port {}", bridgeName, terminationPoint.getName());
 116                     bridge.setName(bridgeName);
 117                     bridge.setPorts(Collections.singleton(new UUID(portUuid)));
 118
 119                     transaction.add(op.mutate(bridge)
 120                             .addMutation(bridge.getPortsColumn().getSchema(),
 121                                     Mutator.INSERT, bridge.getPortsColumn().getData())
 122                             .where(bridge.getNameColumn().getSchema()
 123                                     .opEqual(bridge.getNameColumn().getData())).build());
 124                 } else {
 125                     LOG.error("Missing BridgeName for Node {} during creation of port {}",
 126                             entry.getKey().firstIdentifierOf(Node.class), terminationPoint.getName());
 127                 }
 128             }
 129         }
 130
 131     }
 132
 133     private static void createInterface(
 134             final OvsdbTerminationPointAugmentation terminationPoint,
 135             final Interface ovsInterface) {
 136         ovsInterface.setName(terminationPoint.getName());
 137
 138         createInterfaceType(terminationPoint, ovsInterface);
 139         createOfPort(terminationPoint, ovsInterface);
 140         createOfPortRequest(terminationPoint, ovsInterface);
 141         createInterfaceOptions(terminationPoint, ovsInterface);
 142         createInterfaceOtherConfig(terminationPoint, ovsInterface);
 143         createInterfaceExternalIds(terminationPoint, ovsInterface);
 144         createInterfaceLldp(terminationPoint, ovsInterface);
 145         createInterfaceBfd(terminationPoint, ovsInterface);
 146     }
 147
 148     private static void createInterfaceType(final OvsdbTerminationPointAugmentation terminationPoint,
 149             final Interface ovsInterface) {
 150         InterfaceTypeBase mdsaltype = terminationPoint.getInterfaceType();
 151         if (mdsaltype != null) {
 152             ovsInterface.setType(SouthboundMapper.createOvsdbInterfaceType(mdsaltype));
 153         }
 154     }
 155
 156     private static void createPort(
 157             final OvsdbTerminationPointAugmentation terminationPoint,
 158             final Port port, final String interfaceUuid, final String opendaylightIid) {
 159
 160         port.setName(terminationPoint.getName());
 161         port.setInterfaces(Collections.singleton(new UUID(interfaceUuid)));
 162         createPortOtherConfig(terminationPoint, port);
 163         createPortVlanTag(terminationPoint, port);
 164         createPortVlanTrunk(terminationPoint, port);
 165         createPortVlanMode(terminationPoint, port);
 166         createPortExternalIds(terminationPoint, port, opendaylightIid);
 167     }
 168
 169     private static void createOfPort(
 170             final OvsdbTerminationPointAugmentation terminationPoint,
 171             final Interface ovsInterface) {
 172
 173         Uint32 ofPort = terminationPoint.getOfport();
 174         if (ofPort != null) {
 175             ovsInterface.setOpenFlowPort(Collections.singleton(ofPort.toJava()));
 176         }
 177     }
 178
 179     private static void createOfPortRequest(
 180             final OvsdbTerminationPointAugmentation terminationPoint,
 181             final Interface ovsInterface) {
 182
 183         Uint16 ofPortRequest = terminationPoint.getOfportRequest();
 184         if (ofPortRequest != null) {
 185             ovsInterface.setOpenFlowPortRequest(Collections.singleton(ofPortRequest.longValue()));
 186         }
 187     }
 188
 189     @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
 190     private static void createInterfaceOptions(
 191             final OvsdbTerminationPointAugmentation terminationPoint,
 192             final Interface ovsInterface) {
 193
 194         //Configure optional input
 195         if (terminationPoint.getOptions() != null) {
 196             try {
 197                 ovsInterface.setOptions(YangUtils.convertYangKeyValueListToMap(terminationPoint.getOptions(),
 198                         Options::getOption, Options::getValue));
 199             } catch (NullPointerException e) {
 200                 LOG.warn("Incomplete OVSDB interface options", e);
 201             }
 202         }
 203     }
 204
 205     @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
 206     private static void createInterfaceExternalIds(
 207             final OvsdbTerminationPointAugmentation terminationPoint,
 208             final Interface ovsInterface) {
 209
 210         Map<InterfaceExternalIdsKey, InterfaceExternalIds> interfaceExternalIds =
 211                 terminationPoint.getInterfaceExternalIds();
 212         final InterfaceExternalIds odl = SouthboundUtil.interfaceCreatedByOpenDaylight();
 213
 214         if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
 215             interfaceExternalIds.put(odl.key(), odl);
 216         } else {
 217             interfaceExternalIds = Map.of(odl.key(), odl);
 218         }
 219         try {
 220             ovsInterface.setExternalIds(YangUtils.convertYangKeyValueListToMap(interfaceExternalIds,
 221                     InterfaceExternalIds::getExternalIdKey, InterfaceExternalIds::getExternalIdValue));
 222         } catch (NullPointerException e) {
 223             LOG.warn("Incomplete OVSDB interface external_ids", e);
 224         }
 225     }
 226
 227     @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
 228     private static void createInterfaceOtherConfig(
 229             final OvsdbTerminationPointAugmentation terminationPoint,
 230             final Interface ovsInterface) {
 231
 232         Map<InterfaceOtherConfigsKey, InterfaceOtherConfigs> interfaceOtherConfigs =
 233                 terminationPoint.getInterfaceOtherConfigs();
 234         if (interfaceOtherConfigs != null && !interfaceOtherConfigs.isEmpty()) {
 235             Map<String, String> otherConfigsMap = new HashMap<>();
 236             for (InterfaceOtherConfigs interfaceOtherConfig : interfaceOtherConfigs.values()) {
 237                 otherConfigsMap.put(interfaceOtherConfig.getOtherConfigKey(),
 238                         interfaceOtherConfig.getOtherConfigValue());
 239             }
 240             try {
 241                 ovsInterface.setOtherConfig(otherConfigsMap);
 242             } catch (NullPointerException e) {
 243                 LOG.warn("Incomplete OVSDB interface other_config", e);
 244             }
 245         }
 246     }
 247
 248     @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
 249     private static void createInterfaceLldp(
 250             final OvsdbTerminationPointAugmentation terminationPoint,
 251             final Interface ovsInterface) {
 252
 253         try {
 254             Map<InterfaceLldpKey, InterfaceLldp> interfaceLldpList =
 255                     terminationPoint.getInterfaceLldp();
 256             if (interfaceLldpList != null && !interfaceLldpList.isEmpty()) {
 257                 try {
 258                     ovsInterface.setLldp(YangUtils.convertYangKeyValueListToMap(interfaceLldpList,
 259                             InterfaceLldp::getLldpKey, InterfaceLldp::getLldpValue));
 260                 } catch (NullPointerException e) {
 261                     LOG.warn("Incomplete OVSDB interface lldp", e);
 262                 }
 263             }
 264         } catch (SchemaVersionMismatchException e) {
 265             schemaMismatchLog("lldp", "Interface", e);
 266         }
 267     }
 268
 269     @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
 270     private static void createInterfaceBfd(final OvsdbTerminationPointAugmentation terminationPoint,
 271             final Interface ovsInterface) {
 272
 273         try {
 274             Map<InterfaceBfdKey, InterfaceBfd> interfaceBfdList = terminationPoint.getInterfaceBfd();
 275             if (interfaceBfdList != null && !interfaceBfdList.isEmpty()) {
 276                 try {
 277                     ovsInterface.setBfd(YangUtils.convertYangKeyValueListToMap(interfaceBfdList,
 278                                     InterfaceBfd::getBfdKey, InterfaceBfd::getBfdValue));
 279                 } catch (NullPointerException e) {
 280                     LOG.warn("Incomplete OVSDB interface bfd", e);
 281                 }
 282             }
 283         } catch (SchemaVersionMismatchException e) {
 284             schemaMismatchLog("bfd", "Interface", e);
 285         }
 286     }
 287
 288     @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
 289     private static void createPortExternalIds(final OvsdbTerminationPointAugmentation terminationPoint,
 290             final Port port, final String opendaylightIid) {
 291
 292         // Set the iid external_id
 293         Map<PortExternalIdsKey, PortExternalIds> portExternalIds = terminationPoint.getPortExternalIds();
 294         PortExternalIds odl = SouthboundUtil.portCreatedByOpenDaylight();
 295         PortExternalIds iid = SouthboundUtil.createExternalIdsForPort(
 296             SouthboundConstants.IID_EXTERNAL_ID_KEY, opendaylightIid);
 297
 298         if (portExternalIds != null && !portExternalIds.isEmpty()) {
 299             portExternalIds.put(odl.key(), odl);
 300             portExternalIds.put(iid.key(), iid);
 301         } else {
 302             portExternalIds = Map.of(odl.key(), odl, iid.key(), iid);
 303         }
 304         try {
 305             port.setExternalIds(YangUtils.convertYangKeyValueListToMap(portExternalIds,
 306                 PortExternalIds::getExternalIdKey, PortExternalIds::getExternalIdValue));
 307             //YangUtils.copyYangKeyValueListToMap(externalIdMap, terminationPoint.getPortExternalIds(),
 308              //       PortExternalIds::getExternalIdKey, PortExternalIds::getExternalIdValue);
 309         } catch (NullPointerException e) {
 310             LOG.warn("Incomplete OVSDB port external_ids", e);
 311         }
 312     }
 313
 314     private static void createPortVlanTag(
 315             final OvsdbTerminationPointAugmentation terminationPoint,
 316             final Port port) {
 317
 318         if (terminationPoint.getVlanTag() != null) {
 319             Set<Long> vlanTag = new HashSet<>();
 320             vlanTag.add(terminationPoint.getVlanTag().getValue().longValue());
 321             port.setTag(vlanTag);
 322         }
 323     }
 324
 325     private static void createPortVlanTrunk(
 326             final OvsdbTerminationPointAugmentation terminationPoint,
 327             final Port port) {
 328
 329         if (terminationPoint.getTrunks() != null && terminationPoint.getTrunks().size() > 0) {
 330             Set<Long> portTrunks = new HashSet<>();
 331             List<Trunks> modelTrunks = terminationPoint.getTrunks();
 332             for (Trunks trunk: modelTrunks) {
 333                 if (trunk.getTrunk() != null) {
 334                     portTrunks.add(trunk.getTrunk().getValue().longValue());
 335                 }
 336             }
 337             port.setTrunks(portTrunks);
 338         }
 339     }
 340
 341     private static void createPortVlanMode(
 342             final OvsdbTerminationPointAugmentation terminationPoint,
 343             final Port port) {
 344         if (terminationPoint.getVlanMode() != null) {
 345             Set<String> portVlanMode = new HashSet<>();
 346             VlanMode modelVlanMode = terminationPoint.getVlanMode();
 347             portVlanMode.add(SouthboundConstants.VlanModes.values()[modelVlanMode.getIntValue() - 1].getMode());
 348             port.setVlanMode(portVlanMode);
 349         }
 350     }
 351
 352     @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
 353     private static void createPortOtherConfig(
 354             final OvsdbTerminationPointAugmentation terminationPoint,
 355             final Port ovsPort) {
 356         Map<PortOtherConfigsKey, PortOtherConfigs> portOtherConfigs =
 357                 terminationPoint.getPortOtherConfigs();
 358         if (portOtherConfigs != null && !portOtherConfigs.isEmpty()) {
 359             try {
 360                 ovsPort.setOtherConfig(YangUtils.convertYangKeyValueListToMap(portOtherConfigs,
 361                         PortOtherConfigs::getOtherConfigKey, PortOtherConfigs::getOtherConfigValue));
 362             } catch (NullPointerException e) {
 363                 LOG.warn("Incomplete OVSDB port other_config", e);
 364             }
 365         }
 366     }
 367
 368     public static void stampInstanceIdentifier(final TransactionBuilder transaction,
 369             final InstanceIdentifier<OvsdbTerminationPointAugmentation> iid, final String interfaceName,
 370             final InstanceIdentifierCodec instanceIdentifierCodec) {
 371         Port port = transaction.getTypedRowWrapper(Port.class);
 372         port.setName(interfaceName);
 373         port.setExternalIds(Collections.emptyMap());
 374         Mutate mutate = TransactUtils.stampInstanceIdentifierMutation(transaction, iid, port.getSchema(),
 375                 port.getExternalIdsColumn().getSchema(), instanceIdentifierCodec);
 376         transaction.add(mutate
 377                 .where(port.getNameColumn().getSchema().opEqual(interfaceName))
 378                 .build());
 379     }
 380 }