import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.port.Interfaces;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.xponder.XpdrPort;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.PortQual;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.XpdrNodeTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.InterfaceType;
}
public boolean createMappingData(String nodeId) {
- LOG.info("{} : OpenROADM version 7.1.0 node - Creating Mapping Data", nodeId);
+ LOG.info("{} : OpenROADM version 7.1 node - Creating Mapping Data", nodeId);
List<Mapping> portMapList = new ArrayList<>();
Map<McCapabilitiesKey, McCapabilities> mcCapabilities = new HashMap<>();
InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
LOG.warn("{} : Unable to create mapping for the Xponder", nodeId);
return false;
}
+ // In the case of 7.1 models, even XPDR advertizes mc-capabilities,
+ // hence we need to populate this information into the port-mapping data
+ // Get MC capabilities
+ if (!createMcCapabilitiesList(nodeId, deviceInfo, mcCapabilities)) {
+ // return false if MC capabilites failed
+ LOG.warn("{} : Unable to create MC capabilities", nodeId);
+ return false;
+ }
break;
default:
LOG.error("{} : unknown nodetype - Unable to create mapping", nodeId);
OduSwitchingPools osp = deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL,
ospIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT).get();
Uint16 ospNumber = osp.getSwitchingPoolNumber();
- Map<SwitchingPoolLcpKey, SwitchingPoolLcp> splMap = new HashMap(portmappingNode.nonnullSwitchingPoolLcp());
+ Map<SwitchingPoolLcpKey, SwitchingPoolLcp> splMap =
+ new HashMap<SwitchingPoolLcpKey, SwitchingPoolLcp>(portmappingNode.nonnullSwitchingPoolLcp());
SwitchingPoolLcpBuilder splBldr = splMap.containsKey(new SwitchingPoolLcpKey(ospNumber))
? new SwitchingPoolLcpBuilder(splMap.get(new SwitchingPoolLcpKey(ospNumber)))
: new SwitchingPoolLcpBuilder().setSwitchingPoolNumber(ospNumber)
for (InstanceIdentifier<PortList> id : entry.getValue()) {
PortList portList = deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL,
id, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT).get();
- String lcp = getLcpFromCpAndPort(mappings, portList.getCircuitPackName(), portList.getPortName());
- if (lcp == null || lcpList.contains(lcp)) {
+ String circuitPackName = portList.getCircuitPackName();
+ String portName = portList.getPortName();
+ String lcp = getLcpFromCpAndPort(mappings, circuitPackName, portName);
+ if (lcp != null && !lcpList.contains(lcp)) {
+ lcpList.add(lcp);
+ } else {
return null;
}
- lcpList.add(lcp);
}
- return nblBldr.setLcpList(lcpList).build();
+ nblBldr.setLcpList(lcpList);
+ return nblBldr.build();
}
private boolean createXpdrPortMapping(String nodeId, List<Mapping> portMapList) {
for (XpdrPort xpdrPort : xponder.nonnullXpdrPort().values().stream()
.sorted((xp1, xp2) -> xp1.getIndex().compareTo(xp2.getIndex())).collect(Collectors.toList())) {
String circuitPackName = xpdrPort.getCircuitPackName();
- String portName = xpdrPort.getPortName().toString();
+ String portName = xpdrPort.getPortName();
// If there xponder-subtree has missing circuit-packs or ports,
// This gives a null-pointer expection,
if (device.nonnullCircuitPacks().values().stream()
InstanceIdentifier<Ports> port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(CircuitPacks.class,
new CircuitPacksKey(port.getPartnerPort().getCircuitPackName()))
- .child(Ports.class, new PortsKey(port.getPartnerPort().getPortName().toString()));
+ .child(Ports.class, new PortsKey(port.getPartnerPort().getPortName()));
Optional<Ports> port2Object = this.deviceTransactionManager
.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, port2ID,
Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
|| port2Object.get().getPortQual().getIntValue()
!= PortQual.RoadmExternal.getIntValue()) {
LOG.error("{} : port {} on {} - error getting partner",
- nodeId, port.getPartnerPort().getPortName().toString(),
+ nodeId, port.getPartnerPort().getPortName(),
port.getPartnerPort().getCircuitPackName());
continue;
}
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) {
Map<McCapabilityProfileKey, McCapabilityProfile> mcCapabilityProfiles = new HashMap<>();
InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class);
LOG.warn("{} : No MC profiles are found on degree {} - "
+ "assuming the fixed grid capabilities and a default profile-name",
nodeId, degree.getDegreeNumber());
- String mcNodeName = "DEG" + degree.getDegreeNumber().toString() + "-TTP-" + "default-profile";
+ String mcNodeName =
+ PortMappingUtils.degreeTtpNodeName(degree.getDegreeNumber().toString(), "default-profile");
McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder()
.withKey(new McCapabilitiesKey(mcNodeName))
.setMcNodeName(mcNodeName);
for (String mcCapabilityProfileName : degree.getMcCapabilityProfileName()) {
McCapabilityProfileKey mcKey = new McCapabilityProfileKey(mcCapabilityProfileName);
McCapabilityProfile mcCapabilityProfile = mcCapabilityProfileMap.get(mcKey);
- String mcNodeName = "DEG" + degree.getDegreeNumber().toString() + "-TTP-" + mcCapabilityProfile;
+ String mcNodeName = PortMappingUtils.degreeTtpNodeName(degree.getDegreeNumber().toString(),
+ mcCapabilityProfile.toString());
McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder()
.withKey(new McCapabilitiesKey(mcNodeName))
.setMcNodeName(mcNodeName);
.setSupportingCircuitPackName(circuitPackName)
.setSupportingPort(port.getPortName())
.setPortDirection(port.getPortDirection().getName())
- .setLcpHashVal(FnvUtils.fnv1_64(nodeIdLcp));
+ .setLcpHashVal(PortMappingUtils.fnv1size64(nodeIdLcp));
if (port.getPortQual() != null) {
mpBldr.setPortQual(port.getPortQual().getName());
}
return null;
}
Optional<Ports> poOpt = cpOpt.get().nonnullPorts().values().stream()
- .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString()))
+ .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName()))
.findFirst();
if (!poOpt.isPresent()) {
LOG.error("{} : Error fetching port {} on {}",
Integer xponderNb, XpdrNodeTypes xponderType,
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);
+ String lcp1 =
+ PortMappingUtils.createXpdrLogicalConnectionPort(xponderNb, line, StringConstants.NETWORK_TOKEN);
+ String lcp2 =
+ PortMappingUtils.createXpdrLogicalConnectionPort(xponderNb, line + 1, StringConstants.NETWORK_TOKEN);
if (lcpMap.containsKey(lcp1) || lcpMap.containsKey(lcp2)) {
LOG.warn("{} : mapping already exists for {} or {}", nodeId, lcp1, lcp2);
return;
case XpdrClient:
case SwitchClient:
- String lcp0 = createXpdrLogicalConnectionPort(xponderNb, client, StringConstants.CLIENT_TOKEN);
+ String lcp0 =
+ PortMappingUtils.createXpdrLogicalConnectionPort(xponderNb, client, StringConstants.CLIENT_TOKEN);
lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp0);
mappingMap.put(lcp0,
createXpdrMappingObject(nodeId, port, circuitPackName, lcp0, null, null, null, null));
switch (port.getPortDirection()) {
case Bidirectional:
- String lcp = createXpdrLogicalConnectionPort(xponderNb, line, StringConstants.NETWORK_TOKEN);
+ String lcp =
+ PortMappingUtils.createXpdrLogicalConnectionPort(xponderNb, line, StringConstants.NETWORK_TOKEN);
lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
mappingMap.put(lcp,
createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null, null, xponderType));
private boolean createMcCapabilitiesList(String nodeId, Info deviceInfo,
Map<McCapabilitiesKey, McCapabilities> mcCapabilitiesMap) {
- Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
- List<SharedRiskGroup> srgs = getSrgs(nodeId, deviceInfo);
- mcCapabilitiesMap.putAll(getMcCapabilities(degrees, srgs, deviceInfo, nodeId));
+ if (deviceInfo.getNodeType() == NodeTypes.Rdm) {
+ Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
+ List<SharedRiskGroup> srgs = getSrgs(nodeId, deviceInfo);
+ mcCapabilitiesMap.putAll(getMcCapabilities(degrees, srgs, deviceInfo, nodeId));
+ } else if ((deviceInfo.getNodeType() == NodeTypes.Xpdr)) {
+ Map<McCapabilityProfileKey, McCapabilityProfile> mcProfileXpdr = getMcCapabilityProfiles(nodeId,
+ deviceInfo);
+ if (mcProfileXpdr.size() > 1) {
+ LOG.warn("Re-check the mc-capability-profiles for XPDR port-mapping");
+ }
+ // Typically for a XPDR there will be only one mc-capability-profile
+ for (Map.Entry<McCapabilityProfileKey, McCapabilityProfile> mcCapProfile : mcProfileXpdr.entrySet()) {
+ String mcNodeName = "XPDR" + "-" + "mcprofile";
+ McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder()
+ .withKey(new McCapabilitiesKey(mcNodeName))
+ .setMcNodeName(mcNodeName);
+ mcCapabilitiesBuilder
+ .setCenterFreqGranularity(mcCapProfile.getValue().getCenterFreqGranularity())
+ .setSlotWidthGranularity(mcCapProfile.getValue().getSlotWidthGranularity());
+ // Build and add to the Map
+ mcCapabilitiesMap.put(mcCapabilitiesBuilder.key(), mcCapabilitiesBuilder.build());
+ LOG.info("Finished building mc-capability profile for XPDR {}", nodeId);
+ // Since we only have one mc-profile for XPDR, we can break the for-loop
+ break;
+ }
+
+ }
return true;
}
.child(CircuitPacks.class,
new CircuitPacksKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName()))
.child(Ports.class,
- new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString()));
+ new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName()));
LOG.debug("{} : Fetching connection-port {} at circuit pack {}",
nodeId,
connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName(),
connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName());
continue;
}
- String logicalConnectionPoint = new StringBuilder("DEG")
- .append(cpMapEntry.getKey())
- .append("-TTP-TXRX")
- .toString();
+ String logicalConnectionPoint =
+ PortMappingUtils.degreeTtpNodeName(cpMapEntry.getKey().toString(), "TXRX");
LOG.info("{} : Logical Connection Point for {} on {} is {}",
nodeId,
port.getPortName(), connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
InstanceIdentifier<Ports> port1ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(CircuitPacks.class, new CircuitPacksKey(cp1Name))
.child(Ports.class,
- new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString()));
+ new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName()));
LOG.debug("{} : Fetching connection-port {} at circuit pack {}",
nodeId, connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName(), cp1Name);
Optional<Ports> port1Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
InstanceIdentifier<Ports> port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(CircuitPacks.class, new CircuitPacksKey(cp2Name))
.child(Ports.class,
- new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName().toString()));
+ new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName()));
LOG.debug("{} : Fetching connection-port {} at circuit pack {}",
nodeId, connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName(), cp2Name);
Optional<Ports> port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
continue;
}
- String logicalConnectionPoint1 = new StringBuilder("DEG")
- .append(cpMapEntry.getKey())
- .append("-TTP-")
- .append(port1.getPortDirection().getName().toUpperCase(Locale.getDefault()))
- .toString();
+ String logicalConnectionPoint1 = PortMappingUtils.degreeTtpNodeName(cpMapEntry.getKey().toString(),
+ port1.getPortDirection().getName().toUpperCase(Locale.getDefault()));
LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
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(Locale.getDefault()))
- .toString();
+ String logicalConnectionPoint2 = PortMappingUtils.degreeTtpNodeName(cpMapEntry.getKey().toString(),
+ port2.getPortDirection().getName().toUpperCase(Locale.getDefault()));
LOG.info("{} : Logical Connection Point for {} {} is {}",
nodeId,
connectionPortMap.get(cpMapEntry.getKey()).get(1).getCircuitPackName(),
}
return null;
}
+
}