2 * Copyright (c) 2014 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
9 package org.opendaylight.ovsdb.southbound.transactions.md;
11 import java.util.ArrayList;
12 import java.util.Collection;
13 import java.util.Iterator;
14 import java.util.List;
16 import java.util.Map.Entry;
19 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
20 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
21 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
22 import org.opendaylight.ovsdb.lib.error.ColumnSchemaNotFoundException;
23 import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
24 import org.opendaylight.ovsdb.lib.message.TableUpdates;
25 import org.opendaylight.ovsdb.lib.notation.Column;
26 import org.opendaylight.ovsdb.lib.notation.UUID;
27 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
28 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
29 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
30 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
31 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
32 import org.opendaylight.ovsdb.schema.openvswitch.Port;
33 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
34 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
35 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
36 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpBuilder;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpKey;
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.InterfaceOtherConfigsBuilder;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
61 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
62 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
63 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
64 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
65 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
66 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
67 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
68 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
69 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
70 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
71 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
72 import org.slf4j.Logger;
73 import org.slf4j.LoggerFactory;
75 import com.google.common.base.Optional;
77 public class OvsdbPortUpdateCommand extends AbstractTransactionCommand {
78 private static final Logger LOG = LoggerFactory.getLogger(OvsdbPortUpdateCommand.class);
79 private Map<UUID, Port> portUpdatedRows;
80 private Map<UUID, Port> portOldRows;
81 private Map<UUID, Interface> interfaceUpdatedRows;
82 private Map<UUID, Interface> interfaceOldRows;
83 private Map<UUID, Bridge> bridgeUpdatedRows;
84 public OvsdbPortUpdateCommand(OvsdbConnectionInstance key, TableUpdates updates,
85 DatabaseSchema dbSchema) {
86 super(key, updates, dbSchema);
87 portUpdatedRows = TyperUtils.extractRowsUpdated(Port.class, updates, dbSchema);
88 portOldRows = TyperUtils.extractRowsOld(Port.class, updates, dbSchema);
89 interfaceUpdatedRows = TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema);
90 interfaceOldRows = TyperUtils.extractRowsOld(Interface.class, updates, dbSchema);
91 bridgeUpdatedRows = TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema);
95 public void execute(ReadWriteTransaction transaction) {
96 final InstanceIdentifier<Node> connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier();
97 if ( (portUpdatedRows == null && interfaceOldRows == null )
98 || ( interfaceOldRows.isEmpty() && portUpdatedRows.isEmpty())) {
101 Optional<Node> node = readNode(transaction, connectionIId);
102 if (node.isPresent()) {
103 updateTerminationPoints(transaction, node.get());
106 private void updateTerminationPoints(ReadWriteTransaction transaction, Node node) {
107 for (Entry<UUID, Port> portUpdate : portUpdatedRows.entrySet()) {
108 String portName = null;
109 portName = portUpdate.getValue().getNameColumn().getData();
110 Optional<InstanceIdentifier<Node>> bridgeIid = getTerminationPointBridge(portUpdate.getKey());
111 if (!bridgeIid.isPresent()) {
112 bridgeIid = getTerminationPointBridge( transaction, node, portName);
114 if (bridgeIid.isPresent()) {
115 NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
116 TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
117 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
118 tpBuilder.setKey(tpKey);
119 tpBuilder.setTpId(tpKey.getTpId());
120 InstanceIdentifier<TerminationPoint> tpPath =
121 getInstanceIdentifier(bridgeIid.get(), portUpdate.getValue());
122 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
123 new OvsdbTerminationPointAugmentationBuilder();
124 buildTerminationPoint(tpAugmentationBuilder,portUpdate.getValue());
125 UUID interfaceUUID = (UUID)portUpdate.getValue().getInterfacesColumn().getData().toArray()[0];
126 if (interfaceUpdatedRows.containsKey(interfaceUUID)) {
127 buildTerminationPoint(tpAugmentationBuilder,
128 interfaceUpdatedRows.get(interfaceUUID));
129 interfaceUpdatedRows.remove(interfaceUUID);
130 interfaceOldRows.remove(interfaceUUID);
132 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
133 if (portOldRows.containsKey(portUpdate.getKey()) && !portQosCleared(portUpdate)) {
134 transaction.merge(LogicalDatastoreType.OPERATIONAL,
135 tpPath, tpBuilder.build());
137 transaction.put(LogicalDatastoreType.OPERATIONAL,
138 tpPath, tpBuilder.build());
142 for (Entry<UUID, Interface> interfaceUpdate : interfaceUpdatedRows.entrySet()) {
143 String interfaceName = null;
144 interfaceName = interfaceUpdatedRows.get(interfaceUpdate.getKey()).getNameColumn().getData();
145 Optional<InstanceIdentifier<Node>> bridgeIid = getTerminationPointBridge( transaction, node, interfaceName);
146 if (bridgeIid.isPresent()) {
147 NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
148 TerminationPointKey tpKey = new TerminationPointKey(new TpId(interfaceName));
149 InstanceIdentifier<TerminationPoint> tpPath = InstanceIdentifier
150 .create(NetworkTopology.class)
151 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
152 .child(Node.class,new NodeKey(bridgeId))
153 .child(TerminationPoint.class,tpKey);
154 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
155 tpBuilder.setKey(tpKey);
156 tpBuilder.setTpId(tpKey.getTpId());
157 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
158 new OvsdbTerminationPointAugmentationBuilder();
159 buildTerminationPoint(tpAugmentationBuilder, interfaceUpdate.getValue());
160 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
161 transaction.merge(LogicalDatastoreType.OPERATIONAL,
162 tpPath, tpBuilder.build());
167 private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
170 tpAugmentationBuilder
171 .setName(portUpdate.getName());
172 tpAugmentationBuilder.setPortUuid(new Uuid(
173 portUpdate.getUuid().toString()));
174 updatePort(portUpdate, tpAugmentationBuilder);
177 private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
178 Interface interfaceUpdate) {
180 tpAugmentationBuilder
181 .setName(interfaceUpdate.getName());
182 tpAugmentationBuilder.setInterfaceUuid(new Uuid(
183 interfaceUpdate.getUuid().toString()));
184 updateInterfaces(interfaceUpdate, tpAugmentationBuilder);
187 private Optional<Node> readNode(final ReadWriteTransaction transaction, final InstanceIdentifier<Node> nodePath) {
188 Optional<Node> node = Optional.absent();
190 node = transaction.read(
191 LogicalDatastoreType.OPERATIONAL, nodePath)
193 } catch (final ReadFailedException e) {
194 LOG.warn("Read Operational/DS for Node fail! {}",
200 private Optional<InstanceIdentifier<Node>> getTerminationPointBridge( UUID portUUID) {
201 for (UUID bridgeUUID : this.bridgeUpdatedRows.keySet()) {
202 if (this.bridgeUpdatedRows.get(bridgeUUID).getPortsColumn().getData().contains(portUUID)) {
203 return Optional.of(SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(),
204 this.bridgeUpdatedRows.get(bridgeUUID)));
207 return Optional.absent();
209 private Optional<InstanceIdentifier<Node>> getTerminationPointBridge(
210 final ReadWriteTransaction transaction, Node node, String tpName) {
211 OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
212 List<ManagedNodeEntry> managedNodes = ovsdbNode.getManagedNodeEntry();
213 for ( ManagedNodeEntry managedNodeEntry : managedNodes ) {
214 @SuppressWarnings("unchecked")
215 Node managedNode = readNode(transaction
216 ,(InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue()).get();
217 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
218 TerminationPointKey tpKey = new TerminationPointKey(new TpId(tpName));
219 tpBuilder.setKey(tpKey);
220 if (managedNode.getTerminationPoint().contains(tpBuilder.build())) {
221 OvsdbBridgeAugmentation ovsdbNodeAugment
222 = managedNode.getAugmentation(OvsdbBridgeAugmentation.class);
223 return Optional.of((InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue());
226 return Optional.absent();
229 private void updateInterfaces(Interface interfaceUpdate,
230 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
232 Column<GenericTableSchema, String> typeColumn = interfaceUpdate.getTypeColumn();
233 String type = typeColumn.getData();
234 updateInterface(interfaceUpdate, type,ovsdbTerminationPointBuilder);
237 private void updatePort(final Port port,
238 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
240 updateVlan(port, ovsdbTerminationPointBuilder);
241 updateVlanTrunks(port, ovsdbTerminationPointBuilder);
242 updateVlanMode(port, ovsdbTerminationPointBuilder);
243 updateQos(port, ovsdbTerminationPointBuilder);
244 updatePortExternalIds(port, ovsdbTerminationPointBuilder);
245 updatePortOtherConfig(port, ovsdbTerminationPointBuilder);
248 private void updateInterface(final Interface interf,
250 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
252 ovsdbTerminationPointBuilder.setInterfaceUuid(
253 new Uuid(interf.getUuid().toString()));
254 ovsdbTerminationPointBuilder.setInterfaceType(
255 SouthboundMapper.createInterfaceType(type));
256 updateOfPort(interf, ovsdbTerminationPointBuilder);
257 updateOfPortRequest(interf, ovsdbTerminationPointBuilder);
258 updateInterfaceExternalIds(interf, ovsdbTerminationPointBuilder);
259 updateOptions(interf, ovsdbTerminationPointBuilder);
260 updateInterfaceOtherConfig(interf, ovsdbTerminationPointBuilder);
261 updateInterfaceLldp(interf, ovsdbTerminationPointBuilder);
264 private void updateVlan(final Port port,
265 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
267 Collection<Long> vlanId = port.getTagColumn().getData();
268 if (vlanId.size() > 0) {
269 Iterator<Long> itr = vlanId.iterator();
270 // There are no loops here, just get the first element.
271 int id = itr.next().intValue();
272 ovsdbTerminationPointBuilder.setVlanTag(new VlanId(id));
276 private void updateVlanTrunks(final Port port,
277 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
279 Set<Long> portTrunks = port.getTrunksColumn().getData();
280 List<Trunks> modelTrunks = new ArrayList<>();
281 if (!portTrunks.isEmpty()) {
282 for (Long trunk: portTrunks) {
284 modelTrunks.add(new TrunksBuilder()
285 .setTrunk(new VlanId(trunk.intValue())).build());
288 ovsdbTerminationPointBuilder.setTrunks(modelTrunks);
292 private void updateVlanMode(final Port port,
293 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
295 Collection<String> vlanMode = port.getVlanModeColumn().getData();
296 if (!vlanMode.isEmpty()) {
297 Iterator<String> itr = vlanMode.iterator();
298 String vlanType = itr.next();
299 if (vlanType.equals(SouthboundConstants.VLANMODES.ACCESS.getMode())) {
300 ovsdbTerminationPointBuilder
301 .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
302 } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_TAGGED.getMode())) {
303 ovsdbTerminationPointBuilder
304 .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeTagged);
305 } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_UNTAGGED.getMode())) {
306 ovsdbTerminationPointBuilder
307 .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeUntagged);
308 } else if (vlanType.equals(SouthboundConstants.VLANMODES.TRUNK.getMode())) {
309 ovsdbTerminationPointBuilder
310 .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Trunk);
312 LOG.debug("Invalid vlan mode {}.", vlanType);
317 private void updateQos(final Port port,
318 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
319 if (port.getQosColumn() == null) {
322 Collection<UUID> qosUuidCol = port.getQosColumn().getData();
323 if (!qosUuidCol.isEmpty()) {
324 Iterator<UUID> itr = qosUuidCol.iterator();
325 UUID qosUuid = itr.next();
326 ovsdbTerminationPointBuilder.setQos(new Uuid(qosUuid.toString()));
330 private void updateOfPort(final Interface interf,
331 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
333 Set<Long> ofPorts = interf.getOpenFlowPortColumn().getData();
334 if (ofPorts != null && !ofPorts.isEmpty()) {
335 Iterator<Long> ofPortsIter = ofPorts.iterator();
336 long ofPort = ofPortsIter.next();
338 ovsdbTerminationPointBuilder
341 LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}",
342 interf.getName(),ofPort);
347 private void updateOfPortRequest(final Interface interf,
348 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
350 Set<Long> ofPortRequests = null;
352 ofPortRequests = interf.getOpenFlowPortRequestColumn().getData();
353 } catch (ColumnSchemaNotFoundException e) {
354 LOG.warn("Cannot find openflow column", e);
356 if (ofPortRequests != null && !ofPortRequests.isEmpty()) {
357 Iterator<Long> ofPortRequestsIter = ofPortRequests.iterator();
358 int ofPort = ofPortRequestsIter.next().intValue();
360 ovsdbTerminationPointBuilder
361 .setOfportRequest(ofPort);
363 LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}",
364 interf.getName(),ofPort);
369 private void updateInterfaceExternalIds(final Interface interf,
370 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
372 Map<String, String> interfaceExternalIds =
373 interf.getExternalIdsColumn().getData();
374 if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
375 Set<String> externalIdKeys = interfaceExternalIds.keySet();
376 List<InterfaceExternalIds> externalIdsList =
378 String externalIdValue;
379 for (String externalIdKey : externalIdKeys) {
380 externalIdValue = interfaceExternalIds.get(externalIdKey);
381 if (externalIdKey != null && externalIdValue != null) {
382 externalIdsList.add(new InterfaceExternalIdsBuilder()
383 .setExternalIdKey(externalIdKey)
384 .setExternalIdValue(externalIdValue).build());
387 ovsdbTerminationPointBuilder.setInterfaceExternalIds(externalIdsList);
391 private void updatePortExternalIds(final Port port,
392 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
394 Map<String, String> portExternalIds = port.getExternalIdsColumn().getData();
395 if (portExternalIds != null && !portExternalIds.isEmpty()) {
396 Set<String> externalIdKeys = portExternalIds.keySet();
397 List<PortExternalIds> externalIdsList = new ArrayList<>();
398 String externalIdValue;
399 for (String externalIdKey : externalIdKeys) {
400 externalIdValue = portExternalIds.get(externalIdKey);
401 if (externalIdKey != null && externalIdValue != null) {
402 externalIdsList.add(new PortExternalIdsBuilder()
403 .setExternalIdKey(externalIdKey)
404 .setExternalIdValue(externalIdValue).build());
407 ovsdbTerminationPointBuilder.setPortExternalIds(externalIdsList);
411 private void updateOptions(final Interface interf,
412 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
414 Map<String, String> optionsMap = interf.getOptionsColumn().getData();
415 if (optionsMap != null && !optionsMap.isEmpty()) {
416 List<Options> options = new ArrayList<>();
417 String optionsValueString;
418 OptionsKey optionsKey;
419 for (String optionsKeyString : optionsMap.keySet()) {
420 optionsValueString = optionsMap.get(optionsKeyString);
421 if (optionsKeyString != null && optionsValueString != null) {
422 optionsKey = new OptionsKey(optionsKeyString);
423 options.add(new OptionsBuilder()
425 .setValue(optionsValueString).build());
428 ovsdbTerminationPointBuilder.setOptions(options);
432 private void updatePortOtherConfig(final Port port,
433 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
435 Map<String, String> portOtherConfigMap = port.getOtherConfigColumn().getData();
436 if (portOtherConfigMap != null && !portOtherConfigMap.isEmpty()) {
437 List<PortOtherConfigs> portOtherConfigs = new ArrayList<>();
438 String portOtherConfigValueString;
439 for (String portOtherConfigKeyString : portOtherConfigMap.keySet()) {
440 portOtherConfigValueString = portOtherConfigMap.get(portOtherConfigKeyString);
441 if (portOtherConfigKeyString != null && portOtherConfigValueString != null) {
442 portOtherConfigs.add(new PortOtherConfigsBuilder()
443 .setOtherConfigKey(portOtherConfigKeyString)
444 .setOtherConfigValue(portOtherConfigValueString).build());
447 ovsdbTerminationPointBuilder.setPortOtherConfigs(portOtherConfigs);
451 private void updateInterfaceLldp(final Interface interf,
452 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
455 Map<String, String> interfaceLldpMap = interf.getLldpColumn().getData();
456 if (interfaceLldpMap != null && !interfaceLldpMap.isEmpty()) {
457 List<InterfaceLldp> interfaceLldpList = new ArrayList<>();
458 for (String interfaceLldpKeyString : interfaceLldpMap.keySet()) {
459 String interfaceLldpValueString = interfaceLldpMap.get(interfaceLldpKeyString);
460 if (interfaceLldpKeyString != null && interfaceLldpValueString!=null) {
461 interfaceLldpList.add(new InterfaceLldpBuilder()
462 .setKey(new InterfaceLldpKey(interfaceLldpKeyString))
463 .setLldpKey(interfaceLldpKeyString)
464 .setLldpValue(interfaceLldpValueString)
468 ovsdbTerminationPointBuilder.setInterfaceLldp(interfaceLldpList);
470 } catch (SchemaVersionMismatchException e) {
471 LOG.debug("lldp column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
475 private void updateInterfaceOtherConfig(final Interface interf,
476 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
478 Map<String, String> interfaceOtherConfigMap = interf.getOtherConfigColumn().getData();
479 if (interfaceOtherConfigMap != null && !interfaceOtherConfigMap.isEmpty()) {
480 List<InterfaceOtherConfigs> interfaceOtherConfigs = new ArrayList<>();
481 String interfaceOtherConfigValueString;
482 for (String interfaceOtherConfigKeyString : interfaceOtherConfigMap.keySet()) {
483 interfaceOtherConfigValueString = interfaceOtherConfigMap.get(interfaceOtherConfigKeyString);
484 if (interfaceOtherConfigKeyString != null && interfaceOtherConfigValueString != null) {
485 interfaceOtherConfigs.add(new InterfaceOtherConfigsBuilder()
486 .setOtherConfigKey(interfaceOtherConfigKeyString)
487 .setOtherConfigValue(interfaceOtherConfigValueString).build());
490 ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(interfaceOtherConfigs);
494 private boolean portQosCleared(Entry<UUID, Port> portUpdate) {
495 if (portUpdate.getValue().getQosColumn() == null) {
498 Collection<UUID> newQos = portUpdate.getValue().getQosColumn().getData();
499 if (portOldRows.get(portUpdate.getKey()).getQosColumn() == null) {
502 Collection<UUID> oldQos = portOldRows.get(portUpdate.getKey()).getQosColumn().getData();
504 if (newQos.isEmpty() && !oldQos.isEmpty()) {
511 private InstanceIdentifier<TerminationPoint> getInstanceIdentifier(InstanceIdentifier<Node> bridgeIid,Port port) {
512 if (port.getExternalIdsColumn() != null
513 && port.getExternalIdsColumn().getData() != null
514 && port.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
515 String iidString = port.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY);
516 return (InstanceIdentifier<TerminationPoint>) SouthboundUtil.deserializeInstanceIdentifier(iidString);
518 return bridgeIid.child(TerminationPoint.class, new TerminationPointKey(new TpId(port.getName())));