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;
// Get TTP port mapping
if (!createTtpPortMapping(nodeId, deviceInfo, portMapList)) {
// return false if mapping creation for TTP's failed
- LOG.warn(PortMappingUtils.UNABLE_MAPPING_LOGMSG, nodeId, "create", "TTP's");
+ LOG.warn(PortMappingUtils.UNABLE_MAPPING_LOGMSG, nodeId, PortMappingUtils.CREATE, "TTP's");
return false;
}
// Get PP port mapping
if (!createPpPortMapping(nodeId, deviceInfo, portMapList)) {
// return false if mapping creation for PP's failed
- LOG.warn(PortMappingUtils.UNABLE_MAPPING_LOGMSG, nodeId, "create", "PP's");
+ LOG.warn(PortMappingUtils.UNABLE_MAPPING_LOGMSG, nodeId, PortMappingUtils.CREATE, "PP's");
return false;
}
// Get MC capabilities
break;
case Xpdr:
if (!createXpdrPortMapping(nodeId, portMapList)) {
- LOG.warn(PortMappingUtils.UNABLE_MAPPING_LOGMSG, nodeId, "create", "Xponder");
+ LOG.warn(PortMappingUtils.UNABLE_MAPPING_LOGMSG, nodeId, PortMappingUtils.CREATE, "Xponder");
return false;
}
// In the case of 7.1 models, even XPDR advertizes mc-capabilities,
break;
default:
LOG.error(PortMappingUtils.UNABLE_MAPPING_LOGMSG,
- nodeId, "create", deviceInfo.getNodeType() + " - unknown nodetype");
+ nodeId, PortMappingUtils.CREATE, deviceInfo.getNodeType() + " - unknown nodetype");
break;
}
public boolean updateMapping(String nodeId, Mapping oldMapping) {
if (nodeId == null) {
- LOG.error(PortMappingUtils.UNABLE_MAPPING_LOGMSG, "node id null" , "update", "a null value");
+ LOG.error(PortMappingUtils.UNABLE_MAPPING_LOGMSG, "node id null" , PortMappingUtils.UPDATE, "a null value");
return false;
}
if (oldMapping == null) {
- LOG.error(PortMappingUtils.UNABLE_MAPPING_LOGMSG, nodeId, "update", "a null value");
+ LOG.error(PortMappingUtils.UNABLE_MAPPING_LOGMSG, nodeId, PortMappingUtils.UPDATE, "a null value");
return false;
}
InstanceIdentifier<Ports> portId = InstanceIdentifier.create(OrgOpenroadmDevice.class)
return true;
} catch (InterruptedException | ExecutionException e) {
LOG.error(PortMappingUtils.UNABLE_MAPPING_LOGMSG,
- nodeId, "update", oldMapping.getLogicalConnectionPoint(), e);
+ nodeId, PortMappingUtils.UPDATE, oldMapping.getLogicalConnectionPoint(), e);
return false;
}
}
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));
+ 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();
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();
.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);
+ NonBlockingList nbl = createNonBlockingList(
+ splBldr,
+ 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(),
+ entry,
+ portmappingNode.nonnullMapping(),
+ nodeId);
if (nbl == null) {
return false;
}
nblMap.put(nbl.key(), nbl);
}
- SwitchingPoolLcp switchingPoolLcp = splBldr
- .setNonBlockingList(nblMap)
- .build();
+ 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);
+ postPortMapping(nodeId, null, null, null, new ArrayList<SwitchingPoolLcp>(splMap.values()), 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);
- }
+ NonBlockingListBuilder nblBldr = splBldr.getNonBlockingList() == null
+ || !splBldr.getNonBlockingList().containsKey(new NonBlockingListKey(entry.getKey()))
+ ? new NonBlockingListBuilder().setNblNumber(entry.getKey()).setInterconnectBandwidth(interconnectBw)
+ : new NonBlockingListBuilder(splBldr.getNonBlockingList().get(new NonBlockingListKey(entry.getKey())));
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 {
+ String lcp = getLcpFromCpAndPort(mappings, portList.getCircuitPackName(), portList.getPortName());
+ if (lcp == null || lcpList.contains(lcp)) {
return null;
}
+ lcpList.add(lcp);
}
- nblBldr.setLcpList(lcpList);
- return nblBldr.build();
+ return nblBldr.setLcpList(lcpList).build();
}
private boolean createXpdrPortMapping(String nodeId, List<Mapping> portMapList) {
}
OrgOpenroadmDevice device = deviceObject.get();
if (device.getCircuitPacks() == null) {
- LOG.warn(PortMappingUtils.MISSING_CP_LOGMSG, nodeId, "found");
+ LOG.warn(PortMappingUtils.MISSING_CP_LOGMSG, nodeId, PortMappingUtils.FOUND);
return false;
}
for (CircuitPacks cp : circuitPackList) {
String circuitPackName = cp.getCircuitPackName();
if (cp.getPorts() == null) {
- LOG.warn(PortMappingUtils.NO_PORT_ON_CP_LOGMSG, nodeId, "found", circuitPackName);
+ LOG.warn(PortMappingUtils.NO_PORT_ON_CP_LOGMSG, nodeId, PortMappingUtils.FOUND, circuitPackName);
continue;
}
List<Ports> portList = new ArrayList<>(cp.nonnullPorts().values());
}
}
} else {
- LOG.info(PortMappingUtils.XPDR_LIST_IN_CONF_LOGMSG, nodeId, "found");
+ LOG.info(PortMappingUtils.XPDR_LIST_IN_CONF_LOGMSG, nodeId, PortMappingUtils.FOUND);
for (Xponder xponder : deviceObject.get().nonnullXponder().values()) {
// Variables to keep track of number of line ports and client ports
int line = 1;
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()
- .filter(cp -> cp.getCircuitPackName().equals(circuitPackName))
- .findFirst().isEmpty()) {
+ Optional<CircuitPacks> cpList = device.nonnullCircuitPacks().values().stream()
+ .filter(cp -> cp.getCircuitPackName().equals(circuitPackName)).findFirst();
+ if (cpList.isEmpty()) {
LOG.warn(PortMappingUtils.MISSING_CP_LOGMSG + PortMappingUtils.PORTMAPPING_IGNORE_LOGMSG,
nodeId, circuitPackName);
continue;
}
- if (device.nonnullCircuitPacks().values().stream()
- .filter(cp -> cp.getCircuitPackName().equals(circuitPackName))
- .findFirst().get().nonnullPorts().values().stream()
- .filter(p -> p.getPortName().equals(portName))
- .findFirst().isEmpty()) {
+ Optional<Ports> portsList = cpList.get().nonnullPorts().values().stream()
+ .filter(p -> p.getPortName().equals(portName)).findFirst();
+ if (portsList.isEmpty()) {
LOG.warn(PortMappingUtils.NO_ASSOC_FOUND_LOGMSG + PortMappingUtils.PORTMAPPING_IGNORE_LOGMSG,
nodeId, portName, circuitPackName, "in the device");
continue;
}
- Ports port = device.nonnullCircuitPacks().values().stream()
- .filter(cp -> cp.getCircuitPackName().equals(circuitPackName))
- .findFirst().get().nonnullPorts().values().stream()
- .filter(p -> p.getPortName().equals(portName))
- .findFirst().get();
int[] counters = fillXpdrLcpsMaps(line, client, nodeId,
- xponderNb, xponderType, circuitPackName, port,
+ xponderNb, xponderType, circuitPackName, portsList.get(),
circuitPackList, lcpMap, mappingMap);
line = counters[0];
client = counters[1];
postPortMapping(nodeId, null, null, null, switchingPoolList, null);
}
- if (!mappingMap.isEmpty()) {
- mappingMap.forEach((k,v) -> portMapList.add(v));
- }
+ mappingMap.forEach((k,v) -> portMapList.add(v));
return true;
}
private boolean createPpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
// Creating mapping data for SRG's PP
- HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.srg.CircuitPacks>> srgCps
- = getSrgCps(nodeId, deviceInfo);
for (Entry<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.srg.CircuitPacks>>
- srgCpEntry : srgCps.entrySet()) {
- List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.srg.CircuitPacks> cpList =
- srgCps.get(srgCpEntry.getKey());
+ srgCpEntry : getSrgCps(nodeId, deviceInfo).entrySet()) {
List<String> keys = new ArrayList<>();
- for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.srg.CircuitPacks cp : cpList) {
+ for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.srg.CircuitPacks
+ cp : srgCpEntry.getValue()) {
String circuitPackName = cp.getCircuitPackName();
- InstanceIdentifier<CircuitPacks> cpIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName));
- Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
- LogicalDatastoreType.OPERATIONAL, cpIID,
- Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
-
- if (circuitPackObject.isEmpty()) {
- LOG.warn(PortMappingUtils.MISSING_CP_LOGMSG + PortMappingUtils.PORTMAPPING_IGNORE_LOGMSG,
- nodeId, circuitPackName);
- continue;
- }
- if (circuitPackObject.get().getPorts() == null) {
- LOG.warn(PortMappingUtils.NO_PORT_ON_CP_LOGMSG, nodeId, "found", circuitPackName);
- continue;
- }
-
- List<Ports> portList = new ArrayList<>(circuitPackObject.get().nonnullPorts().values());
+ List<Ports> portList = getPortList(circuitPackName, nodeId);
Collections.sort(portList, new SortPort710ByName());
int portIndex = 1;
for (Ports port : portList) {
if (!checkPortQual(port, circuitPackName, nodeId)) {
continue;
}
-
String currentKey = circuitPackName + "-" + port.getPortName();
if (keys.contains(currentKey)) {
LOG.debug(PortMappingUtils.PORT_ALREADY_HANDLED_LOGMSG + PortMappingUtils.CANNOT_AS_LCP_LOGMSG,
nodeId, port.getPortName(), circuitPackName);
continue;
}
-
switch (port.getPortDirection()) {
-
case Bidirectional:
String lcp = createLogicalConnectionPort(port, srgCpEntry.getKey(), portIndex);
LOG.info(PortMappingUtils.ASSOCIATED_LCP_LOGMSG,
portIndex++;
keys.add(currentKey);
break;
-
case Rx:
case Tx:
if (!checkPartnerPortNotNull(port)) {
nodeId, port.getPortName(), circuitPackName);
continue;
}
-
String lcp1 = createLogicalConnectionPort(port, srgCpEntry.getKey(), portIndex);
LOG.info(PortMappingUtils.ASSOCIATED_LCP_LOGMSG,
nodeId, port.getPortName(), circuitPackName, lcp1);
port.getPortName(), circuitPackName);
continue;
}
-
Ports port2 = port2Object.get();
if (!checkPartnerPort(circuitPackName, port, port2)) {
LOG.error(PortMappingUtils.NOT_CORRECT_PARTNERPORT_LOGMSG
keys.add(currentKey);
keys.add(port.getPartnerPort().getCircuitPackName() + "-" + port2.getPortName());
break;
-
default:
LOG.error(PortMappingUtils.UNSUPPORTED_DIR_LOGMSG + PortMappingUtils.CANNOT_AS_LCP_LOGMSG,
nodeId, port.getPortName(), circuitPackName, port.getPortDirection());
-
}
}
}
return true;
}
+ private List<Ports> getPortList(String circuitPackName, String nodeId) {
+ InstanceIdentifier<CircuitPacks> cpIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName));
+ Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
+ LogicalDatastoreType.OPERATIONAL, cpIID,
+ Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ if (circuitPackObject.isEmpty()) {
+ LOG.warn(PortMappingUtils.MISSING_CP_LOGMSG + PortMappingUtils.PORTMAPPING_IGNORE_LOGMSG,
+ nodeId, circuitPackName);
+ return new ArrayList<>();
+ }
+ if (circuitPackObject.get().getPorts() == null) {
+ LOG.warn(PortMappingUtils.NO_PORT_ON_CP_LOGMSG, nodeId, PortMappingUtils.FOUND, circuitPackName);
+ return new ArrayList<>();
+ }
+ return new ArrayList<>(circuitPackObject.get().nonnullPorts().values());
+ }
+
private String createLogicalConnectionPort(Ports port, int index, int portIndex) {
if (SUFFIX.containsKey(port.getPortDirection())) {
return String.join("-", "SRG" + index, "PP" + portIndex, SUFFIX.get(port.getPortDirection()));
// update existing mapping
return new MappingBuilder(mapping).setConnectionMapLcp(connectionMapLcp).build();
}
+ return createNewXpdrMapping(nodeId, port, circuitPackName, logicalConnectionPoint, partnerLcp, xpdrNodeType);
+ }
- // create a new mapping
- String nodeIdLcp = nodeId + "-" + logicalConnectionPoint;
+ private Mapping createNewXpdrMapping(String nodeId, Ports port, String circuitPackName,
+ String logicalConnectionPoint, String partnerLcp, XpdrNodeTypes xpdrNodeType) {
MappingBuilder mpBldr = new MappingBuilder()
.withKey(new MappingKey(logicalConnectionPoint))
.setLogicalConnectionPoint(logicalConnectionPoint)
.setSupportingCircuitPackName(circuitPackName)
.setSupportingPort(port.getPortName())
.setPortDirection(port.getPortDirection().getName())
- .setLcpHashVal(PortMappingUtils.fnv1size64(nodeIdLcp));
+ .setLcpHashVal(PortMappingUtils.fnv1size64(nodeId + "-" + logicalConnectionPoint));
if (port.getPortQual() != null) {
mpBldr.setPortQual(port.getPortQual().getName());
}
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()) {
+ for (SupportedInterfaceCapability sic : port.augmentation(Ports1.class).getPortCapabilities()
+ .nonnullSupportedInterfaceCapability().values()) {
supportedIntf.add(sic.getIfCapType());
sic1 = sic;
}
+ mpBldr.setSupportedInterfaceCapability(supportedIntf);
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);
+ String mxpProfileName =
+ sic1.getOtnCapability().getMpdrClientRestriction().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
.setMaxTribSlot(minMaxOpucnTribSlots.get(1))
.build());
}
- mpBldr.setSupportedInterfaceCapability(supportedIntf);
}
if (port.getAdministrativeState() != null) {
mpBldr.setPortAdminState(port.getAdministrativeState().name());
Code Review / transportpce.git / blobdiff