public class PortMappingVersion121 {
private static final Logger LOG = LoggerFactory.getLogger(PortMappingVersion121.class);
+ private static final Map<Direction, String> SUFFIX;
private final DataBroker dataBroker;
private final DeviceTransactionManager deviceTransactionManager;
private final OpenRoadmInterfaces openRoadmInterfaces;
+ static {
+ SUFFIX = Map.of(
+ Direction.Tx, "TX",
+ Direction.Rx, "RX",
+ Direction.Bidirectional, "TXRX");
+ }
+
public PortMappingVersion121(DataBroker dataBroker, DeviceTransactionManager deviceTransactionManager,
OpenRoadmInterfaces openRoadmInterfaces) {
this.dataBroker = dataBroker;
switch (port.getPortQual()) {
case XpdrClient:
- String lcp0 = "XPDR1-" + StringConstants.CLIENT_TOKEN + client;
+ String lcp0 = createXpdrLogicalConnectionPort(1, client, StringConstants.CLIENT_TOKEN);
lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp0);
mappingMap.put(lcp0,
createXpdrMappingObject(nodeId, port, circuitPackName, lcp0, null, null, null));
case XpdrNetwork:
if (port.getPortDirection().getIntValue() == Direction.Bidirectional.getIntValue()) {
- String lcp = "XPDR1-" + StringConstants.NETWORK_TOKEN + line;
+ String lcp = createXpdrLogicalConnectionPort(1, line, StringConstants.NETWORK_TOKEN);
lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
mappingMap.put(lcp,
createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null, null));
line++;
continue;
}
- // 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) {
- LOG.warn("Error in the configuration of port {} of {} for {}",
- port.getPortName(), circuitPackName, nodeId);
- continue;
- }
-
- if (lcpMap.containsKey(circuitPackName + '+' + port.getPortName())) {
- continue;
- }
-
- Optional<CircuitPacks> cpOpt = circuitPackList.stream()
- .filter(cP -> cP.getCircuitPackName().equals(port.getPartnerPort().getCircuitPackName()))
- .findFirst();
- if (!cpOpt.isPresent()) {
- LOG.error("Error fetching circuit-pack {} for {}",
- port.getPartnerPort().getCircuitPackName(), nodeId);
- continue;
- }
-
- Optional<Ports> poOpt = cpOpt.get().nonnullPorts().values().stream()
- .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString()))
- .findFirst();
- if (!poOpt.isPresent()) {
- LOG.error("Error fetching port {} on {} for {}", port.getPartnerPort().getPortName(),
- port.getPartnerPort().getCircuitPackName(), nodeId);
+ StringBuilder circuitPackName2 = new StringBuilder();
+ Ports port2 = getPort2(port, nodeId, circuitPackName, circuitPackName2,
+ circuitPackList, lcpMap);
+ if (port2 == null) {
+ //key already present or an error occured and was logged
continue;
}
- Ports port2 = poOpt.get();
- if (!checkPartnerPort(circuitPackName, port, port2)) {
- LOG.error("port {} on {} is not a correct partner port of {} on {}",
- port2.getPortName(), cpOpt.get().getCircuitPackName(), port.getPortName(),
- circuitPackName);
- continue;
- }
- String lcp1 = "XPDR1-" + StringConstants.NETWORK_TOKEN + line;
- String lcp2 = new StringBuilder("XPDR1-")
- .append(StringConstants.NETWORK_TOKEN)
- .append(line + 1)
- .toString();
- if (lcpMap.containsKey(lcp1) || lcpMap.containsKey(lcp2)) {
- LOG.warn("mapping already exists for {} or {}", lcp1, lcp2);
- line += 2;
- continue;
- }
- lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp1);
- lcpMap.put(cpOpt.get().getCircuitPackName() + '+' + port2.getPortName(), lcp2);
- mappingMap.put(lcp1, createXpdrMappingObject(nodeId, port, circuitPackName, lcp1,
- lcp2, null, null));
- mappingMap.put(lcp2, createXpdrMappingObject(nodeId, port2,
- cpOpt.get().getCircuitPackName(), lcp2, lcp1, null, null));
+ putXpdrLcpsInMaps(line, nodeId, 1,
+ circuitPackName, circuitPackName2.toString(), port, port2,
+ lcpMap, mappingMap);
line += 2;
break;
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;
}
private String createLogicalConnectionPort(Ports port, int index, int portIndex) {
- String lcp = null;
- switch (port.getPortDirection()) {
- case Tx:
- lcp = "SRG" + index + "-PP" + portIndex + "-TX";
- break;
- case Rx:
- lcp = "SRG" + index + "-PP" + portIndex + "-RX";
- break;
- case Bidirectional:
- lcp = "SRG" + index + "-PP" + portIndex + "-TXRX";
- break;
- default:
- LOG.error("Unsupported port direction for port {} : {}", port, port.getPortDirection());
+ if (SUFFIX.containsKey(port.getPortDirection())) {
+ return String.join("-", "SRG" + index, "PP" + portIndex, SUFFIX.get(port.getPortDirection()));
}
- return lcp;
+ LOG.error("port {} : Unsupported port direction {}", port, port.getPortDirection());
+ return null;
}
- private List<Degree> getDegrees(String deviceId, Info ordmInfo) {
- List<Degree> degrees = new ArrayList<>();
+ private String createXpdrLogicalConnectionPort(int xponderNb, int lcpNb, String token) {
+ return new StringBuilder("XPDR").append(xponderNb)
+ .append("-")
+ .append(token).append(lcpNb)
+ .toString();
+ }
+
+ 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))
return mpBldr.build();
}
+ private Ports getPort2(Ports port, String nodeId, String circuitPackName, StringBuilder circuitPackName2,
+ //circuitPackName2 will be updated by reference contrary to circuitPackName
+ List<CircuitPacks> circuitPackList, Map<String, String> lcpMap) {
+ if (!checkPartnerPortNotNull(port)) {
+ LOG.warn("Error in the configuration of port {} of {} for {}",
+ port.getPortName(), circuitPackName, nodeId);
+ return null;
+ }
+ if (lcpMap.containsKey(circuitPackName + '+' + port.getPortName())) {
+ return null;
+ }
+ Optional<CircuitPacks> cpOpt = circuitPackList.stream()
+ .filter(cP -> cP.getCircuitPackName().equals(port.getPartnerPort().getCircuitPackName()))
+ .findFirst();
+ if (!cpOpt.isPresent()) {
+ LOG.error("Error fetching circuit-pack {} for {}",
+ port.getPartnerPort().getCircuitPackName(), nodeId);
+ return null;
+ }
+ Optional<Ports> poOpt = cpOpt.get().nonnullPorts().values().stream()
+ .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString()))
+ .findFirst();
+ if (!poOpt.isPresent()) {
+ LOG.error("Error fetching port {} on {} for {}", port.getPartnerPort().getPortName(),
+ port.getPartnerPort().getCircuitPackName(), nodeId);
+ return null;
+ }
+ Ports port2 = poOpt.get();
+ circuitPackName2.append(cpOpt.get().getCircuitPackName());
+ if (!checkPartnerPort(circuitPackName, port, port2)) {
+ LOG.error("port {} on {} is not a correct partner port of {} on {}",
+ port2.getPortName(), circuitPackName2, port.getPortName(),
+ circuitPackName);
+ return null;
+ }
+ return port2;
+ }
+
+ private void putXpdrLcpsInMaps(int line, String nodeId,
+ Integer xponderNb,
+ String circuitPackName, String circuitPackName2, Ports port, Ports port2,
+ Map<String, String> lcpMap, Map<String, Mapping> mappingMap) {
+ String lcp1 = createXpdrLogicalConnectionPort(xponderNb, line, StringConstants.NETWORK_TOKEN);
+ String lcp2 = createXpdrLogicalConnectionPort(xponderNb, line + 1, StringConstants.NETWORK_TOKEN);
+ if (lcpMap.containsKey(lcp1) || lcpMap.containsKey(lcp2)) {
+ LOG.warn("mapping already exists for {} or {}", lcp1, lcp2);
+ return;
+ }
+ lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp1);
+ lcpMap.put(circuitPackName2 + '+' + port2.getPortName(), lcp2);
+ mappingMap.put(lcp1,
+ createXpdrMappingObject(nodeId, port, circuitPackName, lcp1, lcp2, null, null));
+ mappingMap.put(lcp2,
+ createXpdrMappingObject(nodeId, port2, circuitPackName2, lcp2, lcp1, null, null));
+ return;
+ }
+
+
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())
Code Review / transportpce.git / blobdiff