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.opendaylight.transportpce.portmapping.rev210426.mc.capabilities.McCapabilities;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mc.capabilities.McCapabilitiesBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mc.capabilities.McCapabilitiesKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mpdr.restrictions.grp.MpdrRestrictionsBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.Nodes;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.NodesBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.NodesKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.Info;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.McCapabilityProfile;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.McCapabilityProfileKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.MuxpProfile;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.MuxpProfileKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduSwitchingPools;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.Protocols;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
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.lldp.rev200529.Protocols1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.lldp.container.Lldp;
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.lldp.container.lldp.PortConfig;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.Ports1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.port.capability.grp.port.capabilities.SupportedInterfaceCapability;
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;
import org.slf4j.LoggerFactory;
+
// FIXME: many common pieces of code between PortMapping Versions 121 and 221 and 710
// some mutualization would be helpful
@SuppressWarnings("CPD-START")
}
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(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);
if (interfaceType.equals(OpticalTransport.class)) {
mpBldr.setSupportingOts(interfaces.getInterfaceName());
}
- if (interfaceType.equals(OtnOdu.class)) {
+ String interfaceName = interfaces.getInterfaceName();
+ if (interfaceType.equals(OtnOdu.class)
+ && (interfaceName.substring(interfaceName.lastIndexOf("-") + 1)
+ .equals("ODU"))) {
mpBldr.setSupportingOdu4(interfaces.getInterfaceName());
}
+ if ((interfaceType.equals(OtnOdu.class))
+ && (interfaceName.substring(interfaceName.lastIndexOf("-") + 1)
+ .equals("ODUC4"))) {
+ mpBldr.setSupportingOduc4(interfaces.getInterfaceName());
+ }
+
} catch (OpenRoadmInterfaceException ex) {
LOG.warn("{} : Error while getting interface {} - ",
nodeId, interfaces.getInterfaceName(), ex);
.SupportedIfCapability>> supportedIntf = new ArrayList<>();
Map<SupportedInterfaceCapabilityKey, SupportedInterfaceCapability> supIfCapMap = port
.augmentation(Ports1.class).getPortCapabilities().nonnullSupportedInterfaceCapability();
+ SupportedInterfaceCapability sic1 = null;
for (SupportedInterfaceCapability sic : supIfCapMap.values()) {
supportedIntf.add(sic.getIfCapType());
+ sic1 = sic;
+ }
+ if (port.getPortQual() == PortQual.SwitchClient
+ && !sic1.getOtnCapability().getMpdrClientRestriction().isEmpty()) {
+ List<MpdrClientRestriction> mpdrClientRestriction = sic1.getOtnCapability().getMpdrClientRestriction();
+ // Here we assume all the supported-interfaces has the support same rates, and the
+ // trib-slot numbers are assumed to be the same
+ String mxpProfileName = mpdrClientRestriction.get(0).getMuxpProfileName().get(0);
+ // From this muxponder-profile get the min-trib-slot and the max-trib-slot
+ LOG.info("{}: Muxp-profile used for trib information {}", nodeId, mxpProfileName);
+ // This provides the tribSlot information from muxProfile
+ List<OpucnTribSlotDef> minMaxOpucnTribSlots = getOpucnTribSlots(nodeId, mxpProfileName);
+ mpBldr.setMpdrRestrictions(
+ new MpdrRestrictionsBuilder()
+ .setMinTribSlot(minMaxOpucnTribSlots.get(0))
+ .setMaxTribSlot(minMaxOpucnTribSlots.get(1))
+ .build());
}
mpBldr.setSupportedInterfaceCapability(supportedIntf);
}
return mpBldr.build();
}
+ private ArrayList<OpucnTribSlotDef> getOpucnTribSlots(String deviceId, String mxpProfileName) {
+ ArrayList<OpucnTribSlotDef> minMaxOpucnTribSlots = new ArrayList<>(2);
+
+ LOG.info("{} : Getting Min/Max Trib-slots from {}", deviceId, mxpProfileName);
+ InstanceIdentifier<MuxpProfile> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(MuxpProfile.class, new MuxpProfileKey(mxpProfileName));
+
+ Optional<MuxpProfile> muxpProfileObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
+ LogicalDatastoreType.OPERATIONAL, deviceIID,
+ Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+
+ List<OpucnTribSlotDef> ntwHoOduOpucnTribSlots = muxpProfileObject.get().getNetworkHoOduOpucnTribSlots();
+ // Sort the tib-slots in ascending order and pick min and max
+ List<OpucnTribSlotDef> sortedNtwHoOduOpucnTribSlots = ntwHoOduOpucnTribSlots.stream().sorted(
+ Comparator.comparingDouble(x -> Double.parseDouble(
+ x.getValue().substring(x.getValue().lastIndexOf('.') + 1))))
+ .collect(Collectors.toList());
+ minMaxOpucnTribSlots.add(sortedNtwHoOduOpucnTribSlots.get(0));
+ minMaxOpucnTribSlots.add(sortedNtwHoOduOpucnTribSlots.get(sortedNtwHoOduOpucnTribSlots.size() - 1));
+ // LOG.info("Min, Max trib slot list {}", minMaxOpucnTribSlots);
+ return minMaxOpucnTribSlots;
+ }
+
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) {
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;
}
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;
+ }
}
Code Review / transportpce.git / blobdiff