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;
// 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;
}
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 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);
port2.getPortName(), cp2Name, port1.getPortName(), cp1Name);
continue;
}
- // TODO this second checkPartnerPort call has overlap checkings with the first one (Directions)
- if (!checkPartnerPort(cp2Name, port2, port1)) {
+ // 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;
Code Review / transportpce.git / blobdiff