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.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.Network;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.NetworkBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.Nodes;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.NodesBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.NodesKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.CpToDegree;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.CpToDegreeBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.CpToDegreeKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.Mapping;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.MappingBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.MappingKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.McCapabilities;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.McCapabilitiesBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.McCapabilitiesKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.NodeInfo;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.NodeInfo.OpenroadmVersion;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.NodeInfoBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.SwitchingPoolLcp;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.SwitchingPoolLcpBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.SwitchingPoolLcpKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.switching.pool.lcp.NonBlockingList;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.switching.pool.lcp.NonBlockingListBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.switching.pool.lcp.NonBlockingListKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.Network;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.NetworkBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.OpenroadmNodeVersion;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.cp.to.degree.CpToDegree;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.cp.to.degree.CpToDegreeBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.cp.to.degree.CpToDegreeKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.MappingBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.MappingKey;
+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.opendaylight.transportpce.portmapping.rev210426.network.nodes.NodeInfo;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.nodes.NodeInfoBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.switching.pool.lcp.SwitchingPoolLcp;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.switching.pool.lcp.SwitchingPoolLcpBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.switching.pool.lcp.SwitchingPoolLcpKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.switching.pool.lcp.switching.pool.lcp.NonBlockingList;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.switching.pool.lcp.switching.pool.lcp.NonBlockingListBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.switching.pool.lcp.switching.pool.lcp.NonBlockingListKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.alarm.pm.types.rev191129.Direction;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyGHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.CircuitPack;
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 updateMapping(String nodeId, Mapping oldMapping) {
- InstanceIdentifier<Ports> portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ InstanceIdentifier<Ports> portId = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName()))
.child(Ports.class, new PortsKey(oldMapping.getSupportingPort()));
if ((oldMapping == null) || (nodeId == null)) {
return false;
}
try {
- Optional<Ports> portObject = deviceTransactionManager.getDataFromDevice(nodeId,
- LogicalDatastoreType.OPERATIONAL, portIId, Timeouts.DEVICE_READ_TIMEOUT,
- Timeouts.DEVICE_READ_TIMEOUT_UNIT);
- if (!portObject.isPresent()) {
- return false;
- }
- Ports port = portObject.get();
- Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(),
- oldMapping.getLogicalConnectionPoint());
+ Ports port = deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL,
+ portId, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT).get();
+ Mapping newMapping = updateMappingObject(nodeId, port, oldMapping);
LOG.debug("{} : Updating old mapping Data {} for {} by new mapping data {}",
nodeId, oldMapping, oldMapping.getLogicalConnectionPoint(), newMapping);
final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
}
}
+ 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);
int client = 1;
Integer xponderNb = xponder.getXpdrNumber().toJava();
XpdrNodeTypes xponderType = xponder.getXpdrType();
- for (XpdrPort xpdrPort : xponder.nonnullXpdrPort().values()) {
+ 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();
// If there xponder-subtree has missing circuit-packs or ports,
.setSupportingCircuitPackName(circuitPackName)
.setSupportingPort(port.getPortName())
.setPortDirection(port.getPortDirection().getName());
+ if (port.getAdministrativeState() != null) {
+ mpBldr.setPortAdminState(port.getAdministrativeState().name());
+ }
+ if (port.getOperationalState() != null) {
+ mpBldr.setPortOperState(port.getOperationalState().name());
+ }
if ((port.getInterfaces() == null)
|| (!logicalConnectionPoint.contains(StringConstants.TTP_TOKEN)
&& !logicalConnectionPoint.contains(StringConstants.NETWORK_TOKEN))) {
return mpBldr.build();
}
- // Get OMS and OTS interface provisioned on the TTP's
+ mpBldr = updateMappingInterfaces(nodeId, mpBldr, port);
+ return mpBldr.build();
+ }
+
+ private Mapping updateMappingObject(String nodeId, Ports port, Mapping oldmapping) {
+ MappingBuilder mpBldr = new MappingBuilder(oldmapping);
+ updateMappingStates(mpBldr, port, oldmapping);
+ if ((port.getInterfaces() == null)
+ || (!oldmapping.getLogicalConnectionPoint().contains(StringConstants.TTP_TOKEN)
+ && !oldmapping.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN))) {
+ return mpBldr.build();
+ }
+ // Get interfaces provisioned on the port
+ mpBldr = updateMappingInterfaces(nodeId, mpBldr, port);
+ return mpBldr.build();
+ }
+
+ private MappingBuilder updateMappingStates(MappingBuilder mpBldr, Ports port, Mapping oldmapping) {
+ if (port.getAdministrativeState() != null
+ && !port.getAdministrativeState().getName().equals(oldmapping.getPortAdminState())) {
+ mpBldr.setPortAdminState(port.getAdministrativeState().name());
+ }
+ if (port.getOperationalState() != null
+ && !port.getOperationalState().getName().equals(oldmapping.getPortOperState())) {
+ mpBldr.setPortOperState(port.getOperationalState().name());
+ }
+ return mpBldr;
+ }
+
+ private MappingBuilder updateMappingInterfaces(String nodeId, MappingBuilder mpBldr, Ports port) {
for (Interfaces interfaces : port.getInterfaces()) {
try {
Optional<Interface> openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
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);
}
}
- return mpBldr.build();
+ return mpBldr;
}
- private Mapping createXpdrMappingObject(String nodeId, Ports ports, String circuitPackName,
+ private Mapping createXpdrMappingObject(String nodeId, Ports port, String circuitPackName,
String logicalConnectionPoint, String partnerLcp, Mapping mapping, String connectionMapLcp,
XpdrNodeTypes xpdrNodeType) {
.withKey(new MappingKey(logicalConnectionPoint))
.setLogicalConnectionPoint(logicalConnectionPoint)
.setSupportingCircuitPackName(circuitPackName)
- .setSupportingPort(ports.getPortName())
- .setPortDirection(ports.getPortDirection().getName())
+ .setSupportingPort(port.getPortName())
+ .setPortDirection(port.getPortDirection().getName())
.setLcpHashVal(FnvUtils.fnv1_64(nodeIdLcp));
- if (ports.getPortQual() != null) {
- mpBldr.setPortQual(ports.getPortQual().getName());
+ if (port.getPortQual() != null) {
+ mpBldr.setPortQual(port.getPortQual().getName());
}
if (xpdrNodeType != null) {
mpBldr.setXponderType(xpdrNodeType);
if (partnerLcp != null) {
mpBldr.setPartnerLcp(partnerLcp);
}
+ if (port.augmentation(Ports1.class) != null && port.augmentation(Ports1.class).getPortCapabilities() != null) {
+ List<Class<? extends org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327
+ .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);
+ }
+ if (port.getAdministrativeState() != null) {
+ mpBldr.setPortAdminState(port.getAdministrativeState().name());
+ }
+ if (port.getOperationalState() != null) {
+ mpBldr.setPortOperState(port.getOperationalState().name());
+ }
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;
}
}
NodeInfoBuilder nodeInfoBldr = new NodeInfoBuilder()
- .setOpenroadmVersion(OpenroadmVersion._710)
+ .setOpenroadmVersion(OpenroadmNodeVersion._71)
.setNodeType(deviceInfo.getNodeType());
// TODO: 221 versions expects an int value - need to check whether it is bug or an evolution here
if (deviceInfo.getClli() != null && !deviceInfo.getClli().isEmpty()) {
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;
+ }
}