X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=common%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Fcommon%2Fmapping%2FPortMappingVersion121.java;h=70e9e98d97ec0597cb71d3db8dec45af86b2a3f6;hb=9732c621dfe6aa4901d2bc763a17a667a386ed07;hp=8da3ec21ba646c721e7ac0bfe007f4c217159ab7;hpb=1bf7f298852d03faf47011c75978ce44bee135d7;p=transportpce.git diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java index 8da3ec21b..70e9e98d9 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java @@ -9,42 +9,44 @@ package org.opendaylight.transportpce.common.mapping; import com.google.common.util.concurrent.FluentFuture; +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Optional; import java.util.concurrent.ExecutionException; import java.util.stream.Collectors; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.WriteTransaction; import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.transportpce.common.StringConstants; import org.opendaylight.transportpce.common.Timeouts; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.Network; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.NetworkBuilder; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.Nodes; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.NodesBuilder; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.NodesKey; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.CpToDegree; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.CpToDegreeBuilder; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.CpToDegreeKey; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.Mapping; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.MappingBuilder; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.MappingKey; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.NodeInfo; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.NodeInfo.OpenroadmVersion; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.NodeInfoBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.Network; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.NetworkBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.Nodes; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.NodesBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.NodesKey; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.CpToDegree; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.CpToDegreeBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.CpToDegreeKey; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.Mapping; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.MappingBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.MappingKey; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.NodeInfo; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.NodeInfo.OpenroadmVersion; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.NodeInfoBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.Direction; -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.NodeTypes; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.CircuitPack; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.Port; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.Ports; @@ -62,7 +64,9 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.open import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Protocols; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.connection.map.Destination; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes; import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.InterfaceType; import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpenROADMOpticalMultiplex; import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpticalTransport; @@ -70,12 +74,16 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.Protocols1 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.Lldp; import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfig; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.common.Uint16; +import org.opendaylight.yangtools.yang.common.Uint32; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +// FIXME: many common pieces of code between PortMapping Versions 121 and 221 and 710 +// some mutualization would be helpful public class PortMappingVersion121 { - private static final Logger LOG = LoggerFactory.getLogger(PortMappingImpl.class); + private static final Logger LOG = LoggerFactory.getLogger(PortMappingVersion121.class); private final DataBroker dataBroker; private final DeviceTransactionManager deviceTransactionManager; @@ -94,20 +102,16 @@ public class PortMappingVersion121 { InstanceIdentifier infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class); Optional deviceInfoOptional = this.deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType .OPERATIONAL, infoIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); - Info deviceInfo; - NodeInfo nodeInfo; - if (deviceInfoOptional.isPresent()) { - deviceInfo = deviceInfoOptional.get(); - nodeInfo = createNodeInfo(deviceInfo); - if (nodeInfo == null) { - return false; - } else { - postPortMapping(nodeId, nodeInfo, null, null); - } - } else { + if (!deviceInfoOptional.isPresent()) { LOG.warn("Device info subtree is absent for {}", nodeId); return false; } + Info deviceInfo = deviceInfoOptional.get(); + NodeInfo nodeInfo = createNodeInfo(deviceInfo); + if (nodeInfo == null) { + return false; + } + postPortMapping(nodeId, nodeInfo, null, null); switch (deviceInfo.getNodeType()) { @@ -141,36 +145,35 @@ public class PortMappingVersion121 { } public boolean updateMapping(String nodeId, Mapping oldMapping) { - LOG.info("Updating Mapping Data {} for node {}", oldMapping, nodeId); InstanceIdentifier portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class) .child(CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName())) .child(Ports.class, new PortsKey(oldMapping.getSupportingPort())); - if ((oldMapping != null) && (nodeId != null)) { - try { - Optional portObject = deviceTransactionManager.getDataFromDevice(nodeId, - LogicalDatastoreType.OPERATIONAL, portIId, Timeouts.DEVICE_READ_TIMEOUT, - Timeouts.DEVICE_READ_TIMEOUT_UNIT); - if (portObject.isPresent()) { - Ports port = portObject.get(); - Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(), - oldMapping.getLogicalConnectionPoint()); - - final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction(); - InstanceIdentifier mapIID = InstanceIdentifier.create(Network.class) - .child(Nodes.class, new NodesKey(nodeId)) - .child(Mapping.class, new MappingKey(oldMapping.getLogicalConnectionPoint())); - writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, mapIID, newMapping); - FluentFuture commit = writeTransaction.commit(); - commit.get(); - return true; - } - return false; - } catch (InterruptedException | ExecutionException e) { - LOG.error("Error updating Mapping {} for node {}", oldMapping.getLogicalConnectionPoint(), nodeId, e); + if ((oldMapping == null) || (nodeId == null)) { + LOG.error("Impossible to update mapping"); + return false; + } + try { + Optional portObject = deviceTransactionManager.getDataFromDevice(nodeId, + LogicalDatastoreType.OPERATIONAL, portIId, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (!portObject.isPresent()) { return false; } - } else { - LOG.error("Impossible to update mapping"); + Ports port = portObject.get(); + Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(), + oldMapping.getLogicalConnectionPoint()); + LOG.info("Updating old mapping Data {} for {} of {} by new mapping data {}", + oldMapping, oldMapping.getLogicalConnectionPoint(), nodeId, newMapping); + final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction(); + InstanceIdentifier mapIID = InstanceIdentifier.create(Network.class) + .child(Nodes.class, new NodesKey(nodeId)) + .child(Mapping.class, new MappingKey(oldMapping.getLogicalConnectionPoint())); + writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, mapIID, newMapping); + FluentFuture commit = writeTransaction.commit(); + commit.get(); + return true; + } catch (InterruptedException | ExecutionException e) { + LOG.error("Error updating Mapping {} for node {}", oldMapping.getLogicalConnectionPoint(), nodeId, e); return false; } } @@ -181,20 +184,22 @@ public class PortMappingVersion121 { Optional deviceObject = deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, deviceIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); - + if (!deviceObject.isPresent()) { + LOG.error("Impossible to get device configuration for node {}", nodeId); + return false; + } + OrgOpenroadmDevice device = deviceObject.get(); + if (device.getCircuitPacks() == null) { + LOG.warn("Circuit Packs are not present for {}", nodeId); + return false; + } // Variable to keep track of number of line ports int line = 1; // Variable to keep track of number of client ports int client = 1; - if (!deviceObject.isPresent() || deviceObject.get().getCircuitPacks() == null) { - LOG.warn("Circuit Packs are not present for {}", nodeId); - return false; - // TODO return false or continue? - } Map lcpMap = new HashMap<>(); Map mappingMap = new HashMap<>(); - - List circuitPackList = deviceObject.get().getCircuitPacks(); + List circuitPackList = new ArrayList<>(device.nonnullCircuitPacks().values()); circuitPackList.sort(Comparator.comparing(CircuitPack::getCircuitPackName)); for (CircuitPacks cp : circuitPackList) { @@ -203,7 +208,9 @@ public class PortMappingVersion121 { LOG.warn("Ports were not found for circuit pack: {}", circuitPackName); continue; } - List portList = cp.getPorts(); + + // com.google.common.collect.ImmutableList implementation of List + List portList = new ArrayList<>(cp.nonnullPorts().values()); portList.sort(Comparator.comparing(Ports::getPortName)); for (Ports port : portList) { if (port.getPortQual() == null) { @@ -229,7 +236,8 @@ public class PortMappingVersion121 { Optional cpOpt = circuitPackList.stream().filter(cP -> cP.getCircuitPackName() .equals(port.getPartnerPort().getCircuitPackName())).findFirst(); if (cpOpt.isPresent()) { - Optional poOpt = cpOpt.get().getPorts().stream().filter(p -> p.getPortName().equals(port + Optional poOpt = cpOpt.get().nonnullPorts() + .values().stream().filter(p -> p.getPortName().equals(port .getPartnerPort().getPortName().toString())).findFirst(); if (poOpt.isPresent()) { Ports port2 = poOpt.get(); @@ -283,27 +291,30 @@ public class PortMappingVersion121 { } } } - List connectionMap = deviceObject.get().getConnectionMap(); - String slcp = null; - String dlcp = null; + + Collection connectionMap = deviceObject.get().nonnullConnectionMap().values(); for (ConnectionMap cm : connectionMap) { + String slcp = null; + String dlcp = null; String skey = cm.getSource().getCircuitPackName() + "+" + cm.getSource().getPortName(); if (lcpMap.containsKey(skey)) { slcp = lcpMap.get(skey); } - String dkey = cm.getDestination().get(0).getCircuitPackName() + "+" - + cm.getDestination().get(0).getPortName(); + Destination destination0 = cm.nonnullDestination().values().iterator().next(); + String dkey = destination0.getCircuitPackName() + "+" + destination0.getPortName(); if (lcpMap.containsKey(dkey)) { dlcp = lcpMap.get(dkey); } - if (slcp != null) { - Mapping mapping = mappingMap.get(slcp); - mappingMap.remove(slcp); - portMapList.add(createXpdrMappingObject(nodeId, null, null, null, null, mapping, dlcp)); - } else { - LOG.error("Error in connection-map analysis"); + if (slcp == null) { + LOG.error("Error in connection-map analysis for source {} and destination (circuitpack+port) {}", + skey, dkey); + continue; } + Mapping mapping = mappingMap.get(slcp); + mappingMap.remove(slcp); + portMapList.add(createXpdrMappingObject(nodeId, null, null, null, null, mapping, dlcp)); } + if (!mappingMap.isEmpty()) { for (Mapping m : mappingMap.values()) { portMapList.add(m); @@ -320,7 +331,7 @@ public class PortMappingVersion121 { // Get value for max Srg from info subtree, required for iteration // if not present assume to be 20 (temporary) if (ordmInfo.getMaxSrgs() != null) { - maxSrg = ordmInfo.getMaxSrgs(); + maxSrg = ordmInfo.getMaxSrgs().toJava(); } else { maxSrg = 20; } @@ -329,13 +340,13 @@ public class PortMappingVersion121 { = new ArrayList<>(); LOG.info("Getting Circuitpacks for Srg Number {}", srgCounter); InstanceIdentifier srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) - .child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter)); + .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(srgCounter))); Optional ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, srgIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); if (ordmSrgObject.isPresent()) { - srgCps.addAll(ordmSrgObject.get().getCircuitPacks()); - cpPerSrg.put(ordmSrgObject.get().getSrgNumber(), srgCps); + srgCps.addAll(ordmSrgObject.get().nonnullCircuitPacks().values()); + cpPerSrg.put(ordmSrgObject.get().getSrgNumber().toJava(), srgCps); } } LOG.info("Device {} has {} Srg", deviceId, cpPerSrg.size()); @@ -349,9 +360,9 @@ public class PortMappingVersion121 { HashMap> srgCps = getSrgCps(nodeId, deviceInfo); - for (Integer k : srgCps.keySet()) { + for (Entry> srgCpEntry : srgCps.entrySet()) { List cpList = - srgCps.get(k); + srgCps.get(srgCpEntry.getKey()); List keys = new ArrayList<>(); for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks cp : cpList) { String circuitPackName = cp.getCircuitPackName(); @@ -365,8 +376,9 @@ public class PortMappingVersion121 { LOG.warn("{} : Circuit pack {} not found or without ports.", nodeId, circuitPackName); continue; } + // com.google.common.collect.ImmutableList implementation of List @Nullable - List portList = circuitPackObject.get().getPorts(); + List portList = new ArrayList<>(circuitPackObject.get().nonnullPorts().values()); Collections.sort(portList, new SortPort121ByName()); int portIndex = 1; for (Ports port : portList) { @@ -376,7 +388,7 @@ public class PortMappingVersion121 { } else if (Port.PortQual.RoadmExternal.getIntValue() == port.getPortQual().getIntValue() && Direction.Bidirectional.getIntValue() == port.getPortDirection().getIntValue() && !keys.contains(currentKey)) { - String logicalConnectionPoint = createLogicalConnectionPort(port, k, portIndex); + String logicalConnectionPoint = createLogicalConnectionPort(port, srgCpEntry.getKey(), portIndex); LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName, port.getPortName(), logicalConnectionPoint); portMapList.add(createMappingObject(nodeId, port, circuitPackName, logicalConnectionPoint)); @@ -387,7 +399,8 @@ public class PortMappingVersion121 { || Direction.Tx.getIntValue() == port.getPortDirection().getIntValue()) && !keys.contains(currentKey) && port.getPartnerPort() != null) { - String logicalConnectionPoint1 = createLogicalConnectionPort(port, k, portIndex); + String logicalConnectionPoint1 = createLogicalConnectionPort(port, srgCpEntry.getKey(), + portIndex); LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName, port.getPortName(), logicalConnectionPoint1); InstanceIdentifier port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class) @@ -411,7 +424,8 @@ public class PortMappingVersion121 { && port2.getPartnerPort() != null && port2.getPartnerPort().getCircuitPackName().equals(circuitPackName) && port2.getPartnerPort().getPortName().toString().equals(port.getPortName()))) { - String logicalConnectionPoint2 = createLogicalConnectionPort(port2, k, portIndex); + String logicalConnectionPoint2 = createLogicalConnectionPort(port2, srgCpEntry.getKey(), + portIndex); LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName, port2.getPortName(), logicalConnectionPoint2); portMapList.add(createMappingObject(nodeId, port, circuitPackName, @@ -467,7 +481,7 @@ public class PortMappingVersion121 { // Get value for max degree from info subtree, required for iteration // if not present assume to be 20 (temporary) if (ordmInfo.getMaxDegrees() != null) { - maxDegree = ordmInfo.getMaxDegrees(); + maxDegree = ordmInfo.getMaxDegrees().toJava(); } else { maxDegree = 20; } @@ -475,7 +489,7 @@ public class PortMappingVersion121 { for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) { LOG.info("Getting Connection ports for Degree Number {}", degreeCounter); InstanceIdentifier deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) - .child(Degree.class, new DegreeKey(degreeCounter)); + .child(Degree.class, new DegreeKey(Uint16.valueOf(degreeCounter))); Optional ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, deviceIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); @@ -483,7 +497,7 @@ public class PortMappingVersion121 { degrees.add(ordmDegreeObject.get()); } } - LOG.info("Device {} has {} degree", degrees.size()); + LOG.info("Device {} has {} degree", deviceId, degrees.size()); return degrees; } @@ -492,19 +506,20 @@ public class PortMappingVersion121 { Integer maxDegree; if (ordmInfo.getMaxDegrees() != null) { - maxDegree = ordmInfo.getMaxDegrees(); + maxDegree = ordmInfo.getMaxDegrees().toJava(); } else { maxDegree = 20; } for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) { LOG.info("Getting Connection ports for Degree Number {}", degreeCounter); InstanceIdentifier deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) - .child(Degree.class, new DegreeKey(degreeCounter)); + .child(Degree.class, new DegreeKey(Uint16.valueOf(degreeCounter))); Optional ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, deviceIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); if (ordmDegreeObject.isPresent()) { - conPortMap.put(degreeCounter, ordmDegreeObject.get().getConnectionPorts()); + conPortMap.put(degreeCounter, new ArrayList<>(ordmDegreeObject.get() + .nonnullConnectionPorts().values())); } } LOG.info("Device {} has {} degree", deviceId, conPortMap.size()); @@ -521,7 +536,7 @@ public class PortMappingVersion121 { Timeouts.DEVICE_READ_TIMEOUT_UNIT); if (protocolObject.isPresent() && protocolObject.get().augmentation(Protocols1.class).getLldp() != null) { Lldp lldp = protocolObject.get().augmentation(Protocols1.class).getLldp(); - for (PortConfig portConfig : lldp.getPortConfig()) { + for (PortConfig portConfig : lldp.nonnullPortConfig().values()) { if (portConfig.getAdminStatus().equals(PortConfig.AdminStatus.Txandrx)) { InstanceIdentifier interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) .child(Interface.class, new InterfaceKey(portConfig.getIfName())); @@ -557,7 +572,7 @@ public class PortMappingVersion121 { for (Degree degree : degrees) { if (degree.getCircuitPacks() != null) { LOG.info("Inside CP to degree list"); - cpToDegreeList.addAll(degree.getCircuitPacks().stream() + cpToDegreeList.addAll(degree.nonnullCircuitPacks().values().stream() .map(cp -> createCpToDegreeObject(cp.getCircuitPackName(), degree.getDegreeNumber().toString(), nodeId, interfaceList)) .collect(Collectors.toList())); @@ -568,33 +583,42 @@ public class PortMappingVersion121 { private boolean postPortMapping(String nodeId, NodeInfo nodeInfo, List portMapList, List cp2DegreeList) { - NodesBuilder nodesBldr = new NodesBuilder(); - nodesBldr.withKey(new NodesKey(nodeId)).setNodeId(nodeId); + NodesBuilder nodesBldr = new NodesBuilder().withKey(new NodesKey(nodeId)).setNodeId(nodeId); if (nodeInfo != null) { nodesBldr.setNodeInfo(nodeInfo); } if (portMapList != null) { - nodesBldr.setMapping(portMapList); + Map mappingMap = new HashMap<>(); + for (Mapping mapping: portMapList) { + if (mapping != null) { + mappingMap.put(mapping.key(), mapping); + } + } + nodesBldr.setMapping(mappingMap); } if (cp2DegreeList != null) { - nodesBldr.setCpToDegree(cp2DegreeList); + Map cpToDegreeMap = new HashMap<>(); + for (CpToDegree cp2Degree: cp2DegreeList) { + if (cp2Degree != null) { + cpToDegreeMap.put(cp2Degree.key(), cp2Degree); + } + } + nodesBldr.setCpToDegree(cpToDegreeMap); } - List nodesList = new ArrayList<>(); - nodesList.add(nodesBldr.build()); + Map nodesList = new HashMap<>(); + Nodes nodes = nodesBldr.build(); + nodesList.put(nodes.key(),nodes); - NetworkBuilder nwBldr = new NetworkBuilder(); - nwBldr.setNodes(nodesList); + Network network = new NetworkBuilder().setNodes(nodesList).build(); final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); InstanceIdentifier nodesIID = InstanceIdentifier.builder(Network.class).build(); - Network network = nwBldr.build(); writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, nodesIID, network); FluentFuture commit = writeTransaction.commit(); try { commit.get(); return true; - } catch (InterruptedException | ExecutionException e) { LOG.warn("Failed to post {}", network, e); return false; @@ -608,15 +632,18 @@ public class PortMappingVersion121 { interfaceName = interfaceList.get(circuitPackName); } return new CpToDegreeBuilder().withKey(new CpToDegreeKey(circuitPackName)).setCircuitPackName(circuitPackName) - .setDegreeNumber(new Long(degreeNumber)).setInterfaceName(interfaceName).build(); + .setDegreeNumber(Uint32.valueOf(degreeNumber)).setInterfaceName(interfaceName).build(); } private Mapping createMappingObject(String nodeId, Ports port, String circuitPackName, - String logicalConnectionPoint) { - MappingBuilder mpBldr = new MappingBuilder(); - mpBldr.withKey(new MappingKey(logicalConnectionPoint)).setLogicalConnectionPoint(logicalConnectionPoint) - .setSupportingCircuitPackName(circuitPackName).setSupportingPort(port.getPortName()) - .setPortDirection(port.getPortDirection().getName()); + String logicalConnectionPoint) { + + MappingBuilder mpBldr = new MappingBuilder() + .withKey(new MappingKey(logicalConnectionPoint)) + .setLogicalConnectionPoint(logicalConnectionPoint) + .setSupportingCircuitPackName(circuitPackName) + .setSupportingPort(port.getPortName()) + .setPortDirection(port.getPortDirection().getName()); // Get OMS and OTS interface provisioned on the TTP's if (logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) && (port.getInterfaces() != null)) { @@ -647,32 +674,35 @@ public class PortMappingVersion121 { } private Mapping createXpdrMappingObject(String nodeId, Ports port, String circuitPackName, - String logicalConnectionPoint, String partnerLcp, Mapping mapping, String assoLcp) { - MappingBuilder mpBldr; + String logicalConnectionPoint, String partnerLcp, Mapping mapping, String assoLcp) { + if (mapping != null && assoLcp != null) { // update existing mapping - mpBldr = new MappingBuilder(mapping); - mpBldr.setAssociatedLcp(assoLcp); - } else { - // create a new mapping - mpBldr = new MappingBuilder(); - mpBldr.withKey(new MappingKey(logicalConnectionPoint)) + return new MappingBuilder(mapping).setConnectionMapLcp(assoLcp).build(); + } + + // create a new mapping + String nodeIdLcp = nodeId + "-" + logicalConnectionPoint; + MappingBuilder mpBldr = new MappingBuilder() + .withKey(new MappingKey(logicalConnectionPoint)) .setLogicalConnectionPoint(logicalConnectionPoint) .setSupportingCircuitPackName(circuitPackName) .setSupportingPort(port.getPortName()) - .setPortDirection(port.getPortDirection().getName()); - if (port.getPortQual() != null) { - mpBldr.setPortQual(port.getPortQual().getName()); - } - if (partnerLcp != null) { - mpBldr.setPartnerLcp(partnerLcp); - } + .setPortDirection(port.getPortDirection().getName()) + .setLcpHashVal(FnvUtils.fnv1_64(nodeIdLcp)); + if (port.getPortQual() != null) { + mpBldr.setPortQual(port.getPortQual().getName()); } + if (partnerLcp != null) { + mpBldr.setPartnerLcp(partnerLcp); + } + return mpBldr.build(); } // some LOG messages are too long @SuppressWarnings("checkstyle:linelength") + @SuppressFBWarnings("DM_CONVERT_CASE") private boolean createTtpPortMapping(String nodeId, Info deviceInfo, List portMapList) { // Creating mapping data for degree TTP's List degrees = getDegrees(nodeId, deviceInfo); @@ -682,17 +712,18 @@ public class PortMappingVersion121 { postPortMapping(nodeId, null, null, cpToDegreeList); Map> connectionPortMap = getPerDegreePorts(nodeId, deviceInfo); - for (Integer k : connectionPortMap.keySet()) { - switch (connectionPortMap.get(k).size()) { + for (Entry> cpMapEntry : connectionPortMap.entrySet()) { + switch (connectionPortMap.get(cpMapEntry.getKey()).size()) { case 1: // port is bidirectional InstanceIdentifier portID = InstanceIdentifier.create(OrgOpenroadmDevice.class) - .child(CircuitPacks.class, new CircuitPacksKey(connectionPortMap.get(k).get(0) + .child(CircuitPacks.class, new CircuitPacksKey(connectionPortMap.get(cpMapEntry.getKey()).get(0) .getCircuitPackName())) - .child(Ports.class, new PortsKey(connectionPortMap.get(k).get(0) + .child(Ports.class, new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0) .getPortName().toString())); - LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap.get(k).get(0) - .getPortName().toString(), connectionPortMap.get(k).get(0).getCircuitPackName()); + LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap + .get(cpMapEntry.getKey()).get(0).getPortName().toString(), connectionPortMap + .get(cpMapEntry.getKey()).get(0).getCircuitPackName()); Optional portObject = this.deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, portID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); @@ -702,42 +733,46 @@ public class PortMappingVersion121 { continue; } else if (Port.PortQual.RoadmExternal.getIntValue() == port.getPortQual().getIntValue() && Direction.Bidirectional.getIntValue() == port.getPortDirection().getIntValue()) { - String logicalConnectionPoint = new StringBuilder("DEG").append(k).append("-TTP-TXRX") - .toString(); + String logicalConnectionPoint = new StringBuilder("DEG").append(cpMapEntry.getKey()) + .append("-TTP-TXRX").toString(); LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, - connectionPortMap.get(k).get(0).getCircuitPackName(), port.getPortName(), - logicalConnectionPoint); + connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), + port.getPortName(), logicalConnectionPoint); portMapList.add(createMappingObject(nodeId, port, - connectionPortMap.get(k).get(0).getCircuitPackName(), logicalConnectionPoint)); + connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), + logicalConnectionPoint)); } else { LOG.error( "Impossible to create logical connection point for port {} of {} on node {} - Error in configuration with port-qual or port-direction", - port.getPortName(), connectionPortMap.get(k).get(0).getCircuitPackName(), nodeId); + port.getPortName(), connectionPortMap + .get(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId); } } else { LOG.error("No port {} on circuit pack {} for node {}", - connectionPortMap.get(k).get(0).getPortName().toString(), - connectionPortMap.get(k).get(0).getCircuitPackName(), nodeId); + connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString(), + connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId); return false; } break; case 2: // ports are unidirectionals - String cp1Name = connectionPortMap.get(k).get(0).getCircuitPackName(); - String cp2Name = connectionPortMap.get(k).get(1).getCircuitPackName(); + String cp1Name = connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(); + String cp2Name = connectionPortMap.get(cpMapEntry.getKey()).get(1).getCircuitPackName(); InstanceIdentifier port1ID = InstanceIdentifier.create(OrgOpenroadmDevice.class) .child(CircuitPacks.class, new CircuitPacksKey(cp1Name)) - .child(Ports.class, new PortsKey(connectionPortMap.get(k).get(0).getPortName().toString())); - LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap.get(k).get(0) - .getPortName().toString(), cp1Name); + .child(Ports.class, new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName() + .toString())); + LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap + .get(cpMapEntry.getKey()).get(0).getPortName().toString(), cp1Name); Optional port1Object = this.deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, port1ID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); InstanceIdentifier port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class) .child(CircuitPacks.class, new CircuitPacksKey(cp2Name)) - .child(Ports.class, new PortsKey(connectionPortMap.get(k).get(1).getPortName().toString())); + .child(Ports.class, new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName() + .toString())); LOG.info("Fetching connection-port {} at circuit pack {}", - connectionPortMap.get(k).get(1).getPortName().toString(), cp2Name); + connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName().toString(), cp2Name); Optional port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, port2ID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); @@ -752,7 +787,7 @@ public class PortMappingVersion121 { && Direction.Tx.getIntValue() == port2.getPortDirection().getIntValue() && port1.getPartnerPort() != null && port2.getPartnerPort() != null && port1.getPartnerPort().getCircuitPackName().equals(cp2Name) - && port1.getPartnerPort().getPortName().equals(port2.getPortName().toString()) + && port1.getPartnerPort().getPortName().equals(port2.getPortName()) && port2.getPartnerPort().getCircuitPackName().equals(cp1Name) && port2.getPartnerPort().getPortName().equals(port1.getPortName())) || @@ -762,23 +797,23 @@ public class PortMappingVersion121 { && Direction.Tx.getIntValue() == port1.getPortDirection().getIntValue() && port1.getPartnerPort() != null && port2.getPartnerPort() != null && port1.getPartnerPort().getCircuitPackName().equals(cp2Name) - && port1.getPartnerPort().getPortName().equals(port2.getPortName().toString()) + && port1.getPartnerPort().getPortName().equals(port2.getPortName()) && port2.getPartnerPort().getCircuitPackName().equals(cp1Name) - && port2.getPartnerPort().getPortName().equals(port1.getPortName().toString()))) { - String logicalConnectionPoint1 = new StringBuilder("DEG").append(k).append("-TTP-") - .append(port1.getPortDirection().getName().toUpperCase()).toString(); + && port2.getPartnerPort().getPortName().equals(port1.getPortName()))) { + String logicalConnectionPoint1 = new StringBuilder("DEG").append(cpMapEntry.getKey()) + .append("-TTP-").append(port1.getPortDirection().getName().toUpperCase()).toString(); LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, - connectionPortMap.get(k).get(0).getCircuitPackName(), port1.getPortName(), - logicalConnectionPoint1); - portMapList.add(createMappingObject(nodeId, port1, connectionPortMap.get(k).get(0) - .getCircuitPackName(), logicalConnectionPoint1)); - String logicalConnectionPoint2 = new StringBuilder("DEG").append(k).append("-TTP-") - .append(port2.getPortDirection().getName().toUpperCase()).toString(); + connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), + port1.getPortName(), logicalConnectionPoint1); + portMapList.add(createMappingObject(nodeId, port1, connectionPortMap + .get(cpMapEntry.getKey()).get(0).getCircuitPackName(), logicalConnectionPoint1)); + String logicalConnectionPoint2 = new StringBuilder("DEG").append(cpMapEntry.getKey()) + .append("-TTP-").append(port2.getPortDirection().getName().toUpperCase()).toString(); LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, - connectionPortMap.get(k).get(1).getCircuitPackName(), port2.getPortName(), - logicalConnectionPoint2); - portMapList.add(createMappingObject(nodeId, port2, connectionPortMap.get(k).get(1) - .getCircuitPackName(), logicalConnectionPoint2)); + connectionPortMap.get(cpMapEntry.getKey()).get(1).getCircuitPackName(), + port2.getPortName(), logicalConnectionPoint2); + portMapList.add(createMappingObject(nodeId, port2, connectionPortMap + .get(cpMapEntry.getKey()).get(1).getCircuitPackName(), logicalConnectionPoint2)); } else { LOG.error( "Impossible to create logical connection point for port {} or port {} on node {} - Error in configuration with port-qual, port-direction or partner-port configuration", @@ -786,14 +821,14 @@ public class PortMappingVersion121 { } } else { LOG.error("No port {} on circuit pack {} for node {}", - connectionPortMap.get(k).get(0).getPortName().toString(), - connectionPortMap.get(k).get(0).getCircuitPackName(), nodeId); + connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString(), + connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId); return false; } break; default: - LOG.error("Number of connection port for DEG{} on {} is incorrect", k, nodeId); + LOG.error("Number of connection port for DEG{} on {} is incorrect", cpMapEntry.getKey(), nodeId); continue; } } @@ -801,36 +836,40 @@ public class PortMappingVersion121 { } private NodeInfo createNodeInfo(Info deviceInfo) { - NodeInfoBuilder nodeInfoBldr = new NodeInfoBuilder(); - if (deviceInfo.getNodeType() != null) { - nodeInfoBldr = new NodeInfoBuilder() + + if (deviceInfo.getNodeType() == null) { + // TODO make mandatory in yang + LOG.error("Node type field is missing"); + return null; + } + + NodeInfoBuilder nodeInfoBldr = new NodeInfoBuilder() .setOpenroadmVersion(OpenroadmVersion._121); - if (deviceInfo.getNodeType().getIntValue() == 1) { - nodeInfoBldr.setNodeType(NodeTypes.Rdm); - } else if (deviceInfo.getNodeType().getIntValue() == 2) { - nodeInfoBldr.setNodeType(NodeTypes.Xpdr); - } else { + // TODO check if we can use here .setNodeType(NodeTypes.forValue(..) such as with 221 + switch (deviceInfo.getNodeType().getIntValue()) { + case 1: + case 2: + nodeInfoBldr.setNodeType(NodeTypes.forValue(deviceInfo.getNodeType().getIntValue())); + break; + default: LOG.error("Error with node-type of {}", deviceInfo.getNodeId()); - } - if (deviceInfo.getClli() != null && !deviceInfo.getClli().isEmpty()) { - nodeInfoBldr.setNodeClli(deviceInfo.getClli()); - } else { - nodeInfoBldr.setNodeClli("defaultCLLI"); - } - if (deviceInfo.getModel() != null) { - nodeInfoBldr.setNodeModel(deviceInfo.getModel()); - } - if (deviceInfo.getVendor() != null) { - nodeInfoBldr.setNodeVendor(deviceInfo.getVendor()); - } - if (deviceInfo.getIpAddress() != null) { - nodeInfoBldr.setNodeIpAddress(deviceInfo.getIpAddress()); - } + // TODO: is this protection useful ? it is not present in Portmapping 221 + } + if (deviceInfo.getClli() != null && !deviceInfo.getClli().isEmpty()) { + nodeInfoBldr.setNodeClli(deviceInfo.getClli()); } else { - // TODO make mandatory in yang - LOG.error("Node type field is missing"); - return null; + nodeInfoBldr.setNodeClli("defaultCLLI"); } + if (deviceInfo.getModel() != null) { + nodeInfoBldr.setNodeModel(deviceInfo.getModel()); + } + if (deviceInfo.getVendor() != null) { + nodeInfoBldr.setNodeVendor(deviceInfo.getVendor()); + } + if (deviceInfo.getIpAddress() != null) { + nodeInfoBldr.setNodeIpAddress(deviceInfo.getIpAddress()); + } + return nodeInfoBldr.build(); }