// TODO PortDirection treatment here is similar to the one in createPpPortMapping.
// Some code alignment must be considered.
- if (port.getPartnerPort() == null
- || port.getPartnerPort().getCircuitPackName() == null
- || port.getPartnerPort().getPortName() == null) {
+ if (!checkPartnerPortNotNull(port)) {
LOG.warn("Error in the configuration of port {} of {} for {}",
port.getPortName(), circuitPackName, nodeId);
continue;
return true;
}
- private boolean checkPartnerPort(String circuitPackName, Ports port1, Ports port2) {
- if (port2.getPartnerPort() == null
- || port2.getPartnerPort().getCircuitPackName() == null
- || port2.getPartnerPort().getPortName() == null
+ private boolean checkPartnerPortNotNull(Ports port) {
+ if (port.getPartnerPort() == null
+ || port.getPartnerPort().getCircuitPackName() == null
+ || port.getPartnerPort().getPortName() == null) {
+ return false;
+ }
+ return true;
+ }
+
+ private boolean checkPartnerPortNoDir(String circuitPackName, Ports port1, Ports port2) {
+ if (!checkPartnerPortNotNull(port2)
|| !port2.getPartnerPort().getCircuitPackName().equals(circuitPackName)
- || !port2.getPartnerPort().getPortName().equals(port1.getPortName())
+ || !port2.getPartnerPort().getPortName().equals(port1.getPortName())) {
+ return false;
+ }
+ return true;
+ }
+
+ private boolean checkPartnerPort(String circuitPackName, Ports port1, Ports port2) {
+ if (!checkPartnerPortNoDir(circuitPackName, port1, port2)
|| ((Direction.Rx.getIntValue() != port1.getPortDirection().getIntValue()
|| Direction.Tx.getIntValue() != port2.getPortDirection().getIntValue())
&&
case Rx:
case Tx:
- if (port.getPartnerPort() == null) {
- LOG.info("{} : port {} on {} is unidirectional but has no partnerPort"
+ if (!checkPartnerPortNotNull(port)) {
+ LOG.info("{} : port {} on {} is unidirectional but has no valid partnerPort"
+ " - cannot assign logicalConnectionPoint.",
nodeId, port.getPortName(), circuitPackName);
continue;
return lcp;
}
- private List<Degree> getDegrees(String deviceId, Info ordmInfo) {
- List<Degree> degrees = new ArrayList<>();
+ private Map<Integer, Degree> getDegreesMap(String deviceId, Info ordmInfo) {
+ Map<Integer, Degree> degrees = new HashMap<>();
// Get value for max degree from info subtree, required for iteration
// if not present assume to be 20 (temporary)
LogicalDatastoreType.OPERATIONAL, deviceIID,
Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
if (ordmDegreeObject.isPresent()) {
- degrees.add(ordmDegreeObject.get());
+ degrees.put(degreeCounter, ordmDegreeObject.get());
}
}
LOG.info("Device {} has {} degree", deviceId, degrees.size());
private Map<Integer, List<ConnectionPorts>> getPerDegreePorts(String deviceId, Info ordmInfo) {
Map<Integer, List<ConnectionPorts>> conPortMap = new HashMap<>();
- Integer maxDegree = ordmInfo.getMaxDegrees() == null ? 20 : ordmInfo.getMaxDegrees().toJava();
-
- for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
- LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
- InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(Degree.class, new DegreeKey(Uint16.valueOf(degreeCounter)));
- Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
- LogicalDatastoreType.OPERATIONAL, deviceIID,
- Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
- if (ordmDegreeObject.isPresent()) {
- conPortMap.put(degreeCounter, new ArrayList<>(ordmDegreeObject.get()
- .nonnullConnectionPorts().values()));
- }
- }
- LOG.info("Device {} has {} degree", deviceId, conPortMap.size());
+ getDegreesMap(deviceId, ordmInfo).forEach(
+ (index, degree) -> conPortMap.put(index, new ArrayList<>(degree.nonnullConnectionPorts().values())));
return conPortMap;
}
return cpToInterfaceMap;
}
- private List<CpToDegree> getCpToDegreeList(List<Degree> degrees, String nodeId,
- Map<String, String> interfaceList) {
+ private List<CpToDegree> getCpToDegreeList(Map<Integer, Degree> degrees, Map<String, String> interfaceList) {
List<CpToDegree> cpToDegreeList = new ArrayList<>();
- for (Degree degree : degrees) {
- if (degree.getCircuitPacks() == null) {
- continue;
- }
+ for (Degree degree : degrees.values()) {
LOG.info("Inside CP to degree list");
cpToDegreeList.addAll(degree.nonnullCircuitPacks().values().stream()
.map(cp -> createCpToDegreeObject(cp.getCircuitPackName(),
- degree.getDegreeNumber().toString(), nodeId, interfaceList))
+ degree.getDegreeNumber().toString(), interfaceList))
.collect(Collectors.toList()));
}
return cpToDegreeList;
}
if (portMapList != null) {
Map<MappingKey, Mapping> mappingMap = new HashMap<>();
+ // No element in the list below should be null at this stage
for (Mapping mapping: portMapList) {
- if (mapping == null) {
- continue;
- }
mappingMap.put(mapping.key(), mapping);
}
nodesBldr.setMapping(mappingMap);
}
if (cp2DegreeList != null) {
Map<CpToDegreeKey, CpToDegree> cpToDegreeMap = new HashMap<>();
+ // No element in the list below should be null at this stage
for (CpToDegree cp2Degree: cp2DegreeList) {
- if (cp2Degree == null) {
- continue;
- }
cpToDegreeMap.put(cp2Degree.key(), cp2Degree);
}
nodesBldr.setCpToDegree(cpToDegreeMap);
}
}
- private CpToDegree createCpToDegreeObject(String circuitPackName, String degreeNumber, String nodeId,
+ private CpToDegree createCpToDegreeObject(String circuitPackName, String degreeNumber,
Map<String, String> interfaceList) {
return new CpToDegreeBuilder()
.withKey(new CpToDegreeKey(circuitPackName))
private boolean createTtpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
// Creating mapping data for degree TTP's
- List<Degree> degrees = getDegrees(nodeId, deviceInfo);
+ Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
Map<String, String> interfaceList = getEthInterfaceList(nodeId);
- List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, nodeId, interfaceList);
+ List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, interfaceList);
LOG.info("Map looks like this {}", interfaceList);
postPortMapping(nodeId, null, null, cpToDegreeList);
continue;
}
if (Port.PortQual.RoadmExternal.getIntValue() != port1.getPortQual().getIntValue()
- || Port.PortQual.RoadmExternal.getIntValue() != port2.getPortQual().getIntValue()
- || port1.getPartnerPort() == null
- || port2.getPartnerPort() == null
- || !port1.getPartnerPort().getCircuitPackName().equals(cp2Name)
- || !port1.getPartnerPort().getPortName().equals(port2.getPortName())
- || !port2.getPartnerPort().getCircuitPackName().equals(cp1Name)
- || !port2.getPartnerPort().getPortName().equals(port1.getPortName())
- || ((Direction.Rx.getIntValue() != port1.getPortDirection().getIntValue()
- || Direction.Tx.getIntValue() != port2.getPortDirection().getIntValue())
- && (Direction.Rx.getIntValue() != port2.getPortDirection().getIntValue()
- || Direction.Tx.getIntValue() != port1.getPortDirection().getIntValue()))) {
- 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",
+ || Port.PortQual.RoadmExternal.getIntValue() != port2.getPortQual().getIntValue()) {
+ LOG.error("Impossible to create logical connection point for port {} or port {} on node {}"
+ + " - Error in configuration with port-qual",
port1.getPortName(), port2.getPortName(), nodeId);
continue;
}
+ if (!checkPartnerPort(cp1Name, port1, port2)) {
+ LOG.error("port {} on {} is not a correct partner port of {} on {}",
+ port2.getPortName(), cp2Name, port1.getPortName(), cp1Name);
+ continue;
+ }
+ // Directions checks are the same for cp1 and cp2, no need to check them twice.
+ if (!checkPartnerPortNoDir(cp2Name, port2, port1)) {
+ LOG.error("port {} on {} is not a correct partner port of {} on {}",
+ port1.getPortName(), cp1Name, port2.getPortName(), cp2Name);
+ continue;
+ }
String logicalConnectionPoint1 = new StringBuilder("DEG")
.append(cpMapEntry.getKey())