X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=southbound%2Fsouthbound-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fovsdb%2Fsouthbound%2Ftransactions%2Fmd%2FOvsdbPortUpdateCommand.java;h=7a5123dfde1d5afeb57f69dd8508e92ba1c4595a;hb=55ce82cbd9fdcb0edf9e629bd2d626b193c6ab26;hp=42aa957f5a4e6acd0f9f342f3918e057bf12e923;hpb=5388a7dfb731ef7eb38d979b35221eb17135d0e1;p=ovsdb.git diff --git a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbPortUpdateCommand.java b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbPortUpdateCommand.java index 42aa957f5..7a5123dfd 100644 --- a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbPortUpdateCommand.java +++ b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbPortUpdateCommand.java @@ -8,16 +8,21 @@ package org.opendaylight.ovsdb.southbound.transactions.md; +import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog; + import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Set; import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.ovsdb.lib.error.ColumnSchemaNotFoundException; +import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException; import org.opendaylight.ovsdb.lib.message.TableUpdates; import org.opendaylight.ovsdb.lib.notation.Column; import org.opendaylight.ovsdb.lib.notation.UUID; @@ -27,27 +32,57 @@ import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils; import org.opendaylight.ovsdb.schema.openvswitch.Bridge; import org.opendaylight.ovsdb.schema.openvswitch.Interface; import org.opendaylight.ovsdb.schema.openvswitch.Port; -import org.opendaylight.ovsdb.southbound.OvsdbClientKey; +import org.opendaylight.ovsdb.schema.openvswitch.Qos; +import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance; +import org.opendaylight.ovsdb.southbound.SouthboundConstants; import org.opendaylight.ovsdb.southbound.SouthboundMapper; +import org.opendaylight.ovsdb.southbound.SouthboundUtil; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid; import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbQosRef; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.external.ids.attributes.ExternalIds; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.external.ids.attributes.ExternalIdsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatus; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatusBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatusKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntry; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntryBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntryKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node; -import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -56,160 +91,597 @@ import com.google.common.base.Optional; public class OvsdbPortUpdateCommand extends AbstractTransactionCommand { private static final Logger LOG = LoggerFactory.getLogger(OvsdbPortUpdateCommand.class); - - public OvsdbPortUpdateCommand(OvsdbClientKey key, TableUpdates updates, + private Map portUpdatedRows; + private Map portOldRows; + private Map interfaceUpdatedRows; + private Map interfaceOldRows; + private Map bridgeUpdatedRows; + private Map qosUpdatedRows; + public OvsdbPortUpdateCommand(OvsdbConnectionInstance key, TableUpdates updates, DatabaseSchema dbSchema) { super(key, updates, dbSchema); + portUpdatedRows = TyperUtils.extractRowsUpdated(Port.class, updates, dbSchema); + portOldRows = TyperUtils.extractRowsOld(Port.class, updates, dbSchema); + interfaceUpdatedRows = TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema); + interfaceOldRows = TyperUtils.extractRowsOld(Interface.class, updates, dbSchema); + bridgeUpdatedRows = TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema); + qosUpdatedRows = TyperUtils.extractRowsUpdated(Qos.class, updates, dbSchema); } @Override public void execute(ReadWriteTransaction transaction) { - String bridgeName = null; - Collection portUpdatedRows = TyperUtils.extractRowsUpdated( - Port.class, getUpdates(), getDbSchema()).values(); - Collection bridgeUpdatedRows = TyperUtils.extractRowsUpdated( - Bridge.class, getUpdates(), getDbSchema()).values(); - for (Bridge bridge : bridgeUpdatedRows) { - Iterator bridgePorts = bridge.getPortsColumn().getData() - .iterator(); - while (bridgePorts.hasNext()) { - UUID portUUID = bridgePorts.next(); - for (Port port : portUpdatedRows) { - if (portUUID.equals(port.getUuid())) { - Collection vlanId = port.getTagColumn().getData(); - Set portTrunks = port.getTrunksColumn().getData(); - bridgeName = bridge.getName(); - NodeId bridgeId = SouthboundMapper.createManagedNodeId( - getKey(), new OvsdbBridgeName(bridgeName)); - final InstanceIdentifier nodePath = SouthboundMapper - .createInstanceIdentifier(bridgeId); - Optional node = Optional.absent(); - try { - node = transaction.read( - LogicalDatastoreType.OPERATIONAL, nodePath) - .checkedGet(); - } catch (final ReadFailedException e) { - LOG.warn("Read Operational/DS for Node fail! {}", - nodePath, e); - } - if (node.isPresent()) { - NodeBuilder nodeBuilder = new NodeBuilder(); - nodeBuilder.setNodeId(bridgeId); - - OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder - = new OvsdbTerminationPointAugmentationBuilder(); - List tpList = new ArrayList(); - TerminationPointBuilder entry = new TerminationPointBuilder(); - entry.setTpId(new TpId(port.getName())); - ovsdbTerminationPointBuilder - .setName(port.getName()); - ovsdbTerminationPointBuilder.setPortUuid(new Uuid( - port.getUuid().toString())); - if (vlanId.size() > 0) { - Iterator itr = vlanId.iterator(); - // There are no loops here, just get the first element. - int id = itr.next().intValue(); - ovsdbTerminationPointBuilder.setVlanTag(new VlanId(id)); - } - List modelTrunks = new ArrayList(); - for (Long trunk: portTrunks) { - if (trunk != null) { - modelTrunks.add(new TrunksBuilder().setTrunk(new VlanId(trunk.intValue())).build()); - } - } - ovsdbTerminationPointBuilder.setTrunks(modelTrunks); - Column> iface = port.getInterfacesColumn(); - Set ifUuid = iface.getData(); - Collection ifUpdateRows = TyperUtils.extractRowsUpdated( - Interface.class, getUpdates(), getDbSchema()).values(); - for (UUID ifIter : ifUuid) { - for (Interface interfIter : ifUpdateRows) { - Column typeColumn = interfIter.getTypeColumn(); - String type = typeColumn.getData(); - if ((interfIter.getUuid()).equals(ifIter)) { - ovsdbTerminationPointBuilder.setInterfaceUuid( - new Uuid(interfIter.getUuid().toString())); - ovsdbTerminationPointBuilder.setInterfaceType( - SouthboundMapper.createInterfaceType(type)); - Set ofPorts = interfIter.getOpenFlowPortColumn().getData(); - if (ofPorts != null && !ofPorts.isEmpty()) { - Iterator ofPortsIter = ofPorts.iterator(); - long ofPort = ofPortsIter.next(); - if (ofPort >= 0) { - ovsdbTerminationPointBuilder - .setOfport(ofPort); - } else { - LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}", - bridge.getName(), interfIter.getName(),ofPort); - } - } - Set ofPortRequests = interfIter - .getOpenFlowPortRequestColumn().getData(); - if (ofPortRequests != null && !ofPortRequests.isEmpty()) { - Iterator ofPortRequestsIter = ofPortRequests.iterator(); - int ofPort = ofPortRequestsIter.next().intValue(); - if (ofPort >= 0) { - ovsdbTerminationPointBuilder - .setOfportRequest(ofPort); - } else { - LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}", - bridge.getName(), interfIter.getName(),ofPort); - } - } - - Map externalIds = interfIter.getExternalIdsColumn().getData(); - if (externalIds != null && !externalIds.isEmpty()) { - Set externalIdKeys = externalIds.keySet(); - ArrayList externalIdsList = new ArrayList(); - String externalIdValue; - for (String externalIdKey : externalIdKeys) { - externalIdValue = externalIds.get(externalIdKey); - if (externalIdKey != null && externalIdValue != null) { - externalIdsList.add(new ExternalIdsBuilder() - .setExternalIdKey(externalIdKey) - .setExternalIdValue(externalIdValue).build()); - } - } - ovsdbTerminationPointBuilder.setExternalIds(externalIdsList); - } - - Map optionsMap = interfIter.getOptionsColumn().getData(); - if (optionsMap != null && !optionsMap.isEmpty()) { - List options = new ArrayList(); - String optionsValueString; - OptionsKey optionsKey; - for (String optionsKeyString : optionsMap.keySet()) { - optionsValueString = optionsMap.get(optionsKeyString); - if (optionsKeyString != null && optionsValueString != null) { - optionsKey = new OptionsKey(optionsKeyString); - options.add(new OptionsBuilder() - .setKey(optionsKey) - .setValue(optionsValueString).build()); - } - } - ovsdbTerminationPointBuilder.setOptions(options); - } - - break; - } - } - } - entry.addAugmentation( - OvsdbTerminationPointAugmentation.class, - ovsdbTerminationPointBuilder.build()); - - tpList.add(entry.build()); - nodeBuilder.setTerminationPoint(tpList); - nodeBuilder.addAugmentation( - OvsdbBridgeAugmentation.class, - node.get().getAugmentation( - OvsdbBridgeAugmentation.class)); - transaction.merge(LogicalDatastoreType.OPERATIONAL, - nodePath, nodeBuilder.build()); + final InstanceIdentifier connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier(); + if ( (portUpdatedRows == null && interfaceOldRows == null ) + || ( interfaceOldRows.isEmpty() && portUpdatedRows.isEmpty())) { + return; + } + Optional node = readNode(transaction, connectionIId); + if (node.isPresent()) { + updateTerminationPoints(transaction, node.get()); + } + } + private void updateTerminationPoints(ReadWriteTransaction transaction, Node node) { + for (Entry portUpdate : portUpdatedRows.entrySet()) { + String portName = null; + portName = portUpdate.getValue().getNameColumn().getData(); + Optional> bridgeIid = getTerminationPointBridge(portUpdate.getKey()); + if (!bridgeIid.isPresent()) { + bridgeIid = getTerminationPointBridge( transaction, node, portName); + } + if (bridgeIid.isPresent()) { + NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get()); + TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName)); + TerminationPointBuilder tpBuilder = new TerminationPointBuilder(); + tpBuilder.setKey(tpKey); + tpBuilder.setTpId(tpKey.getTpId()); + InstanceIdentifier tpPath = + getInstanceIdentifier(bridgeIid.get(), portUpdate.getValue()); + OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = + new OvsdbTerminationPointAugmentationBuilder(); + buildTerminationPoint(transaction, tpPath, tpAugmentationBuilder, node, portUpdate); + UUID interfaceUUID = (UUID)portUpdate.getValue().getInterfacesColumn().getData().toArray()[0]; + if (interfaceUpdatedRows.containsKey(interfaceUUID)) { + buildTerminationPoint(tpAugmentationBuilder, + interfaceUpdatedRows.get(interfaceUUID)); + interfaceUpdatedRows.remove(interfaceUUID); + interfaceOldRows.remove(interfaceUUID); + } + tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build()); + if (portOldRows.containsKey(portUpdate.getKey()) && !portQosCleared(portUpdate)) { + transaction.merge(LogicalDatastoreType.OPERATIONAL, + tpPath, tpBuilder.build()); + } else { + transaction.put(LogicalDatastoreType.OPERATIONAL, + tpPath, tpBuilder.build()); + } + } + } + for (Entry interfaceUpdate : interfaceUpdatedRows.entrySet()) { + String interfaceName = null; + interfaceName = interfaceUpdatedRows.get(interfaceUpdate.getKey()).getNameColumn().getData(); + Optional> bridgeIid = getTerminationPointBridge( transaction, node, interfaceName); + if (bridgeIid.isPresent()) { + NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get()); + TerminationPointKey tpKey = new TerminationPointKey(new TpId(interfaceName)); + InstanceIdentifier tpPath = InstanceIdentifier + .create(NetworkTopology.class) + .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID)) + .child(Node.class,new NodeKey(bridgeId)) + .child(TerminationPoint.class,tpKey); + TerminationPointBuilder tpBuilder = new TerminationPointBuilder(); + tpBuilder.setKey(tpKey); + tpBuilder.setTpId(tpKey.getTpId()); + OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = + new OvsdbTerminationPointAugmentationBuilder(); + buildTerminationPoint(tpAugmentationBuilder, interfaceUpdate.getValue()); + tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build()); + transaction.merge(LogicalDatastoreType.OPERATIONAL, + tpPath, tpBuilder.build()); + } + } + + } + private void buildTerminationPoint(ReadWriteTransaction transaction, + InstanceIdentifier tpPath, + OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder, + Node node, Entry portUpdate) { + + tpAugmentationBuilder + .setName(portUpdate.getValue().getName()); + tpAugmentationBuilder.setPortUuid(new Uuid( + portUpdate.getValue().getUuid().toString())); + updatePort(transaction, node, tpPath, portUpdate, tpAugmentationBuilder); + } + + private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder, + Interface interfaceUpdate) { + + tpAugmentationBuilder + .setName(interfaceUpdate.getName()); + tpAugmentationBuilder.setInterfaceUuid(new Uuid( + interfaceUpdate.getUuid().toString())); + updateInterfaces(interfaceUpdate, tpAugmentationBuilder); + } + + private Optional readNode(final ReadWriteTransaction transaction, final InstanceIdentifier nodePath) { + Optional node = Optional.absent(); + try { + node = transaction.read( + LogicalDatastoreType.OPERATIONAL, nodePath) + .checkedGet(); + } catch (final ReadFailedException e) { + LOG.warn("Read Operational/DS for Node fail! {}", + nodePath, e); + } + return node; + } + + private Optional> getTerminationPointBridge( UUID portUUID) { + for (UUID bridgeUUID : this.bridgeUpdatedRows.keySet()) { + if (this.bridgeUpdatedRows.get(bridgeUUID).getPortsColumn().getData().contains(portUUID)) { + return Optional.of(SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(), + this.bridgeUpdatedRows.get(bridgeUUID))); + } + } + return Optional.absent(); + } + private Optional> getTerminationPointBridge( + final ReadWriteTransaction transaction, Node node, String tpName) { + OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class); + List managedNodes = ovsdbNode.getManagedNodeEntry(); + TpId tpId = new TpId(tpName); + for ( ManagedNodeEntry managedNodeEntry : managedNodes ) { + @SuppressWarnings("unchecked") + Node managedNode = readNode(transaction + ,(InstanceIdentifier)managedNodeEntry.getBridgeRef().getValue()).get(); + for (TerminationPoint tpEntry : managedNode.getTerminationPoint()) { + if (tpId.equals(tpEntry.getTpId())) { + return Optional.of((InstanceIdentifier)managedNodeEntry.getBridgeRef().getValue()); + } + } + } + return Optional.absent(); + } + + private void updateInterfaces(Interface interfaceUpdate, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Column typeColumn = interfaceUpdate.getTypeColumn(); + String type = typeColumn.getData(); + updateInterface(interfaceUpdate, type,ovsdbTerminationPointBuilder); + } + + private void updatePort(final ReadWriteTransaction transaction, final Node node, + final InstanceIdentifier tpPath, final Entry port, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + updateVlan(port.getValue(), ovsdbTerminationPointBuilder); + updateVlanTrunks(port.getValue(), ovsdbTerminationPointBuilder); + updateVlanMode(port.getValue(), ovsdbTerminationPointBuilder); + updateQos(transaction, node, tpPath, port, ovsdbTerminationPointBuilder); + updatePortExternalIds(port.getValue(), ovsdbTerminationPointBuilder); + updatePortOtherConfig(port.getValue(), ovsdbTerminationPointBuilder); + } + + private void updateInterface(final Interface interf, + final String type, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + ovsdbTerminationPointBuilder.setInterfaceUuid( + new Uuid(interf.getUuid().toString())); + ovsdbTerminationPointBuilder.setInterfaceType( + SouthboundMapper.createInterfaceType(type)); + updateOfPort(interf, ovsdbTerminationPointBuilder); + updateOfPortRequest(interf, ovsdbTerminationPointBuilder); + updateInterfaceExternalIds(interf, ovsdbTerminationPointBuilder); + updateOptions(interf, ovsdbTerminationPointBuilder); + updateInterfaceOtherConfig(interf, ovsdbTerminationPointBuilder); + updateInterfaceLldp(interf, ovsdbTerminationPointBuilder); + updateInterfaceBfd(interf, ovsdbTerminationPointBuilder); + updateInterfaceBfdStatus(interf, ovsdbTerminationPointBuilder); + updateInterfacePolicing(interf, ovsdbTerminationPointBuilder); + } + + private void updateVlan(final Port port, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Collection vlanId = port.getTagColumn().getData(); + if (vlanId.size() > 0) { + Iterator itr = vlanId.iterator(); + // There are no loops here, just get the first element. + int id = itr.next().intValue(); + ovsdbTerminationPointBuilder.setVlanTag(new VlanId(id)); + } + } + + private void updateVlanTrunks(final Port port, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Set portTrunks = port.getTrunksColumn().getData(); + List modelTrunks = new ArrayList<>(); + if (!portTrunks.isEmpty()) { + for (Long trunk: portTrunks) { + if (trunk != null) { + modelTrunks.add(new TrunksBuilder() + .setTrunk(new VlanId(trunk.intValue())).build()); + } + } + ovsdbTerminationPointBuilder.setTrunks(modelTrunks); + } + } + + private void updateVlanMode(final Port port, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Collection vlanMode = port.getVlanModeColumn().getData(); + if (!vlanMode.isEmpty()) { + Iterator itr = vlanMode.iterator(); + String vlanType = itr.next(); + if (vlanType.equals(SouthboundConstants.VLANMODES.ACCESS.getMode())) { + ovsdbTerminationPointBuilder + .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access); + } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_TAGGED.getMode())) { + ovsdbTerminationPointBuilder + .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeTagged); + } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_UNTAGGED.getMode())) { + ovsdbTerminationPointBuilder + .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeUntagged); + } else if (vlanType.equals(SouthboundConstants.VLANMODES.TRUNK.getMode())) { + ovsdbTerminationPointBuilder + .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Trunk); + } else { + LOG.debug("Invalid vlan mode {}.", vlanType); + } + } + } + + private void updateQos(final ReadWriteTransaction transaction, final Node node, InstanceIdentifier tpPath, + final Entry port, final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + if (port.getValue() == null) { + return; + } + Collection qosUuidCol = port.getValue().getQosColumn().getData(); + if (!qosUuidCol.isEmpty()) { + UUID qosUuid = qosUuidCol.iterator().next(); + ovsdbTerminationPointBuilder.setQos(new Uuid(qosUuid.toString())); + + NodeId nodeId = node.getNodeId(); + OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class); + + // Delete an older QoS entry + if (portOldRows.containsKey(port.getKey()) && + portOldRows.get(port.getKey()).getQosColumn() != null) { + Collection oldQos = portOldRows.get(port.getKey()).getQosColumn().getData(); + if (!oldQos.isEmpty()) { + UUID oldQosUuid = oldQos.iterator().next(); + if (!oldQosUuid.equals(qosUuid)) { + InstanceIdentifier oldQosIid = getQosIid(nodeId, ovsdbNode, oldQosUuid); + if (oldQosIid != null) { + InstanceIdentifier oldPortQosIid = tpPath + .augmentation(OvsdbTerminationPointAugmentation.class) + .child(QosEntry.class, + new QosEntryKey(new Long(SouthboundConstants.PORT_QOS_LIST_KEY))); +// new QosEntryKey(new OvsdbQosRef(oldQosIid))); + transaction.delete(LogicalDatastoreType.OPERATIONAL, oldPortQosIid); } } } } + + InstanceIdentifier qosIid = getQosIid(nodeId, ovsdbNode, qosUuid); + if (qosIid != null) { + List qosList = new ArrayList<>(); + OvsdbQosRef qosRef = new OvsdbQosRef(qosIid); + qosList.add(new QosEntryBuilder() + .setKey(new QosEntryKey(new Long(SouthboundConstants.PORT_QOS_LIST_KEY))) + .setQosRef(qosRef).build()); + ovsdbTerminationPointBuilder.setQosEntry(qosList); + } + } + } + + private InstanceIdentifier getQosIid(NodeId nodeId, OvsdbNodeAugmentation ovsdbNode, UUID qosUuid) { + // Search for the QoS entry first in the operational datastore + for (QosEntries qosEntry : ovsdbNode.getQosEntries()) { + if (qosEntry.getQosUuid().equals(new Uuid(qosUuid.toString()))) { + return SouthboundMapper.createInstanceIdentifier(nodeId) + .augmentation(OvsdbNodeAugmentation.class) + .child(QosEntries.class, new QosEntriesKey(qosEntry.getQosId())); + } + } + + // Search for the QoS entry in the current OVS updates + for (Entry qosUpdate : qosUpdatedRows.entrySet()) { + Qos qos = qosUpdate.getValue(); + if (qos.getUuid().equals(qosUuid)) { + if (qos.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) { + return (InstanceIdentifier) SouthboundUtil.deserializeInstanceIdentifier( + qos.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY)); + } else { + return SouthboundMapper.createInstanceIdentifier(nodeId) + .augmentation(OvsdbNodeAugmentation.class) + .child(QosEntries.class, new QosEntriesKey( + new Uri(SouthboundConstants.QOS_URI_PREFIX + "://" + qosUuid.toString()))); + } + } + } + LOG.debug("QoS UUID {} assigned to port not found in operational node {} or QoS updates", qosUuid, ovsdbNode); + return SouthboundMapper.createInstanceIdentifier(nodeId) + .augmentation(OvsdbNodeAugmentation.class) + .child(QosEntries.class, new QosEntriesKey( + new Uri(SouthboundConstants.QOS_URI_PREFIX + "://" + qosUuid.toString()))); + } + + private void updateOfPort(final Interface interf, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Set ofPorts = interf.getOpenFlowPortColumn().getData(); + if (ofPorts != null && !ofPorts.isEmpty()) { + Iterator ofPortsIter = ofPorts.iterator(); + long ofPort = ofPortsIter.next(); + if (ofPort >= 0) { + ovsdbTerminationPointBuilder + .setOfport(ofPort); + } else { + LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}", + interf.getName(),ofPort); + } + } + } + + private void updateOfPortRequest(final Interface interf, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Set ofPortRequests = null; + try { + ofPortRequests = interf.getOpenFlowPortRequestColumn().getData(); + } catch (ColumnSchemaNotFoundException e) { + LOG.warn("Cannot find openflow column", e); + } + if (ofPortRequests != null && !ofPortRequests.isEmpty()) { + Iterator ofPortRequestsIter = ofPortRequests.iterator(); + int ofPort = ofPortRequestsIter.next().intValue(); + if (ofPort >= 0) { + ovsdbTerminationPointBuilder + .setOfportRequest(ofPort); + } else { + LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}", + interf.getName(),ofPort); + } + } + } + + private void updateInterfaceExternalIds(final Interface interf, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Map interfaceExternalIds = + interf.getExternalIdsColumn().getData(); + if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) { + Set externalIdKeys = interfaceExternalIds.keySet(); + List externalIdsList = + new ArrayList<>(); + String externalIdValue; + for (String externalIdKey : externalIdKeys) { + externalIdValue = interfaceExternalIds.get(externalIdKey); + if (externalIdKey != null && externalIdValue != null) { + externalIdsList.add(new InterfaceExternalIdsBuilder() + .setExternalIdKey(externalIdKey) + .setExternalIdValue(externalIdValue).build()); + } + } + ovsdbTerminationPointBuilder.setInterfaceExternalIds(externalIdsList); + } + } + + private void updatePortExternalIds(final Port port, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Map portExternalIds = port.getExternalIdsColumn().getData(); + if (portExternalIds != null && !portExternalIds.isEmpty()) { + Set externalIdKeys = portExternalIds.keySet(); + List externalIdsList = new ArrayList<>(); + String externalIdValue; + for (String externalIdKey : externalIdKeys) { + externalIdValue = portExternalIds.get(externalIdKey); + if (externalIdKey != null && externalIdValue != null) { + externalIdsList.add(new PortExternalIdsBuilder() + .setExternalIdKey(externalIdKey) + .setExternalIdValue(externalIdValue).build()); + } + } + ovsdbTerminationPointBuilder.setPortExternalIds(externalIdsList); + } + } + + private void updateOptions(final Interface interf, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Map optionsMap = interf.getOptionsColumn().getData(); + if (optionsMap != null && !optionsMap.isEmpty()) { + List options = new ArrayList<>(); + String optionsValueString; + OptionsKey optionsKey; + for (String optionsKeyString : optionsMap.keySet()) { + optionsValueString = optionsMap.get(optionsKeyString); + if (optionsKeyString != null && optionsValueString != null) { + optionsKey = new OptionsKey(optionsKeyString); + options.add(new OptionsBuilder() + .setKey(optionsKey) + .setValue(optionsValueString).build()); + } + } + ovsdbTerminationPointBuilder.setOptions(options); + } + } + + private void updatePortOtherConfig(final Port port, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Map portOtherConfigMap = port.getOtherConfigColumn().getData(); + if (portOtherConfigMap != null && !portOtherConfigMap.isEmpty()) { + List portOtherConfigs = new ArrayList<>(); + String portOtherConfigValueString; + for (String portOtherConfigKeyString : portOtherConfigMap.keySet()) { + portOtherConfigValueString = portOtherConfigMap.get(portOtherConfigKeyString); + if (portOtherConfigKeyString != null && portOtherConfigValueString != null) { + portOtherConfigs.add(new PortOtherConfigsBuilder() + .setOtherConfigKey(portOtherConfigKeyString) + .setOtherConfigValue(portOtherConfigValueString).build()); + } + } + ovsdbTerminationPointBuilder.setPortOtherConfigs(portOtherConfigs); + } + } + + private void updateInterfaceLldp(final Interface interf, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + try { + Map interfaceLldpMap = interf.getLldpColumn().getData(); + if (interfaceLldpMap != null && !interfaceLldpMap.isEmpty()) { + List interfaceLldpList = new ArrayList<>(); + for (String interfaceLldpKeyString : interfaceLldpMap.keySet()) { + String interfaceLldpValueString = interfaceLldpMap.get(interfaceLldpKeyString); + if (interfaceLldpKeyString != null && interfaceLldpValueString!=null) { + interfaceLldpList.add(new InterfaceLldpBuilder() + .setKey(new InterfaceLldpKey(interfaceLldpKeyString)) + .setLldpKey(interfaceLldpKeyString) + .setLldpValue(interfaceLldpValueString) + .build()); + } + } + ovsdbTerminationPointBuilder.setInterfaceLldp(interfaceLldpList); + } + } catch (SchemaVersionMismatchException e) { + schemaMismatchLog("lldp", "Interface", e); + } + } + + private void updateInterfaceOtherConfig(final Interface interf, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Map interfaceOtherConfigMap = interf.getOtherConfigColumn().getData(); + if (interfaceOtherConfigMap != null && !interfaceOtherConfigMap.isEmpty()) { + List interfaceOtherConfigs = new ArrayList<>(); + String interfaceOtherConfigValueString; + for (String interfaceOtherConfigKeyString : interfaceOtherConfigMap.keySet()) { + interfaceOtherConfigValueString = interfaceOtherConfigMap.get(interfaceOtherConfigKeyString); + if (interfaceOtherConfigKeyString != null && interfaceOtherConfigValueString != null) { + interfaceOtherConfigs.add(new InterfaceOtherConfigsBuilder() + .setOtherConfigKey(interfaceOtherConfigKeyString) + .setOtherConfigValue(interfaceOtherConfigValueString).build()); + } + } + ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(interfaceOtherConfigs); + } + } + + private void updateInterfaceBfdStatus(final Interface interf, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + try { + Map interfaceBfdStatusMap = interf.getBfdStatusColumn().getData(); + if (interfaceBfdStatusMap != null && !interfaceBfdStatusMap.isEmpty()) { + List interfaceBfdStatusList = new ArrayList<>(); + for (String interfaceBfdStatusKeyString : interfaceBfdStatusMap.keySet()) { + String interfaceBfdStatusValueString = interfaceBfdStatusMap.get(interfaceBfdStatusKeyString); + if (interfaceBfdStatusKeyString != null && interfaceBfdStatusValueString!=null) { + interfaceBfdStatusList.add(new InterfaceBfdStatusBuilder() + .setKey(new InterfaceBfdStatusKey(interfaceBfdStatusKeyString)) + .setBfdStatusKey(interfaceBfdStatusKeyString) + .setBfdStatusValue(interfaceBfdStatusValueString) + .build()); + } + } + ovsdbTerminationPointBuilder.setInterfaceBfdStatus(interfaceBfdStatusList); + } + } catch (SchemaVersionMismatchException e) { + schemaMismatchLog("bfd", "Interface", e); + } + } + + private void updateInterfaceBfd(final Interface interf, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + try { + Map interfaceBfdMap = interf.getBfdColumn().getData(); + if (interfaceBfdMap != null && !interfaceBfdMap.isEmpty()) { + List interfaceBfdList = new ArrayList<>(); + for (String interfaceBfdKeyString : interfaceBfdMap.keySet()) { + String interfaceBfdValueString = interfaceBfdMap.get(interfaceBfdKeyString); + if (interfaceBfdKeyString != null && interfaceBfdValueString!=null) { + interfaceBfdList.add(new InterfaceBfdBuilder() + .setKey(new InterfaceBfdKey(interfaceBfdKeyString)) + .setBfdKey(interfaceBfdKeyString) + .setBfdValue(interfaceBfdValueString) + .build()); + } + } + ovsdbTerminationPointBuilder.setInterfaceBfd(interfaceBfdList); + } + } catch (SchemaVersionMismatchException e) { + schemaMismatchLog("bfd", "Interface", e); + + } + } + + private void updateInterfacePolicing(final Interface interf, + final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) { + + Long ingressPolicingRate = null; + if (interf.getIngressPolicingRateColumn() != null) { + ingressPolicingRate = interf.getIngressPolicingRateColumn().getData(); + } + if (ingressPolicingRate != null) { + if (ingressPolicingRate >= 0) { + ovsdbTerminationPointBuilder + .setIngressPolicingRate(ingressPolicingRate); + } else { + LOG.debug("Received negative value for ingressPolicingRate from ovsdb for {} {}", + interf.getName(),ingressPolicingRate); + } + } + + Long ingressPolicingBurst = null; + if (interf.getIngressPolicingBurstColumn() != null) { + ingressPolicingBurst = interf.getIngressPolicingBurstColumn().getData(); + } + if (ingressPolicingBurst != null) { + if (ingressPolicingBurst >= 0) { + ovsdbTerminationPointBuilder + .setIngressPolicingBurst(ingressPolicingBurst); + } else { + LOG.debug("Received negative value for ingressPolicingBurst from ovsdb for {} {}", + interf.getName(),ingressPolicingBurst); + } + } + } + + private boolean portQosCleared(Entry portUpdate) { + if (portUpdate.getValue().getQosColumn() == null) { + return false; + } + Collection newQos = portUpdate.getValue().getQosColumn().getData(); + if (portOldRows.get(portUpdate.getKey()).getQosColumn() == null) { + return false; + } + Collection oldQos = portOldRows.get(portUpdate.getKey()).getQosColumn().getData(); + + if (newQos.isEmpty() && !oldQos.isEmpty()) { + return true; + } else { + return false; + } + } + + private InstanceIdentifier getInstanceIdentifier(InstanceIdentifier bridgeIid,Port port) { + if (port.getExternalIdsColumn() != null + && port.getExternalIdsColumn().getData() != null + && port.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) { + String iidString = port.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY); + return (InstanceIdentifier) SouthboundUtil.deserializeInstanceIdentifier(iidString); + } else { + return bridgeIid.child(TerminationPoint.class, new TerminationPointKey(new TpId(port.getName()))); } } }