import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.port.capability.grp.port.capabilities.SupportedInterfaceCapabilityKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.port.capability.grp.port.capabilities.supported._interface.capability.otn.capability.MpdrClientRestriction;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
}
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);
}
}
+ public boolean updatePortMappingWithOduSwitchingPools(String nodeId, InstanceIdentifier<OduSwitchingPools> ospIID,
+ Map<Uint16, List<InstanceIdentifier<PortList>>> nbliidMap) {
+
+ KeyedInstanceIdentifier<Nodes, NodesKey> portMappingNodeIID = InstanceIdentifier.create(Network.class)
+ .child(Nodes.class, new NodesKey(nodeId));
+ Nodes portmappingNode = null;
+ try (ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+ portmappingNode = readTx.read(LogicalDatastoreType.CONFIGURATION, portMappingNodeIID).get().get();
+ } catch (InterruptedException | ExecutionException ex) {
+ LOG.error("Unable to read the port-mapping for nodeId {}", nodeId, ex);
+ }
+ if (portmappingNode == null) {
+ return false;
+ }
+ Map<MappingKey, Mapping> mappings = portmappingNode.nonnullMapping();
+
+ 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<SwitchingPoolLcpKey, SwitchingPoolLcp>(portmappingNode.nonnullSwitchingPoolLcp());
+ SwitchingPoolLcpBuilder splBldr = splMap.containsKey(new SwitchingPoolLcpKey(ospNumber))
+ ? new SwitchingPoolLcpBuilder(splMap.get(new SwitchingPoolLcpKey(ospNumber)))
+ : new SwitchingPoolLcpBuilder().setSwitchingPoolNumber(ospNumber)
+ .setSwitchingPoolType(osp.getSwitchingPoolType());
+ Map<NonBlockingListKey, NonBlockingList> nblMap = new HashMap<>();
+ for (Entry<Uint16, List<InstanceIdentifier<PortList>>> entry : nbliidMap.entrySet()) {
+ Uint32 interconnectBw = osp.getNonBlockingList().get(new
+ org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org
+ .openroadm.device.odu.switching.pools.NonBlockingListKey(entry.getKey()))
+ .getInterconnectBandwidth();
+ NonBlockingList nbl = createNonBlockingList(splBldr, interconnectBw, entry, mappings, nodeId);
+ if (nbl == null) {
+ return false;
+ }
+ nblMap.put(nbl.key(), nbl);
+ }
+ SwitchingPoolLcp switchingPoolLcp = splBldr
+ .setNonBlockingList(nblMap)
+ .build();
+ splMap.put(switchingPoolLcp.key(), switchingPoolLcp);
+ List<SwitchingPoolLcp> switchingPoolList = new ArrayList<>(splMap.values());
+ postPortMapping(nodeId, null, null, null, switchingPoolList, null);
+ return true;
+ }
+
+ private NonBlockingList createNonBlockingList(SwitchingPoolLcpBuilder splBldr, Uint32 interconnectBw,
+ Entry<Uint16, List<InstanceIdentifier<PortList>>> entry, Map<MappingKey, Mapping> mappings, String nodeId) {
+ NonBlockingListBuilder nblBldr;
+ if (splBldr.getNonBlockingList() != null
+ && splBldr.getNonBlockingList().containsKey(new NonBlockingListKey(entry.getKey()))) {
+ nblBldr = new NonBlockingListBuilder(splBldr.getNonBlockingList()
+ .get(new NonBlockingListKey(entry.getKey())));
+ } else {
+ nblBldr = new NonBlockingListBuilder()
+ .setNblNumber(entry.getKey())
+ .setInterconnectBandwidth(interconnectBw);
+ }
+ List<String> lcpList = nblBldr.getLcpList() != null ? nblBldr.getLcpList() : new ArrayList<>();
+ 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 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;
+ }
+ }
+ nblBldr.setLcpList(lcpList);
+ return nblBldr.build();
+ }
+
private boolean createXpdrPortMapping(String nodeId, List<Mapping> portMapList) {
// Creating for Xponder Line and Client Ports
InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class);
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 nodeInfoBldr.build();
}
+ private String getLcpFromCpAndPort(Map<MappingKey, Mapping> mappings, String cpName, String portName) {
+ for (Mapping mapping : mappings.values()) {
+ if (cpName.equals(mapping.getSupportingCircuitPackName())
+ && portName.equals(mapping.getSupportingPort())) {
+ return mapping.getLogicalConnectionPoint();
+ }
+ }
+ return null;
+ }
+
}