+
+ InstanceIdentifier<QosEntries> qosIid = getQosIid(nodeId, ovsdbNode, qosUuid);
+ if (qosIid != null) {
+ List<QosEntry> 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);
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private InstanceIdentifier<QosEntries> 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<UUID, Qos> qosUpdate : qosUpdatedRows.entrySet()) {
+ Qos qos = qosUpdate.getValue();
+ if (qos.getUuid().equals(qosUuid)) {
+ if (qos.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
+ return (InstanceIdentifier<QosEntries>) 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 updateIfIndex(final Interface interf,
+ final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
+ Set<Long> ifIndexSet = null;
+ try {
+ if (interf.getIfIndexColumn() != null) {
+ ifIndexSet = interf.getIfIndexColumn().getData();
+ }
+ if (ifIndexSet != null && !ifIndexSet.isEmpty()) {
+ for (Long ifIndex : ifIndexSet) {
+ ovsdbTerminationPointBuilder.setIfindex(ifIndex);
+ }
+ }
+ } catch (SchemaVersionMismatchException e) {
+ schemaMismatchLog("ifindex", "Interface", e);
+ }
+ }
+
+ private void updateOfPort(final Interface interf,
+ final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
+
+ Set<Long> ofPorts = interf.getOpenFlowPortColumn().getData();
+ if (ofPorts != null && !ofPorts.isEmpty()) {
+ Iterator<Long> 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<Long> ofPortRequests = null;
+ try {
+ ofPortRequests = interf.getOpenFlowPortRequestColumn().getData();
+ } catch (ColumnSchemaNotFoundException e) {
+ LOG.warn("Cannot find openflow column", e);
+ }
+ if (ofPortRequests != null && !ofPortRequests.isEmpty()) {
+ Iterator<Long> 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<String, String> interfaceExternalIds =
+ interf.getExternalIdsColumn().getData();
+ if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
+ Set<String> externalIdKeys = interfaceExternalIds.keySet();
+ List<InterfaceExternalIds> 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<String, String> portExternalIds = port.getExternalIdsColumn().getData();
+ if (portExternalIds != null && !portExternalIds.isEmpty()) {
+ Set<String> externalIdKeys = portExternalIds.keySet();
+ List<PortExternalIds> 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<String, String> optionsMap = interf.getOptionsColumn().getData();
+ if (optionsMap != null && !optionsMap.isEmpty()) {
+ List<Options> 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<String, String> portOtherConfigMap = port.getOtherConfigColumn().getData();
+ if (portOtherConfigMap != null && !portOtherConfigMap.isEmpty()) {
+ List<PortOtherConfigs> 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<String, String> interfaceLldpMap = interf.getLldpColumn().getData();
+ if (interfaceLldpMap != null && !interfaceLldpMap.isEmpty()) {
+ List<InterfaceLldp> 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<String, String> interfaceOtherConfigMap = interf.getOtherConfigColumn().getData();
+ if (interfaceOtherConfigMap != null && !interfaceOtherConfigMap.isEmpty()) {
+ List<InterfaceOtherConfigs> 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<String, String> interfaceBfdStatusMap = interf.getBfdStatusColumn().getData();
+ if (interfaceBfdStatusMap != null && !interfaceBfdStatusMap.isEmpty()) {
+ List<InterfaceBfdStatus> 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<String, String> interfaceBfdMap = interf.getBfdColumn().getData();
+ if (interfaceBfdMap != null && !interfaceBfdMap.isEmpty()) {
+ List<InterfaceBfd> 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<UUID, Port> portUpdate) {
+ if (portUpdate.getValue().getQosColumn() == null) {
+ return false;
+ }
+ Collection<UUID> newQos = portUpdate.getValue().getQosColumn().getData();
+ if (portOldRows.get(portUpdate.getKey()).getQosColumn() == null) {
+ return false;
+ }
+ Collection<UUID> oldQos = portOldRows.get(portUpdate.getKey()).getQosColumn().getData();
+
+ if (newQos.isEmpty() && !oldQos.isEmpty()) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private InstanceIdentifier<TerminationPoint> getInstanceIdentifier(InstanceIdentifier<Node> 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<TerminationPoint>) SouthboundUtil.deserializeInstanceIdentifier(iidString);
+ } else {
+ return bridgeIid.child(TerminationPoint.class, new TerminationPointKey(new TpId(port.getName())));