// some mutualization would be helpful
public class PortMappingVersion710 {
private static final Logger LOG = LoggerFactory.getLogger(PortMappingVersion710.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 PortMappingVersion710(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, 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, 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) {
+ if (!checkPartnerPortNotNull(port)) {
LOG.warn("Error in the configuration of port {} of {} for {}",
port.getPortName(), circuitPackName, nodeId);
continue;
circuitPackName);
continue;
}
- String lcp1 = "XPDR1-" + StringConstants.NETWORK_TOKEN + line;
- String lcp2 = new StringBuilder("XPDR1-")
- .append(StringConstants.NETWORK_TOKEN)
- .append(line + 1)
- .toString();
+ String lcp1 = createXpdrLogicalConnectionPort(1, line, StringConstants.NETWORK_TOKEN);
+ String lcp2 = createXpdrLogicalConnectionPort(1, line + 1, StringConstants.NETWORK_TOKEN);
if (lcpMap.containsKey(lcp1) || lcpMap.containsKey(lcp2)) {
LOG.warn("mapping already exists for {} or {}", lcp1, lcp2);
line += 2;
case XpdrClient:
case SwitchClient:
- String lcp0 = "XPDR" + xponderNb + "-" + StringConstants.CLIENT_TOKEN + client;
+ String lcp0 =
+ createXpdrLogicalConnectionPort(xponderNb , client, StringConstants.CLIENT_TOKEN);
lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp0);
mappingMap.put(lcp0,
createXpdrMappingObject(nodeId, port, circuitPackName, lcp0, null, null, null, null));
case XpdrNetwork:
case SwitchNetwork:
if (port.getPortDirection().getIntValue() == Direction.Bidirectional.getIntValue()) {
- String lcp = "XPDR" + xponderNb + "-" + StringConstants.NETWORK_TOKEN + line;
+ String lcp =
+ createXpdrLogicalConnectionPort(xponderNb , 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) {
+ if (!checkPartnerPortNotNull(port)) {
LOG.warn("Error in the configuration of port {} of {} for {}",
port.getPortName(), circuitPackName, nodeId);
continue;
circuitPackName);
continue;
}
- String lcp1 = "XPDR" + xponderNb + "-" + StringConstants.NETWORK_TOKEN + line;
- String lcp2 = new StringBuilder("XPDR")
- .append(xponderNb)
- .append("-")
- .append(StringConstants.NETWORK_TOKEN)
- .append(line + 1)
- .toString();
+ 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);
line += 2;
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 String createXpdrLogicalConnectionPort(int xponderNb, int lcpNb, String token) {
+ return new StringBuilder("XPDR").append(xponderNb)
+ .append("-")
+ .append(token).append(lcpNb)
+ .toString();
}
private Map<McCapabilityProfileKey, McCapabilityProfile> getMcCapabilityProfiles(String deviceId, Info ordmInfo) {
return mcCapabilityProfiles;
}
- 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());
return degrees;
}
+ private Map<Integer, List<ConnectionPorts>> getPerDegreePorts(String deviceId, Info ordmInfo) {
+ Map<Integer, List<ConnectionPorts>> conPortMap = new HashMap<>();
+ getDegreesMap(deviceId, ordmInfo).forEach(
+ (index, degree) -> conPortMap.put(index, new ArrayList<>(degree.nonnullConnectionPorts().values())));
+ return conPortMap;
+ }
+
private List<SharedRiskGroup> getSrgs(String deviceId, Info ordmInfo) {
List<SharedRiskGroup> srgs = new ArrayList<>();
return srgs;
}
- 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());
- return conPortMap;
- }
-
private Map<String, String> getEthInterfaceList(String nodeId) {
LOG.info("It is calling get ethernet interface");
InstanceIdentifier<Protocols> protocoliid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
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;
}
- private List<McCapabilities> getMcCapabilitiesList(List<Degree> degrees, List<SharedRiskGroup> srgs,
+ private List<McCapabilities> getMcCapabilitiesList(Map<Integer, Degree> degrees, List<SharedRiskGroup> srgs,
Info deviceInfo, String nodeId) {
//TODO some divergences with 2.2.1 here
LOG.info("Getting the MC capabilities for degrees of node {}", nodeId);
}
}
- 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))
.setInterfaceName(interfaceList.get(circuitPackName)).build();
}
- private List<McCapabilities> createMcCapDegreeObject(List<Degree> degrees,
+ private List<McCapabilities> createMcCapDegreeObject(Map<Integer, Degree> degrees,
Map<McCapabilityProfileKey, McCapabilityProfile> mcCapabilityProfileMap, String nodeId) {
//TODO some divergences here with 2.2.1
List<McCapabilities> mcCapabilitiesList = new ArrayList<>();
- for (Degree degree : degrees) {
+ for (Degree degree : degrees.values()) {
if ((degree.getMcCapabilityProfileName() == null) || (degree.getMcCapabilityProfileName().isEmpty())) {
LOG.warn("No MC profiles are found for node {} on degree {}", nodeId, degree.getDegreeNumber());
}
private boolean createMcCapabilitiesList(String nodeId, Info deviceInfo, List<McCapabilities> mcCapabilitiesList) {
- List<Degree> degrees = getDegrees(nodeId, deviceInfo);
+ Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
List<SharedRiskGroup> srgs = getSrgs(nodeId, deviceInfo);
mcCapabilitiesList.addAll(getMcCapabilitiesList(degrees, srgs, deviceInfo, nodeId));
return true;
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, null, null);
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