*/
package org.opendaylight.transportpce.common.mapping;
+
import com.google.common.util.concurrent.CheckedFuture;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
-import java.util.Set;
import java.util.stream.Collectors;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.MappingBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.MappingKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.NodeTypes;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PortQual;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.Direction;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.Port;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.CircuitPack;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.pack.Ports;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.pack.PortsKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
-
-
-
public class PortMappingVersion221 {
private static final Logger LOG = LoggerFactory.getLogger(PortMappingImpl.class);
private final OpenRoadmInterfaces openRoadmInterfaces;
public PortMappingVersion221(DataBroker dataBroker, DeviceTransactionManager deviceTransactionManager,
- OpenRoadmInterfaces openRoadmInterfaces) {
+ OpenRoadmInterfaces openRoadmInterfaces) {
this.dataBroker = dataBroker;
this.deviceTransactionManager = deviceTransactionManager;
this.openRoadmInterfaces = openRoadmInterfaces;
LOG.info("Create Mapping Data for node 2.2.1 {}", nodeId);
List<Mapping> portMapList = new ArrayList<>();
InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
- Optional<Info> deviceInfoOptional = this.deviceTransactionManager
- .getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, infoIID,
- Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ Optional<Info> deviceInfoOptional = this.deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType
+ .OPERATIONAL, infoIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
Info deviceInfo;
if (deviceInfoOptional.isPresent()) {
}
public boolean updateMapping(String nodeId, Mapping oldMapping) {
-
-
LOG.info("Updating Mapping Data {} for node {}", oldMapping, nodeId);
- InstanceIdentifier<Ports> portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
- CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName())).child(Ports.class,
- new PortsKey(oldMapping.getSupportingPort()));
+ InstanceIdentifier<Ports> portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName()))
+ .child(Ports.class, new PortsKey(oldMapping.getSupportingPort()));
if ((oldMapping != null) && (nodeId != null)) {
try {
Optional<Ports> portObject = deviceTransactionManager.getDataFromDevice(nodeId,
if (portObject.isPresent()) {
Ports port = portObject.get();
Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(),
- oldMapping.getLogicalConnectionPoint());
+ oldMapping.getLogicalConnectionPoint());
final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
- InstanceIdentifier<Mapping> mapIID = InstanceIdentifier.create(Network.class).child(Nodes.class,
- new NodesKey(nodeId)).child(Mapping.class,
- new MappingKey(oldMapping.getLogicalConnectionPoint()));
+ InstanceIdentifier<Mapping> mapIID = InstanceIdentifier.create(Network.class)
+ .child(Nodes.class, new NodesKey(nodeId))
+ .child(Mapping.class, new MappingKey(oldMapping.getLogicalConnectionPoint()));
writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, mapIID, newMapping);
CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
submit.checkedGet();
return false;
} catch (TransactionCommitFailedException e) {
LOG.error("Transaction Commit Error updating Mapping {} for node {}", oldMapping
- .getLogicalConnectionPoint(), nodeId, e);
+ .getLogicalConnectionPoint(), nodeId, e);
return false;
}
} else {
private boolean createXpdrPortMapping(String nodeId, List<Mapping> portMapList) {
// Creating for Xponder Line and Client Ports
InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class);
- Optional<OrgOpenroadmDevice> deviceObject =
- deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, deviceIID,
- Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ Optional<OrgOpenroadmDevice> deviceObject = deviceTransactionManager.getDataFromDevice(nodeId,
+ LogicalDatastoreType.OPERATIONAL, deviceIID,
+ Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
// Variable to keep track of number of line ports
int line = 1;
LOG.warn("Circuit Packs are not present for {}", nodeId);
return false; // TODO return false or continue?
}
- Map<String, String> lcpMap = new HashMap();
- Map<String, Mapping> mappingMap = new HashMap();
+ Map<String, String> lcpMap = new HashMap<>();
+ Map<String, Mapping> mappingMap = new HashMap<>();
List<CircuitPacks> circuitPackList = deviceObject.get().getCircuitPacks();
circuitPackList.sort(Comparator.comparing(CircuitPack::getCircuitPackName));
List<Ports> portList = cp.getPorts();
portList.sort(Comparator.comparing(Ports::getPortName));
for (Ports port : portList) {
- if (PortQual.XpdrNetwork.getName().equals(port.getPortQual().getName())) {
+ if (port.getPortQual() == null) {
+ LOG.warn("PortQual was not found for port {} on circuit pack: {}", port.getPortName(),
+ circuitPackName);
+ continue;
+ }
+ if (Port.PortQual.XpdrNetwork.getIntValue() == port.getPortQual().getIntValue()
+ && port.getPortDirection().getIntValue() == Direction.Bidirectional.getIntValue()) {
String lcp = "XPDR1-" + StringConstants.NETWORK_TOKEN + line;
lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
- mappingMap.put(lcp, createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null));
+ mappingMap.put(lcp, createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null, null));
line++;
- } else if (PortQual.XpdrClient.getName().equals(port.getPortQual().getName())) {
+ } else if (Port.PortQual.XpdrNetwork.getIntValue() == port.getPortQual().getIntValue()
+ && port.getPortDirection().getIntValue() != Direction.Bidirectional.getIntValue()
+ && port.getPartnerPort() != null
+ && port.getPartnerPort().getCircuitPackName() != null
+ && port.getPartnerPort().getPortName() != null) {
+ if (lcpMap.containsKey(circuitPackName + '+' + port.getPortName())) {
+ continue;
+ }
+ String lcp1 = "XPDR1-" + StringConstants.NETWORK_TOKEN + line;
+ Optional<CircuitPacks> cpOpt = circuitPackList.stream().filter(cP -> cP.getCircuitPackName()
+ .equals(port.getPartnerPort().getCircuitPackName())).findFirst();
+ if (cpOpt.isPresent()) {
+ Optional<Ports> poOpt = cpOpt.get().getPorts().stream().filter(p -> p.getPortName().equals(port
+ .getPartnerPort().getPortName().toString())).findFirst();
+ if (poOpt.isPresent()) {
+ Ports port2 = poOpt.get();
+ if ((Direction.Rx.getIntValue() == port.getPortDirection().getIntValue()
+ && Direction.Tx.getIntValue() == port2.getPortDirection().getIntValue()
+ && port2.getPartnerPort() != null && port2.getPartnerPort().getCircuitPackName() != null
+ && port2.getPartnerPort().getPortName() != null
+ && port2.getPartnerPort().getCircuitPackName().equals(circuitPackName)
+ && port2.getPartnerPort().getPortName().equals(port.getPortName()))
+ ||
+ (Direction.Tx.getIntValue() == port.getPortDirection().getIntValue()
+ && Direction.Rx.getIntValue() == port2.getPortDirection().getIntValue()
+ && port2.getPartnerPort() != null && port2.getPartnerPort().getCircuitPackName() != null
+ && port2.getPartnerPort().getPortName() != null
+ && port2.getPartnerPort().getCircuitPackName().equals(circuitPackName)
+ && port2.getPartnerPort().getPortName().equals(port.getPortName()))) {
+ String lcp2 = new StringBuilder("XPDR1-").append(StringConstants.NETWORK_TOKEN)
+ .append(line + 1).toString();
+ if (!lcpMap.containsKey(lcp1) && !lcpMap.containsKey(lcp2)) {
+ lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp1);
+ lcpMap.put(cpOpt.get().getCircuitPackName() + '+' + port2.getPortName(), lcp2);
+ mappingMap.put(lcp1, createXpdrMappingObject(nodeId, port, circuitPackName, lcp1,
+ lcp2, null, null));
+ mappingMap.put(lcp2, createXpdrMappingObject(nodeId, port2, cpOpt.get()
+ .getCircuitPackName(), lcp2, lcp1, null, null));
+ } else {
+ LOG.warn("mapping already exists for {} or {}", lcp1, lcp2);
+ }
+ line += 2;
+ } else {
+ LOG.error("port {} on {} is not a correct partner port of {} on {}",
+ port2.getPortName(), cpOpt.get().getCircuitPackName(), port.getPortName(),
+ circuitPackName);
+ }
+ } else {
+ LOG.error("Error fetching port {} on {} for {}", port.getPartnerPort().getPortName(),
+ port.getPartnerPort().getCircuitPackName(), nodeId);
+ }
+ } else {
+ LOG.error("Error fetching circuit-pack {} for {}", port.getPartnerPort().getCircuitPackName(),
+ nodeId);
+ }
+ } else if (Port.PortQual.XpdrClient.getIntValue() == port.getPortQual().getIntValue()) {
String lcp = "XPDR1-" + StringConstants.CLIENT_TOKEN + client;
lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
- mappingMap.put(lcp, createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null));
+ mappingMap.put(lcp, createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null, null));
client++;
} else {
- LOG.warn("Not supported type of port! Port type: {}", port.getPortQual().getName());
- }
- if (portMapList.size() == 0) {
- LOG.info("portMapList is empty");
- } else {
- LOG.info("portMapList Is {} {}",portMapList.size(),portMapList.get(0));
+ LOG.warn("Error in the configuration of port {} of {} for {}", port.getPortName(), circuitPackName,
+ nodeId);
}
}
}
List<ConnectionMap> connectionMap = deviceObject.get().getConnectionMap();
+ String slcp = null;
+ String dlcp = null;
for (ConnectionMap cm : connectionMap) {
String skey = cm.getSource().getCircuitPackName() + "+" + cm.getSource().getPortName();
- String slcp = lcpMap.get(skey);
- String dkey = cm.getDestination().get(0).getCircuitPackName() + "+" + cm.getDestination().get(0)
- .getPortName();
- String dlcp = lcpMap.get(dkey);
- Mapping mapping = mappingMap.get(slcp);
- mappingMap.remove(slcp);
- portMapList.add(createXpdrMappingObject(nodeId, null, null, null, mapping, dlcp));
+ if (lcpMap.containsKey(skey)) {
+ slcp = lcpMap.get(skey);
+ }
+ String dkey = cm.getDestination().get(0).getCircuitPackName() + "+"
+ + cm.getDestination().get(0).getPortName();
+ if (lcpMap.containsKey(dkey)) {
+ dlcp = lcpMap.get(dkey);
+ }
+ if (slcp != null) {
+ Mapping mapping = mappingMap.get(slcp);
+ mappingMap.remove(slcp);
+ portMapList.add(createXpdrMappingObject(nodeId, null, null, null, null, mapping, dlcp));
+ } else {
+ LOG.error("Error in connection-map analysis");
+ }
}
if (!mappingMap.isEmpty()) {
for (Mapping m : mappingMap.values()) {
return true;
}
-
-
private HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg
- .CircuitPacks>> getSrgCps(String deviceId, Info ordmInfo) {
+ .CircuitPacks>> getSrgCps(String deviceId, Info ordmInfo) {
HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg
- .CircuitPacks>> cpPerSrg = new HashMap<>();
+ .CircuitPacks>> cpPerSrg = new HashMap<>();
Integer maxSrg;
// Get value for max Srg from info subtree, required for iteration
// if not present assume to be 20 (temporary)
maxSrg = 20;
}
for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) {
- List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks> srgCps =
- new ArrayList<>();
+ List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks> srgCps
+ = new ArrayList<>();
LOG.info("Getting Circuitpacks for Srg Number {}", srgCounter);
InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter));
+ .child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter));
Optional<SharedRiskGroup> ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
LogicalDatastoreType.OPERATIONAL, srgIID,
Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
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.rev181019.srg
- .CircuitPacks>> srgCps = getSrgCps(nodeId, deviceInfo);
- Set<Map.Entry<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019
- .srg.CircuitPacks>>> circuitPacks = srgCps.entrySet();
- for (Map.Entry<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg
- .CircuitPacks>> entry : circuitPacks) {
- Integer srgIndex = entry.getKey();
- for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks cp : entry
- .getValue()) {
+ HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks>> srgCps
+ = getSrgCps(nodeId, deviceInfo);
+
+ for (Integer k : srgCps.keySet()) {
+ List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks> cpList =
+ srgCps.get(k);
+ List<String> keys = new ArrayList<>();
+ for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks cp : cpList) {
String circuitPackName = cp.getCircuitPackName();
InstanceIdentifier<CircuitPacks> cpIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName));
+ .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);
portList.sort(Comparator.comparing(Ports::getPortName));
int portIndex = 1;
for (Ports port : portList) {
+ String currentKey = circuitPackName + "-" + port.getPortName();
if (port.getPortQual() == null) {
continue;
- } else if (PortQual.RoadmExternal.getIntValue() == port.getPortQual().getIntValue()) {
- String logicalConnectionPoint = createLogicalConnectionPort(port, srgIndex, portIndex);
+ } else if (Port.PortQual.RoadmExternal.getIntValue() == port.getPortQual().getIntValue()
+ && Direction.Bidirectional.getIntValue() == port.getPortDirection().getIntValue()
+ && !keys.contains(currentKey)) {
+ String logicalConnectionPoint = createLogicalConnectionPort(port, k, portIndex);
LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName,
port.getPortName(), logicalConnectionPoint);
portMapList.add(createMappingObject(nodeId, port, circuitPackName, logicalConnectionPoint));
portIndex++;
+ keys.add(currentKey);
+ } else if (Port.PortQual.RoadmExternal.getIntValue() == port.getPortQual().getIntValue()
+ && (Direction.Rx.getIntValue() == port.getPortDirection().getIntValue()
+ || Direction.Tx.getIntValue() == port.getPortDirection().getIntValue())
+ && !keys.contains(currentKey)
+ && port.getPartnerPort() != null) {
+ String logicalConnectionPoint1 = createLogicalConnectionPort(port, k, portIndex);
+ LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName,
+ port.getPortName(), logicalConnectionPoint1);
+ InstanceIdentifier<Ports> port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(CircuitPacks.class, new CircuitPacksKey(port.getPartnerPort().getCircuitPackName()))
+ .child(Ports.class, new PortsKey(port.getPartnerPort().getPortName().toString()));
+ Optional<Ports> port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
+ LogicalDatastoreType.OPERATIONAL, port2ID,
+ Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ if (port2Object.isPresent() && port2Object.get().getPortQual().getIntValue() ==
+ Port.PortQual.RoadmExternal.getIntValue()) {
+ Ports port2 = port2Object.get();
+ if ((port.getPortDirection().getIntValue() == Direction.Rx.getIntValue()
+ && port2.getPortDirection().getIntValue() == Direction.Tx.getIntValue()
+ && port2.getPartnerPort() != null
+ && port2.getPartnerPort().getCircuitPackName().equals(circuitPackName)
+ && port2.getPartnerPort().getPortName().toString().equals(port.getPortName()))
+ ||
+ (port.getPortDirection().getIntValue() == Direction.Tx.getIntValue()
+ && port2.getPortDirection().getIntValue() == Direction.Rx.getIntValue()
+ && port2.getPartnerPort() != null
+ && port2.getPartnerPort().getCircuitPackName().equals(circuitPackName)
+ && port2.getPartnerPort().getPortName().toString().equals(port.getPortName()))) {
+ String logicalConnectionPoint2 = createLogicalConnectionPort(port2, k, portIndex);
+ LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName,
+ port2.getPortName(), logicalConnectionPoint2);
+ portMapList.add(createMappingObject(nodeId, port, circuitPackName,
+ logicalConnectionPoint1));
+ portMapList.add(createMappingObject(nodeId,port2,
+ port.getPartnerPort().getCircuitPackName(), logicalConnectionPoint2));
+ portIndex++;
+ keys.add(currentKey);
+ keys.add(port.getPartnerPort().getCircuitPackName() + "-" + port2.getPortName());
+ } else {
+ LOG.error("Error with partner port configuration for port {} of {} - {}",
+ port.getPortName(), circuitPackName, nodeId);
+ portIndex++;
+ }
+ } else {
+ LOG.error("error getting partner port {} of {} - {}", port.getPartnerPort().getPortName()
+ .toString(), port.getPartnerPort().getCircuitPackName(), nodeId);
+ continue;
+ }
} else {
- LOG.info("{} : port {} on {} is not roadm-external. No logicalConnectionPoint for this port.",
+ LOG.info("{} : port {} on {} is not roadm-external or has already been handled."
+ + "No logicalConnectionPoint assignment for this port.",
nodeId, port.getPortName(), circuitPackName);
}
}
return true;
}
- private static String getLogicalConnectionPort(Ports port, int srgCounter) {
- String logicalConnectionPoint = null;
- if (port.getLogicalConnectionPoint() != null) {
- switch (port.getPortDirection()) {
- case Tx:
- // Port direction is transmit
- if (!port.getLogicalConnectionPoint().contains("SRG")) {
- logicalConnectionPoint = "SRG" + srgCounter + "-" + port.getLogicalConnectionPoint() + "-TX";
- } else {
- logicalConnectionPoint = port.getLogicalConnectionPoint() + "-TX";
- }
- break;
- case Rx:
- // Port direction is receive
- if (!port.getLogicalConnectionPoint().contains("SRG")) {
- logicalConnectionPoint = "SRG" + srgCounter + "-" + port.getLogicalConnectionPoint() + "-RX";
- } else {
- logicalConnectionPoint = port.getLogicalConnectionPoint() + "-RX";
- }
- break;
- case Bidirectional:
- // port is bidirectional
- if (!port.getLogicalConnectionPoint().contains("SRG")) {
- logicalConnectionPoint = "SRG" + srgCounter + "-" + port.getLogicalConnectionPoint();
- } else {
- logicalConnectionPoint = port.getLogicalConnectionPoint();
- }
- if (!port.getLogicalConnectionPoint().endsWith("-TXRX")) {
- logicalConnectionPoint = logicalConnectionPoint.concat("-TXRX");
- }
- break;
- default:
- // Unsupported Port direction
- LOG.error("Unsupported port direction for port {} {}", port, port.getPortDirection());
- return null; // TODO return false or continue?
- }
- return logicalConnectionPoint;
- }
- LOG.warn("Unsupported port direction for port {} - {} - LogicalConnectionPoint is null",
- port, port.getPortDirection());
- return null; // TODO return false or continue?
- }
-
- private String createLogicalConnectionPort(Ports port, int srgIndex, int portIndex) {
+ private String createLogicalConnectionPort(Ports port, int index, int portIndex) {
String lcp = null;
switch (port.getPortDirection()) {
case Tx:
- lcp = "SRG" + srgIndex + "-PP" + portIndex + "-TX";
+ lcp = "SRG" + index + "-PP" + portIndex + "-TX";
break;
case Rx:
- lcp = "SRG" + srgIndex + "-PP" + portIndex + "-RX";
+ lcp = "SRG" + index + "-PP" + portIndex + "-RX";
break;
case Bidirectional:
- lcp = "SRG" + srgIndex + "-PP" + portIndex + "-TXRX";
+ lcp = "SRG" + index + "-PP" + portIndex + "-TXRX";
break;
default:
LOG.error("Unsupported port direction for port {} : {}", port, port.getPortDirection());
for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(Degree.class, new DegreeKey(degreeCounter));
+ .child(Degree.class, new DegreeKey(degreeCounter));
Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
LogicalDatastoreType.OPERATIONAL, deviceIID,
Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
if (ordmDegreeObject.isPresent()) {
degrees.add(ordmDegreeObject.get());
}
- LOG.info("Device {} has {} degree", degrees.size());
}
+ LOG.info("Device {} has {} degree", degrees.size());
return degrees;
}
- private static List<ConnectionPorts> getDegreePorts(List<Degree> degrees) {
- return degrees.stream().filter(degree -> degree.getConnectionPorts() != null)
- .flatMap(degree -> degree.getConnectionPorts().stream()).collect(Collectors.toList());
+ private Map<Integer, List<ConnectionPorts>> getPerDegreePorts(String deviceId, Info ordmInfo) {
+ Map<Integer, List<ConnectionPorts>> conPortMap = new HashMap<>();
+ Integer maxDegree;
+
+ if (ordmInfo.getMaxDegrees() != null) {
+ maxDegree = ordmInfo.getMaxDegrees();
+ } else {
+ maxDegree = 20;
+ }
+ for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
+ LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
+ InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(Degree.class, new DegreeKey(degreeCounter));
+ Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
+ LogicalDatastoreType.OPERATIONAL, deviceIID,
+ Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ if (ordmDegreeObject.isPresent()) {
+ conPortMap.put(degreeCounter, ordmDegreeObject.get().getConnectionPorts());
+ }
+ }
+ LOG.info("Device {} has {} degree", deviceId, conPortMap.size());
+ return conPortMap;
}
private Map<String, String> getEthInterfaceList(String nodeId) {
if (interfaceObject.isPresent() && (interfaceObject.get().getSupportingCircuitPackName() != null)) {
String supportingCircuitPackName = interfaceObject.get().getSupportingCircuitPackName();
cpToInterfaceMap.put(supportingCircuitPackName, portConfig.getIfName());
- InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier.create(OrgOpenroadmDevice
- .class).child(CircuitPacks.class, new CircuitPacksKey(supportingCircuitPackName));
+ InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier
+ .create(OrgOpenroadmDevice.class)
+ .child(CircuitPacks.class, new CircuitPacksKey(supportingCircuitPackName));
Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(
- nodeId, LogicalDatastoreType.OPERATIONAL, circuitPacksIID, Timeouts
- .DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ nodeId, LogicalDatastoreType.OPERATIONAL, circuitPacksIID, Timeouts.DEVICE_READ_TIMEOUT,
+ Timeouts.DEVICE_READ_TIMEOUT_UNIT);
if (circuitPackObject.isPresent() && (circuitPackObject.get().getParentCircuitPack() != null)) {
cpToInterfaceMap.put(circuitPackObject.get().getParentCircuitPack().getCircuitPackName(),
- portConfig.getIfName());
+ portConfig.getIfName());
}
}
}
}
private List<CpToDegree> getCpToDegreeList(List<Degree> degrees, String nodeId,
- Map<String, String> interfaceList) {
+ Map<String, String> interfaceList) {
List<CpToDegree> cpToDegreeList = new ArrayList<>();
for (Degree degree : degrees) {
if (degree.getCircuitPacks() != null) {
LOG.info("Inside CP to degree list");
cpToDegreeList.addAll(degree.getCircuitPacks().stream()
.map(cp -> createCpToDegreeObject(cp.getCircuitPackName(),
- degree.getDegreeNumber().toString(), nodeId, interfaceList)).collect(Collectors.toList()));
+ degree.getDegreeNumber().toString(), nodeId, interfaceList))
+ .collect(Collectors.toList()));
}
}
return cpToDegreeList;
}
private boolean postPortMapping(Info deviceInfo, List<Mapping> portMapList, Integer nodeType,
- List<CpToDegree> cp2DegreeList) {
+ List<CpToDegree> cp2DegreeList) {
NodesBuilder nodesBldr = new NodesBuilder();
nodesBldr.withKey(new NodesKey(deviceInfo.getNodeId().getValue())).setNodeId(deviceInfo.getNodeId().getValue());
nodesBldr.setNodeType(NodeTypes.forValue(nodeType));
}
private CpToDegree createCpToDegreeObject(String circuitPackName, String degreeNumber, String nodeId,
- Map<String, String> interfaceList) {
+ Map<String, String> interfaceList) {
String interfaceName = null;
if (interfaceList.get(circuitPackName) != null) {
interfaceName = interfaceList.get(circuitPackName);
}
return new CpToDegreeBuilder().withKey(new CpToDegreeKey(circuitPackName)).setCircuitPackName(circuitPackName)
- .setDegreeNumber(new Long(degreeNumber)).setInterfaceName(interfaceName).build();
+ .setDegreeNumber(new Long(degreeNumber)).setInterfaceName(interfaceName).build();
}
private Mapping createMappingObject(String nodeId, Ports port, String circuitPackName,
String logicalConnectionPoint) {
MappingBuilder mpBldr = new MappingBuilder();
mpBldr.withKey(new MappingKey(logicalConnectionPoint)).setLogicalConnectionPoint(logicalConnectionPoint)
- .setSupportingCircuitPackName(circuitPackName).setSupportingPort(port.getPortName())
- .setPortDirection(port.getPortDirection().getName());
+ .setSupportingCircuitPackName(circuitPackName).setSupportingPort(port.getPortName())
+ .setPortDirection(port.getPortDirection().getName());
// Get OMS and OTS interface provisioned on the TTP's
if (logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) && (port.getInterfaces() != null)) {
for (Interfaces interfaces : port.getInterfaces()) {
try {
- Optional<Interface>
- openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
+ Optional<Interface> openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
interfaces.getInterfaceName());
if (openRoadmInterface.isPresent()) {
- Class<? extends InterfaceType> interfaceType = (Class<? extends InterfaceType>)
- openRoadmInterface.get().getType();
+ Class<? extends InterfaceType> interfaceType
+ = (Class<? extends InterfaceType>) openRoadmInterface.get().getType();
// Check if interface type is OMS or OTS
if (interfaceType.equals(OpenROADMOpticalMultiplex.class)) {
mpBldr.setSupportingOms(interfaces.getInterfaceName());
}
} catch (OpenRoadmInterfaceException ex) {
LOG.warn("Error while getting interface {} from node {}!", interfaces.getInterfaceName(), nodeId,
- ex);
+ ex);
}
}
}
}
private Mapping createXpdrMappingObject(String nodeId, Ports port, String circuitPackName,
- String logicalConnectionPoint, Mapping mapping, String assoLcp) {
+ String logicalConnectionPoint, String partnerLcp, Mapping mapping, String assoLcp) {
MappingBuilder mpBldr;
if (mapping != null && assoLcp != null) {
+ // update existing mapping
mpBldr = new MappingBuilder(mapping);
mpBldr.setAssociatedLcp(assoLcp);
} else {
+ // create a new mapping
mpBldr = new MappingBuilder();
mpBldr.withKey(new MappingKey(logicalConnectionPoint))
.setLogicalConnectionPoint(logicalConnectionPoint)
if (port.getPortQual() != null) {
mpBldr.setPortQual(port.getPortQual().getName());
}
+ if (partnerLcp != null) {
+ mpBldr.setPartnerLcp(partnerLcp);
+ }
}
return mpBldr.build();
}
+ @SuppressWarnings("checkstyle:linelength") //log error message in lines 696 and 766 is too long
private boolean createTtpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
// Creating mapping data for degree TTP's
-
List<Degree> degrees = getDegrees(nodeId, deviceInfo);
- List<ConnectionPorts> degreeConPorts = getDegreePorts(degrees);
Map<String, String> interfaceList = getEthInterfaceList(nodeId);
List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, nodeId, interfaceList);
LOG.info("Map looks like this {}", interfaceList);
postPortMapping(deviceInfo, null, deviceInfo.getNodeType().getIntValue(), cpToDegreeList);
- // Getting circuit-pack-name/port-name corresponding to TTP's
- for (ConnectionPorts cp : degreeConPorts) {
- String circuitPackName = cp.getCircuitPackName();
- String portName = cp.getPortName().toString();
- InstanceIdentifier<Ports> portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName))
- .child(Ports.class, new PortsKey(portName));
-
- LOG.info("Fetching logical Connection Point value for port {} at circuit pack {}", portName,
- circuitPackName);
- Optional<Ports> portObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
- LogicalDatastoreType.OPERATIONAL, portIID, Timeouts.DEVICE_READ_TIMEOUT,
- Timeouts.DEVICE_READ_TIMEOUT_UNIT);
- if (portObject.isPresent()) {
- Ports port = portObject.get();
- if (port.getLogicalConnectionPoint() != null) {
- LOG.info("Logical Connection Point for {} {} is {}", circuitPackName, portName,
- port.getLogicalConnectionPoint());
- portMapList.add(createMappingObject(nodeId, port, circuitPackName,
- port.getLogicalConnectionPoint()));
- } else {
- LOG.warn("Logical Connection Point value is missing for {} {}", circuitPackName,
- port.getPortName());
- }
- } else {
- LOG.warn("Port {} is not present in node {} in circuit pack {}!", portName, nodeId, circuitPackName);
- continue; // TODO continue or return true?
+ Map<Integer, List<ConnectionPorts>> connectionPortMap = getPerDegreePorts(nodeId, deviceInfo);
+ for (Integer k : connectionPortMap.keySet()) {
+ switch (connectionPortMap.get(k).size()) {
+ case 1:
+ // port is bidirectional
+ InstanceIdentifier<Ports> portID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(CircuitPacks.class, new CircuitPacksKey(connectionPortMap.get(k).get(0)
+ .getCircuitPackName()))
+ .child(Ports.class, new PortsKey(connectionPortMap.get(k).get(0)
+ .getPortName().toString()));
+ LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap.get(k).get(0)
+ .getPortName().toString(), connectionPortMap.get(k).get(0).getCircuitPackName());
+ Optional<Ports> portObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
+ LogicalDatastoreType.OPERATIONAL, portID, Timeouts.DEVICE_READ_TIMEOUT,
+ Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ if (portObject.isPresent()) {
+ Ports port = portObject.get();
+ if (port.getPortQual() == null) {
+ continue;
+ } else if (Port.PortQual.RoadmExternal.getIntValue() == port.getPortQual().getIntValue()
+ && Direction.Bidirectional.getIntValue() == port.getPortDirection().getIntValue()) {
+ String logicalConnectionPoint = new StringBuilder("DEG").append(k).append("-TTP-TXRX")
+ .toString();
+ LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
+ connectionPortMap.get(k).get(0).getCircuitPackName(), port.getPortName(),
+ logicalConnectionPoint);
+ portMapList.add(createMappingObject(nodeId, port,
+ connectionPortMap.get(k).get(0).getCircuitPackName(), logicalConnectionPoint));
+ } else {
+ LOG.error(
+ "Impossible to create logical connection point for port {} of {} on node {} - Error in configuration with port-qual or port-direction",
+ port.getPortName(), connectionPortMap.get(k).get(0).getCircuitPackName(), nodeId);
+ }
+ } else {
+ LOG.error("No port {} on circuit pack {} for node {}",
+ connectionPortMap.get(k).get(0).getPortName().toString(),
+ connectionPortMap.get(k).get(0).getCircuitPackName(), nodeId);
+ return false;
+ }
+ break;
+ case 2:
+ // ports are unidirectionals
+ String cp1Name = connectionPortMap.get(k).get(0).getCircuitPackName();
+ String cp2Name = connectionPortMap.get(k).get(1).getCircuitPackName();
+ InstanceIdentifier<Ports> port1ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(CircuitPacks.class, new CircuitPacksKey(cp1Name))
+ .child(Ports.class, new PortsKey(connectionPortMap.get(k).get(0).getPortName().toString()));
+ LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap.get(k).get(0)
+ .getPortName().toString(), cp1Name);
+ Optional<Ports> port1Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
+ LogicalDatastoreType.OPERATIONAL, port1ID, Timeouts.DEVICE_READ_TIMEOUT,
+ Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ InstanceIdentifier<Ports> port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(CircuitPacks.class, new CircuitPacksKey(cp2Name))
+ .child(Ports.class, new PortsKey(connectionPortMap.get(k).get(1).getPortName().toString()));
+ LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap.get(k).get(1)
+ .getPortName().toString(), cp2Name);
+ Optional<Ports> port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
+ LogicalDatastoreType.OPERATIONAL, port2ID, Timeouts.DEVICE_READ_TIMEOUT,
+ Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ if (port1Object.isPresent() && port2Object.isPresent()) {
+ Ports port1 = port1Object.get();
+ Ports port2 = port2Object.get();
+ if (port1.getPortQual() == null || port2.getPortQual() == null) {
+ continue;
+ } else if ((Port.PortQual.RoadmExternal.getIntValue() == port1.getPortQual().getIntValue()
+ && Port.PortQual.RoadmExternal.getIntValue() == port2.getPortQual().getIntValue()
+ && Direction.Rx.getIntValue() == port1.getPortDirection().getIntValue()
+ && Direction.Tx.getIntValue() == port2.getPortDirection().getIntValue()
+ && port1.getPartnerPort() != null && port2.getPartnerPort() != null
+ && port1.getPartnerPort().getCircuitPackName().equals(cp2Name)
+ && port1.getPartnerPort().getPortName().equals(port2.getPortName().toString())
+ && port2.getPartnerPort().getCircuitPackName().equals(cp1Name)
+ && port2.getPartnerPort().getPortName().equals(port1.getPortName()))
+ ||
+ (Port.PortQual.RoadmExternal.getIntValue() == port1.getPortQual().getIntValue()
+ && Port.PortQual.RoadmExternal.getIntValue() == port2.getPortQual().getIntValue()
+ && Direction.Rx.getIntValue() == port2.getPortDirection().getIntValue()
+ && Direction.Tx.getIntValue() == port1.getPortDirection().getIntValue()
+ && port1.getPartnerPort() != null && port2.getPartnerPort() != null
+ && port1.getPartnerPort().getCircuitPackName().equals(cp2Name)
+ && port1.getPartnerPort().getPortName().equals(port2.getPortName().toString())
+ && port2.getPartnerPort().getCircuitPackName().equals(cp1Name)
+ && port2.getPartnerPort().getPortName().equals(port1.getPortName().toString()))) {
+ String logicalConnectionPoint1 = new StringBuilder("DEG").append(k).append("-TTP-")
+ .append(port1.getPortDirection().getName().toUpperCase()).toString();
+ LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
+ connectionPortMap.get(k).get(0).getCircuitPackName(), port1.getPortName(),
+ logicalConnectionPoint1);
+ portMapList.add(createMappingObject(nodeId, port1, connectionPortMap.get(k).get(0)
+ .getCircuitPackName(), logicalConnectionPoint1));
+ String logicalConnectionPoint2 = new StringBuilder("DEG").append(k).append("-TTP-")
+ .append(port2.getPortDirection().getName().toUpperCase()).toString();
+ LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
+ connectionPortMap.get(k).get(1).getCircuitPackName(), port2.getPortName(),
+ logicalConnectionPoint2);
+ portMapList.add(createMappingObject(nodeId, port2, connectionPortMap.get(k).get(1)
+ .getCircuitPackName(), logicalConnectionPoint2));
+ } else {
+ LOG.error(
+ "impossible to create logical connection point for port {} or port {} on node {} - Error in configuration with port-qual, port-direction or partner-port configuration",
+ port1.getPortName(), port2.getPortName(), nodeId);
+ }
+ } else {
+ LOG.error("No port {} on circuit pack {} for node {}",
+ connectionPortMap.get(k).get(0).getPortName().toString(),
+ connectionPortMap.get(k).get(0).getCircuitPackName(), nodeId);
+ return false;
+ }
+
+ break;
+ default:
+ LOG.error("Number of connection port for DEG{} on {} is incorrect", k, nodeId);
+ continue;
}
}
return true;
Code Review / transportpce.git / commitdiff