2 * Copyright (c) 2014, 2017 Intel Corp. and others. All rights reserved.
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
8 package org.opendaylight.ovsdb.southbound.transactions.md;
10 import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
12 import com.google.common.annotations.VisibleForTesting;
13 import java.util.ArrayList;
14 import java.util.Collection;
15 import java.util.Iterator;
16 import java.util.List;
18 import java.util.Map.Entry;
19 import java.util.Optional;
21 import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
22 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
23 import org.opendaylight.ovsdb.lib.error.ColumnSchemaNotFoundException;
24 import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
25 import org.opendaylight.ovsdb.lib.message.TableUpdates;
26 import org.opendaylight.ovsdb.lib.notation.Column;
27 import org.opendaylight.ovsdb.lib.notation.UUID;
28 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
29 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
30 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
31 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
32 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
33 import org.opendaylight.ovsdb.schema.openvswitch.Port;
34 import org.opendaylight.ovsdb.schema.openvswitch.Qos;
35 import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
36 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
37 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
38 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
39 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
40 import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbQosRef;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryKey;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesKey;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdBuilder;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdKey;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatus;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatusBuilder;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatusKey;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpBuilder;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpKey;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsBuilder;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntry;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntryBuilder;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntryKey;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
79 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
80 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
81 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
82 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
83 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
84 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
85 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
86 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
87 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
88 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
89 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
90 import org.slf4j.Logger;
91 import org.slf4j.LoggerFactory;
93 public class OvsdbPortUpdateCommand extends AbstractTransactionCommand {
94 private static final Logger LOG = LoggerFactory.getLogger(OvsdbPortUpdateCommand.class);
96 private final InstanceIdentifierCodec instanceIdentifierCodec;
97 private final Map<UUID, Port> portUpdatedRows;
98 private final Map<UUID, Port> portOldRows;
99 private final Map<UUID, Interface> interfaceUpdatedRows;
100 private final Map<UUID, Interface> interfaceOldRows;
101 private final Map<UUID, Bridge> bridgeUpdatedRows;
102 private final Map<UUID, Qos> qosUpdatedRows;
104 public OvsdbPortUpdateCommand(InstanceIdentifierCodec instanceIdentifierCodec, OvsdbConnectionInstance key,
105 TableUpdates updates, DatabaseSchema dbSchema) {
106 super(key, updates, dbSchema);
107 this.instanceIdentifierCodec = instanceIdentifierCodec;
108 portUpdatedRows = TyperUtils.extractRowsUpdated(Port.class, updates, dbSchema);
109 portOldRows = TyperUtils.extractRowsOld(Port.class, updates, dbSchema);
110 interfaceUpdatedRows = TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema);
111 interfaceOldRows = TyperUtils.extractRowsOld(Interface.class, updates, dbSchema);
112 bridgeUpdatedRows = TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema);
113 qosUpdatedRows = TyperUtils.extractRowsUpdated(Qos.class, updates, dbSchema);
117 public void execute(ReadWriteTransaction transaction) {
118 final InstanceIdentifier<Node> connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier();
119 if (portUpdatedRows == null && interfaceOldRows == null
120 || interfaceOldRows.isEmpty() && portUpdatedRows.isEmpty()) {
123 Optional<Node> node = readNode(transaction, connectionIId);
124 if (node.isPresent()) {
125 updateTerminationPoints(transaction, node.get());
130 void updateTerminationPoints(ReadWriteTransaction transaction, Node node) {
131 for (Entry<UUID, Port> portUpdate : portUpdatedRows.entrySet()) {
132 String portName = null;
133 portName = portUpdate.getValue().getNameColumn().getData();
134 Optional<InstanceIdentifier<Node>> bridgeIid = getTerminationPointBridge(portUpdate.getKey());
135 if (!bridgeIid.isPresent()) {
136 bridgeIid = getTerminationPointBridge(transaction, node, portName);
138 if (bridgeIid.isPresent()) {
139 NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
140 TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
141 getOvsdbConnectionInstance().updatePortInterface(portName, bridgeIid.get());
142 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
143 tpBuilder.withKey(tpKey);
144 tpBuilder.setTpId(tpKey.getTpId());
145 InstanceIdentifier<TerminationPoint> tpPath =
146 getInstanceIdentifier(bridgeIid.get(), portUpdate.getValue());
147 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
148 new OvsdbTerminationPointAugmentationBuilder();
149 buildTerminationPoint(transaction, tpPath, tpAugmentationBuilder, node, portUpdate);
150 UUID interfaceUuid = (UUID)portUpdate.getValue().getInterfacesColumn().getData().toArray()[0];
151 if (interfaceUpdatedRows.containsKey(interfaceUuid)) {
152 buildTerminationPoint(tpAugmentationBuilder, interfaceUpdatedRows.get(interfaceUuid));
153 interfaceUpdatedRows.remove(interfaceUuid);
154 interfaceOldRows.remove(interfaceUuid);
156 tpBuilder.addAugmentation(tpAugmentationBuilder.build());
157 if (portOldRows.containsKey(portUpdate.getKey()) && !portQosCleared(portUpdate)) {
158 updateToDataStore(transaction, tpBuilder, tpPath, true);
159 LOG.info("DEVICE - {} TerminationPoint : {} to Bridge : {}", TransactionType.ADD,
160 tpKey.getTpId().getValue(), bridgeId.getValue());
162 updateToDataStore(transaction, tpBuilder, tpPath, false);
163 LOG.debug("DEVICE - {} TerminationPoint : {} to Bridge : {}", TransactionType.UPDATE,
164 tpKey.getTpId().getValue(), bridgeId.getValue());
168 for (Entry<UUID, Interface> interfaceUpdate : interfaceUpdatedRows.entrySet()) {
169 String interfaceName = null;
170 Optional<InstanceIdentifier<Node>> bridgeIid = Optional.empty();
171 interfaceName = interfaceUpdatedRows.get(interfaceUpdate.getKey()).getNameColumn().getData();
172 if (getOvsdbConnectionInstance().getPortInterface(interfaceName) != null) {
173 bridgeIid = Optional.of(getOvsdbConnectionInstance().getPortInterface(interfaceName));
175 if (!bridgeIid.isPresent()) {
176 bridgeIid = getTerminationPointBridge(transaction, node, interfaceName);
178 if (bridgeIid.isPresent()) {
179 TerminationPointKey tpKey = new TerminationPointKey(new TpId(interfaceName));
180 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
181 tpBuilder.withKey(tpKey);
182 tpBuilder.setTpId(tpKey.getTpId());
183 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
184 new OvsdbTerminationPointAugmentationBuilder();
185 buildTerminationPoint(tpAugmentationBuilder, interfaceUpdate.getValue());
186 tpBuilder.addAugmentation(tpAugmentationBuilder.build());
187 NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
188 InstanceIdentifier<TerminationPoint> tpPath = InstanceIdentifier
189 .create(NetworkTopology.class)
190 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
191 .child(Node.class,new NodeKey(bridgeId))
192 .child(TerminationPoint.class,tpKey);
193 updateToDataStore(transaction, tpBuilder, tpPath, true);
199 protected void updateToDataStore(ReadWriteTransaction transaction, TerminationPointBuilder tpBuilder,
200 InstanceIdentifier<TerminationPoint> tpPath, boolean merge) {
202 transaction.merge(LogicalDatastoreType.OPERATIONAL,
203 tpPath, tpBuilder.build());
205 transaction.put(LogicalDatastoreType.OPERATIONAL,
206 tpPath, tpBuilder.build());
211 void buildTerminationPoint(ReadWriteTransaction transaction,
212 InstanceIdentifier<TerminationPoint> tpPath,
213 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
214 Node node, Entry<UUID, Port> portUpdate) {
216 tpAugmentationBuilder
217 .setName(portUpdate.getValue().getName());
218 tpAugmentationBuilder.setPortUuid(new Uuid(
219 portUpdate.getValue().getUuid().toString()));
220 updatePort(transaction, node, tpPath, portUpdate, tpAugmentationBuilder);
223 private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
224 Interface interfaceUpdate) {
226 tpAugmentationBuilder
227 .setName(interfaceUpdate.getName());
228 tpAugmentationBuilder.setInterfaceUuid(new Uuid(
229 interfaceUpdate.getUuid().toString()));
230 updateInterfaces(interfaceUpdate, tpAugmentationBuilder);
233 @SuppressWarnings("IllegalCatch")
234 private Optional<Node> readNode(final ReadWriteTransaction transaction, final InstanceIdentifier<Node> nodePath) {
235 Optional<Node> node = Optional.empty();
237 node = SouthboundUtil.readNode(transaction, nodePath);
238 } catch (Exception exp) {
239 LOG.error("Error in getting the Node for {}", nodePath, exp);
244 private Optional<InstanceIdentifier<Node>> getTerminationPointBridge(UUID portUuid) {
246 if (bridgeUpdatedRows != null) {
247 for (Entry<UUID, Bridge> entry : this.bridgeUpdatedRows.entrySet()) {
248 UUID bridgeUuid = entry.getKey();
249 if (this.bridgeUpdatedRows.get(bridgeUuid).getPortsColumn().getData()
250 .contains(portUuid)) {
251 InstanceIdentifier<Node> iid = SouthboundMapper.createInstanceIdentifier(
252 instanceIdentifierCodec, getOvsdbConnectionInstance(),
253 this.bridgeUpdatedRows.get(bridgeUuid));
254 getOvsdbConnectionInstance().updatePort(portUuid, iid);
255 return Optional.of(iid);
259 if (getOvsdbConnectionInstance().getPort(portUuid) != null) {
260 return Optional.of(getOvsdbConnectionInstance().getPort(portUuid));
262 return Optional.empty();
265 @SuppressWarnings("unchecked")
266 // FIXME: non-static for implementation internals mocking
267 private Optional<InstanceIdentifier<Node>> getTerminationPointBridge(
268 final ReadWriteTransaction transaction, Node node, String tpName) {
269 OvsdbNodeAugmentation ovsdbNode = node.augmentation(OvsdbNodeAugmentation.class);
270 Map<ManagedNodeEntryKey, ManagedNodeEntry> managedNodes = ovsdbNode.nonnullManagedNodeEntry();
271 TpId tpId = new TpId(tpName);
273 for (ManagedNodeEntry managedNodeEntry : managedNodes.values()) {
274 Optional<Node> optManagedNode = SouthboundUtil.readNode(transaction,
275 (InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue());
276 if (optManagedNode.isPresent()) {
277 Node managedNode = optManagedNode.get();
278 Map<TerminationPointKey, TerminationPoint> tpEntrys = managedNode.getTerminationPoint();
279 if (tpEntrys != null) {
280 TerminationPoint tpEntry = tpEntrys.get(new TerminationPointKey(tpId));
281 if (tpEntry != null) {
282 return Optional.of((InstanceIdentifier<Node>) managedNodeEntry.getBridgeRef().getValue());
288 return Optional.empty();
292 void updateInterfaces(Interface interfaceUpdate,
293 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
295 Column<GenericTableSchema, String> typeColumn = interfaceUpdate.getTypeColumn();
296 String type = typeColumn.getData();
297 updateInterface(interfaceUpdate, type,ovsdbTerminationPointBuilder);
301 void updatePort(final ReadWriteTransaction transaction, final Node node,
302 final InstanceIdentifier<TerminationPoint> tpPath, final Entry<UUID, Port> port,
303 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
305 updateVlan(port.getValue(), ovsdbTerminationPointBuilder);
306 updateVlanTrunks(port.getValue(), ovsdbTerminationPointBuilder);
307 updateVlanMode(port.getValue(), ovsdbTerminationPointBuilder);
308 updateQos(transaction, node, tpPath, port, ovsdbTerminationPointBuilder);
309 updatePortExternalIds(port.getValue(), ovsdbTerminationPointBuilder);
310 updatePortOtherConfig(port.getValue(), ovsdbTerminationPointBuilder);
314 void updateInterface(final Interface interf,
316 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
318 ovsdbTerminationPointBuilder.setInterfaceUuid(
319 new Uuid(interf.getUuid().toString()));
320 ovsdbTerminationPointBuilder.setInterfaceType(
321 SouthboundMapper.createInterfaceType(type));
322 updateIfIndex(interf, ovsdbTerminationPointBuilder);
323 updateMac(interf, ovsdbTerminationPointBuilder);
324 updateMacInUse(interf, ovsdbTerminationPointBuilder);
325 updateOfPort(interf, ovsdbTerminationPointBuilder);
326 updateOfPortRequest(interf, ovsdbTerminationPointBuilder);
327 updateInterfaceExternalIds(interf, ovsdbTerminationPointBuilder);
328 updateOptions(interf, ovsdbTerminationPointBuilder);
329 updateInterfaceOtherConfig(interf, ovsdbTerminationPointBuilder);
330 updateInterfaceLldp(interf, ovsdbTerminationPointBuilder);
331 updateInterfaceBfd(interf, ovsdbTerminationPointBuilder);
332 updateInterfaceBfdStatus(interf, ovsdbTerminationPointBuilder);
333 updateInterfacePolicing(interf, ovsdbTerminationPointBuilder);
337 void updateVlan(final Port port,
338 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
340 Collection<Long> vlanId = port.getTagColumn().getData();
341 if (vlanId.size() > 0) {
342 Iterator<Long> itr = vlanId.iterator();
343 // There are no loops here, just get the first element.
344 int id = itr.next().intValue();
345 ovsdbTerminationPointBuilder.setVlanTag(new VlanId(id));
350 void updateVlanTrunks(final Port port,
351 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
353 Set<Long> portTrunks = port.getTrunksColumn().getData();
354 List<Trunks> modelTrunks = new ArrayList<>();
355 if (!portTrunks.isEmpty()) {
356 for (Long trunk: portTrunks) {
358 modelTrunks.add(new TrunksBuilder()
359 .setTrunk(new VlanId(trunk.intValue())).build());
363 ovsdbTerminationPointBuilder.setTrunks(modelTrunks);
367 void updateVlanMode(final Port port,
368 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
370 Collection<String> vlanMode = port.getVlanModeColumn().getData();
371 if (!vlanMode.isEmpty()) {
372 Iterator<String> itr = vlanMode.iterator();
373 String vlanType = itr.next();
374 if (vlanType.equals(SouthboundConstants.VlanModes.ACCESS.getMode())) {
375 ovsdbTerminationPointBuilder
376 .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
377 } else if (vlanType.equals(SouthboundConstants.VlanModes.NATIVE_TAGGED.getMode())) {
378 ovsdbTerminationPointBuilder
379 .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeTagged);
380 } else if (vlanType.equals(SouthboundConstants.VlanModes.NATIVE_UNTAGGED.getMode())) {
381 ovsdbTerminationPointBuilder
382 .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeUntagged);
383 } else if (vlanType.equals(SouthboundConstants.VlanModes.TRUNK.getMode())) {
384 ovsdbTerminationPointBuilder
385 .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Trunk);
387 LOG.debug("Invalid vlan mode {}.", vlanType);
392 private void updateQos(final ReadWriteTransaction transaction, final Node node,
393 InstanceIdentifier<TerminationPoint> tpPath, final Entry<UUID, Port> port,
394 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
395 if (port.getValue() == null) {
398 Collection<UUID> qosUuidCol = port.getValue().getQosColumn().getData();
399 if (!qosUuidCol.isEmpty()) {
400 UUID qosUuid = qosUuidCol.iterator().next();
402 NodeId nodeId = node.getNodeId();
403 OvsdbNodeAugmentation ovsdbNode = node.augmentation(OvsdbNodeAugmentation.class);
405 // Delete an older QoS entry
406 if (portOldRows.containsKey(port.getKey()) && portOldRows.get(port.getKey()).getQosColumn() != null) {
407 Collection<UUID> oldQos = portOldRows.get(port.getKey()).getQosColumn().getData();
408 if (!oldQos.isEmpty()) {
409 UUID oldQosUuid = oldQos.iterator().next();
410 if (!oldQosUuid.equals(qosUuid)) {
411 InstanceIdentifier<QosEntries> oldQosIid = getQosIid(nodeId, ovsdbNode, oldQosUuid);
412 if (oldQosIid != null) {
413 InstanceIdentifier<QosEntry> oldPortQosIid = tpPath
414 .augmentation(OvsdbTerminationPointAugmentation.class)
415 .child(QosEntry.class,
416 new QosEntryKey(Long.valueOf(SouthboundConstants.PORT_QOS_LIST_KEY)));
417 transaction.delete(LogicalDatastoreType.OPERATIONAL, oldPortQosIid);
423 InstanceIdentifier<QosEntries> qosIid = getQosIid(nodeId, ovsdbNode, qosUuid);
424 if (qosIid != null) {
425 List<QosEntry> qosList = new ArrayList<>();
426 OvsdbQosRef qosRef = new OvsdbQosRef(qosIid);
427 qosList.add(new QosEntryBuilder()
428 .withKey(new QosEntryKey(Long.valueOf(SouthboundConstants.PORT_QOS_LIST_KEY)))
429 .setQosRef(qosRef).build());
430 ovsdbTerminationPointBuilder.setQosEntry(qosList);
435 @SuppressWarnings("unchecked")
436 private InstanceIdentifier<QosEntries> getQosIid(NodeId nodeId, OvsdbNodeAugmentation ovsdbNode, UUID qosUuid) {
437 // Search for the QoS entry first in the operational datastore
438 final Uuid uuid = new Uuid(qosUuid.toString());
439 for (QosEntries qosEntry : ovsdbNode.nonnullQosEntries().values()) {
440 if (uuid.equals(qosEntry.getQosUuid())) {
441 return SouthboundMapper.createInstanceIdentifier(nodeId)
442 .augmentation(OvsdbNodeAugmentation.class)
443 .child(QosEntries.class, qosEntry.key());
447 // Search for the QoS entry in the current OVS updates
448 for (Entry<UUID, Qos> qosUpdate : qosUpdatedRows.entrySet()) {
449 Qos qos = qosUpdate.getValue();
450 if (qos.getUuid().equals(qosUuid)) {
451 if (qos.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
452 return (InstanceIdentifier<QosEntries>) instanceIdentifierCodec.bindingDeserializerOrNull(
453 qos.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY));
455 return SouthboundMapper.createInstanceIdentifier(nodeId)
456 .augmentation(OvsdbNodeAugmentation.class)
457 .child(QosEntries.class, new QosEntriesKey(
458 new Uri(SouthboundConstants.QOS_URI_PREFIX + "://" + qosUuid.toString())));
462 LOG.debug("QoS UUID {} assigned to port not found in operational node {} or QoS updates", qosUuid, ovsdbNode);
463 return SouthboundMapper.createInstanceIdentifier(nodeId)
464 .augmentation(OvsdbNodeAugmentation.class)
465 .child(QosEntries.class, new QosEntriesKey(
466 new Uri(SouthboundConstants.QOS_URI_PREFIX + "://" + qosUuid.toString())));
469 private void updateIfIndex(final Interface interf,
470 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
471 Set<Long> ifIndexSet = null;
473 if (interf.getIfIndexColumn() != null) {
474 ifIndexSet = interf.getIfIndexColumn().getData();
476 if (ifIndexSet != null && !ifIndexSet.isEmpty()) {
477 for (Long ifIndex : ifIndexSet) {
478 ovsdbTerminationPointBuilder.setIfindex(ifIndex);
481 } catch (SchemaVersionMismatchException e) {
482 schemaMismatchLog("ifindex", "Interface", e);
486 private void updateMac(final Interface interf,
487 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
488 Set<String> macSet = null;
490 if (interf.getMacColumn() != null) {
491 macSet = interf.getMacColumn().getData();
493 if (macSet != null && !macSet.isEmpty()) {
495 * It is a set due to way JSON decoder converts [] objects. OVS
496 * only supports ONE mac, so we're fine.
498 for (String mac: macSet) {
499 ovsdbTerminationPointBuilder.setMac(new MacAddress(mac));
502 } catch (SchemaVersionMismatchException e) {
503 schemaMismatchLog("mac", "Interface", e);
507 private void updateMacInUse(final Interface interf,
508 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
509 Set<String> macInUseSet = null;
511 if (interf.getMacInUseColumn() != null) {
512 macInUseSet = interf.getMacInUseColumn().getData();
514 if (macInUseSet != null && !macInUseSet.isEmpty()) {
516 * It is a set due to way JSON decoder converts [] objects. OVS
517 * only supports ONE mac, so we're fine.
519 for (String macInUse: macInUseSet) {
520 ovsdbTerminationPointBuilder.setMacInUse(new MacAddress(macInUse));
523 } catch (SchemaVersionMismatchException e) {
524 schemaMismatchLog("mac_in_use", "Interface", e);
529 void updateOfPort(final Interface interf,
530 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
532 Set<Long> ofPorts = interf.getOpenFlowPortColumn().getData();
533 if (ofPorts != null && !ofPorts.isEmpty()) {
534 Iterator<Long> ofPortsIter = ofPorts.iterator();
535 long ofPort = ofPortsIter.next();
537 ovsdbTerminationPointBuilder
540 LOG.debug("Received negative value for ofPort from ovsdb for {} {}",
541 interf.getName(),ofPort);
547 void updateOfPortRequest(final Interface interf,
548 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
550 Set<Long> ofPortRequests = null;
552 ofPortRequests = interf.getOpenFlowPortRequestColumn().getData();
553 } catch (ColumnSchemaNotFoundException e) {
554 LOG.warn("Cannot find openflow column", e);
556 if (ofPortRequests != null && !ofPortRequests.isEmpty()) {
557 Iterator<Long> ofPortRequestsIter = ofPortRequests.iterator();
558 int ofPort = ofPortRequestsIter.next().intValue();
560 ovsdbTerminationPointBuilder
561 .setOfportRequest(ofPort);
563 LOG.debug("Received negative value for ofPort from ovsdb for {} {}",
564 interf.getName(),ofPort);
570 void updateInterfaceExternalIds(final Interface interf,
571 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
573 Map<String, String> interfaceExternalIds =
574 interf.getExternalIdsColumn().getData();
575 if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
576 List<InterfaceExternalIds> externalIdsList = new ArrayList<>();
577 for (Entry<String, String> entry : interfaceExternalIds.entrySet()) {
578 String externalIdKey = entry.getKey();
579 String externalIdValue = entry.getValue();
580 if (externalIdKey != null && externalIdValue != null) {
581 externalIdsList.add(new InterfaceExternalIdsBuilder()
582 .setExternalIdKey(externalIdKey)
583 .setExternalIdValue(externalIdValue).build());
586 ovsdbTerminationPointBuilder.setInterfaceExternalIds(externalIdsList);
591 void updatePortExternalIds(final Port port,
592 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
594 Map<String, String> portExternalIds = port.getExternalIdsColumn().getData();
595 if (portExternalIds != null && !portExternalIds.isEmpty()) {
596 List<PortExternalIds> externalIdsList = new ArrayList<>();
597 for (Entry<String, String> entry : portExternalIds.entrySet()) {
598 String externalIdKey = entry.getKey();
599 String externalIdValue = entry.getValue();
600 if (externalIdKey != null && externalIdValue != null) {
601 externalIdsList.add(new PortExternalIdsBuilder()
602 .setExternalIdKey(externalIdKey)
603 .setExternalIdValue(externalIdValue).build());
606 ovsdbTerminationPointBuilder.setPortExternalIds(externalIdsList);
611 void updateOptions(final Interface interf,
612 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
614 Map<String, String> optionsMap = interf.getOptionsColumn().getData();
615 if (optionsMap != null && !optionsMap.isEmpty()) {
616 List<Options> options = new ArrayList<>();
617 for (Entry<String, String> entry : optionsMap.entrySet()) {
618 String optionsKeyString = entry.getKey();
619 String optionsValueString = entry.getValue();
620 if (optionsKeyString != null && optionsValueString != null) {
621 OptionsKey optionsKey = new OptionsKey(optionsKeyString);
622 options.add(new OptionsBuilder()
624 .setValue(optionsValueString).build());
627 ovsdbTerminationPointBuilder.setOptions(options);
632 void updatePortOtherConfig(final Port port,
633 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
635 Map<String, String> portOtherConfigMap = port.getOtherConfigColumn().getData();
636 if (portOtherConfigMap != null && !portOtherConfigMap.isEmpty()) {
637 List<PortOtherConfigs> portOtherConfigs = new ArrayList<>();
638 for (Entry<String, String> entry : portOtherConfigMap.entrySet()) {
639 String portOtherConfigKeyString = entry.getKey();
640 String portOtherConfigValueString = entry.getValue();
641 if (portOtherConfigKeyString != null && portOtherConfigValueString != null) {
642 portOtherConfigs.add(new PortOtherConfigsBuilder()
643 .setOtherConfigKey(portOtherConfigKeyString)
644 .setOtherConfigValue(portOtherConfigValueString).build());
647 ovsdbTerminationPointBuilder.setPortOtherConfigs(portOtherConfigs);
651 private void updateInterfaceLldp(final Interface interf,
652 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
655 Map<String, String> interfaceLldpMap = interf.getLldpColumn().getData();
656 if (interfaceLldpMap != null && !interfaceLldpMap.isEmpty()) {
657 List<InterfaceLldp> interfaceLldpList = new ArrayList<>();
658 for (Entry<String, String> entry : interfaceLldpMap.entrySet()) {
659 String interfaceLldpKeyString = entry.getKey();
660 String interfaceLldpValueString = entry.getValue();
661 if (interfaceLldpKeyString != null && interfaceLldpValueString != null) {
662 interfaceLldpList.add(new InterfaceLldpBuilder()
663 .withKey(new InterfaceLldpKey(interfaceLldpKeyString))
664 .setLldpKey(interfaceLldpKeyString)
665 .setLldpValue(interfaceLldpValueString)
669 ovsdbTerminationPointBuilder.setInterfaceLldp(interfaceLldpList);
671 } catch (SchemaVersionMismatchException e) {
672 schemaMismatchLog("lldp", "Interface", e);
677 void updateInterfaceOtherConfig(final Interface interf,
678 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
680 Map<String, String> interfaceOtherConfigMap = interf.getOtherConfigColumn().getData();
681 if (interfaceOtherConfigMap != null && !interfaceOtherConfigMap.isEmpty()) {
682 List<InterfaceOtherConfigs> interfaceOtherConfigs = new ArrayList<>();
683 for (Entry<String, String> entry : interfaceOtherConfigMap.entrySet()) {
684 String interfaceOtherConfigKeyString = entry.getKey();
685 String interfaceOtherConfigValueString = entry.getValue();
686 if (interfaceOtherConfigKeyString != null && interfaceOtherConfigValueString != null) {
687 interfaceOtherConfigs.add(new InterfaceOtherConfigsBuilder()
688 .setOtherConfigKey(interfaceOtherConfigKeyString)
689 .setOtherConfigValue(interfaceOtherConfigValueString).build());
692 ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(interfaceOtherConfigs);
696 private void updateInterfaceBfdStatus(final Interface interf,
697 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
700 Map<String, String> interfaceBfdStatusMap = interf.getBfdStatusColumn().getData();
701 if (interfaceBfdStatusMap != null && !interfaceBfdStatusMap.isEmpty()) {
702 List<InterfaceBfdStatus> interfaceBfdStatusList = new ArrayList<>();
703 for (Entry<String, String> entry : interfaceBfdStatusMap.entrySet()) {
704 String interfaceBfdStatusKeyString = entry.getKey();
705 String interfaceBfdStatusValueString = entry.getValue();
706 if (interfaceBfdStatusKeyString != null && interfaceBfdStatusValueString != null) {
707 interfaceBfdStatusList.add(new InterfaceBfdStatusBuilder()
708 .withKey(new InterfaceBfdStatusKey(interfaceBfdStatusKeyString))
709 .setBfdStatusKey(interfaceBfdStatusKeyString)
710 .setBfdStatusValue(interfaceBfdStatusValueString)
714 ovsdbTerminationPointBuilder.setInterfaceBfdStatus(interfaceBfdStatusList);
716 } catch (SchemaVersionMismatchException e) {
717 schemaMismatchLog("bfd", "Interface", e);
721 private void updateInterfaceBfd(final Interface interf,
722 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
725 Map<String, String> interfaceBfdMap = interf.getBfdColumn().getData();
726 if (interfaceBfdMap != null && !interfaceBfdMap.isEmpty()) {
727 List<InterfaceBfd> interfaceBfdList = new ArrayList<>();
728 for (Entry<String, String> entry : interfaceBfdMap.entrySet()) {
729 String interfaceBfdKeyString = entry.getKey();
730 String interfaceBfdValueString = entry.getValue();
731 if (interfaceBfdKeyString != null && interfaceBfdValueString != null) {
732 interfaceBfdList.add(new InterfaceBfdBuilder()
733 .withKey(new InterfaceBfdKey(interfaceBfdKeyString))
734 .setBfdKey(interfaceBfdKeyString)
735 .setBfdValue(interfaceBfdValueString)
739 ovsdbTerminationPointBuilder.setInterfaceBfd(interfaceBfdList);
741 } catch (SchemaVersionMismatchException e) {
742 schemaMismatchLog("bfd", "Interface", e);
747 private void updateInterfacePolicing(final Interface interf,
748 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
750 Long ingressPolicingRate = null;
751 if (interf.getIngressPolicingRateColumn() != null) {
752 ingressPolicingRate = interf.getIngressPolicingRateColumn().getData();
754 if (ingressPolicingRate != null) {
755 if (ingressPolicingRate >= 0) {
756 ovsdbTerminationPointBuilder
757 .setIngressPolicingRate(ingressPolicingRate);
759 LOG.debug("Received negative value for ingressPolicingRate from ovsdb for {} {}",
760 interf.getName(),ingressPolicingRate);
764 Long ingressPolicingBurst = null;
765 if (interf.getIngressPolicingBurstColumn() != null) {
766 ingressPolicingBurst = interf.getIngressPolicingBurstColumn().getData();
768 if (ingressPolicingBurst != null) {
769 if (ingressPolicingBurst >= 0) {
770 ovsdbTerminationPointBuilder
771 .setIngressPolicingBurst(ingressPolicingBurst);
773 LOG.debug("Received negative value for ingressPolicingBurst from ovsdb for {} {}",
774 interf.getName(),ingressPolicingBurst);
779 private boolean portQosCleared(Entry<UUID, Port> portUpdate) {
780 if (portUpdate.getValue().getQosColumn() == null) {
783 Collection<UUID> newQos = portUpdate.getValue().getQosColumn().getData();
784 if (portOldRows.get(portUpdate.getKey()).getQosColumn() == null) {
787 Collection<UUID> oldQos = portOldRows.get(portUpdate.getKey()).getQosColumn().getData();
789 if (newQos.isEmpty() && !oldQos.isEmpty()) {
796 @SuppressWarnings("unchecked")
798 InstanceIdentifier<TerminationPoint> getInstanceIdentifier(InstanceIdentifier<Node> bridgeIid,Port port) {
799 if (port.getExternalIdsColumn() != null
800 && port.getExternalIdsColumn().getData() != null
801 && port.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
802 String iidString = port.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY);
803 return (InstanceIdentifier<TerminationPoint>) instanceIdentifierCodec.bindingDeserializerOrNull(iidString);
805 return bridgeIid.child(TerminationPoint.class, new TerminationPointKey(new TpId(port.getName())));