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.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.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.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.openroadm.common.types.rev161014.Direction;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.CircuitPack;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.Port;
// FIXME: many common pieces of code between PortMapping Versions 121 and 221 and 710
// some mutualization would be helpful
+@SuppressWarnings("CPD-START")
public class PortMappingVersion121 {
private static final Logger LOG = LoggerFactory.getLogger(PortMappingVersion121.class);
}
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();
List<Ports> portList = new ArrayList<>(cp.nonnullPorts().values());
portList.sort(Comparator.comparing(Ports::getPortName));
for (Ports port : portList) {
- if (port.getPortQual() == null) {
- LOG.warn("{} : port {} on {} - PortQual was not found",
- nodeId, port.getPortName(), circuitPackName);
- continue;
- }
-
- switch (port.getPortQual()) {
-
- case XpdrClient:
- String lcp0 = createXpdrLogicalConnectionPort(1, client, StringConstants.CLIENT_TOKEN);
- lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp0);
- mappingMap.put(lcp0,
- createXpdrMappingObject(nodeId, port, circuitPackName, lcp0, null, null, null));
- client++;
- //continue;
- break;
-
- case XpdrNetwork:
- switch (port.getPortDirection()) {
-
- case Bidirectional:
- String lcp = createXpdrLogicalConnectionPort(1, line, StringConstants.NETWORK_TOKEN);
- lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
- mappingMap.put(lcp,
- createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null, null));
- line++;
- break;
-
- case Rx:
- case Tx:
- StringBuilder circuitPackName2 = new StringBuilder();
- Ports port2 = getPort2(port, nodeId, circuitPackName, circuitPackName2,
- circuitPackList, lcpMap);
- if (port2 == null) {
- //key already present or an error occured and was logged
- continue;
- }
- putXpdrLcpsInMaps(line, nodeId, 1,
- circuitPackName, circuitPackName2.toString(), port, port2,
- lcpMap, mappingMap);
- line += 2;
- break;
-
- default:
- LOG.error("{} : port {} on {} - unsupported Direction {}",
- nodeId, port.getPortName(), circuitPackName, port.getPortDirection());
- }
- break;
-
- default:
- LOG.error("{} : port {} on {} - unsupported PortQual {}",
- nodeId, port.getPortName(), circuitPackName, port.getPortQual());
- }
+ int[] counters = fillXpdrLcpsMaps(line, client, nodeId,
+ 1, circuitPackName, port,
+ circuitPackList, lcpMap, mappingMap);
+ line = counters[0];
+ client = counters[1];
}
}
InstanceIdentifier<Ports> port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(CircuitPacks.class,
new CircuitPacksKey(port.getPartnerPort().getCircuitPackName()))
- .child(Ports.class, new PortsKey(port.getPartnerPort().getPortName().toString()));
+ .child(Ports.class, new PortsKey(port.getPartnerPort().getPortName()));
Optional<Ports> port2Object = this.deviceTransactionManager
.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, port2ID,
Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
|| port2Object.get().getPortQual().getIntValue()
!= Port.PortQual.RoadmExternal.getIntValue()) {
LOG.error("{} : port {} on {} - error getting partner",
- nodeId, port.getPartnerPort().getPortName().toString(),
+ nodeId, port.getPartnerPort().getPortName(),
port.getPartnerPort().getCircuitPackName());
continue;
}
return null;
}
- private String createXpdrLogicalConnectionPort(int xponderNb, int lcpNb, String token) {
- return new StringBuilder("XPDR").append(xponderNb)
- .append("-")
- .append(token).append(lcpNb)
- .toString();
- }
-
private Map<Integer, Degree> getDegreesMap(String deviceId, Info ordmInfo) {
Map<Integer, Degree> degrees = new HashMap<>();
.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 (!logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) || (port.getInterfaces() == null)) {
return mpBldr.build();
}
+ 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;
+ }
- // Get OMS and OTS interface provisioned on the TTP's
+ private MappingBuilder updateMappingInterfaces(String nodeId, MappingBuilder mpBldr, Ports port) {
for (Interfaces interfaces : port.getInterfaces()) {
try {
Optional<Interface> openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
nodeId, interfaces.getInterfaceName(), ex);
}
}
- return mpBldr.build();
+ return mpBldr;
}
private Mapping createXpdrMappingObject(String nodeId, Ports port, String circuitPackName,
.setSupportingCircuitPackName(circuitPackName)
.setSupportingPort(port.getPortName())
.setPortDirection(port.getPortDirection().getName())
- .setLcpHashVal(FnvUtils.fnv1_64(nodeIdLcp));
+ .setLcpHashVal(PortMappingUtils.fnv1size64(nodeIdLcp));
if (port.getPortQual() != null) {
mpBldr.setPortQual(port.getPortQual().getName());
}
if (partnerLcp != null) {
mpBldr.setPartnerLcp(partnerLcp);
}
-
+ if (port.getAdministrativeState() != null) {
+ mpBldr.setPortAdminState(port.getAdministrativeState().name());
+ }
+ if (port.getOperationalState() != null) {
+ mpBldr.setPortOperState(port.getOperationalState().name());
+ }
return mpBldr.build();
}
return null;
}
Optional<Ports> poOpt = cpOpt.get().nonnullPorts().values().stream()
- .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString()))
+ .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName()))
.findFirst();
if (!poOpt.isPresent()) {
LOG.error("{} : Error fetching port {} on {}",
Integer xponderNb,
String circuitPackName, String circuitPackName2, Ports port, Ports port2,
Map<String, String> lcpMap, Map<String, Mapping> mappingMap) {
- String lcp1 = createXpdrLogicalConnectionPort(xponderNb, line, StringConstants.NETWORK_TOKEN);
- String lcp2 = createXpdrLogicalConnectionPort(xponderNb, line + 1, StringConstants.NETWORK_TOKEN);
+ String lcp1 =
+ PortMappingUtils.createXpdrLogicalConnectionPort(xponderNb, line, StringConstants.NETWORK_TOKEN);
+ String lcp2 =
+ PortMappingUtils.createXpdrLogicalConnectionPort(xponderNb, line + 1, StringConstants.NETWORK_TOKEN);
if (lcpMap.containsKey(lcp1) || lcpMap.containsKey(lcp2)) {
LOG.warn("{} : mapping already exists for {} or {}", nodeId, lcp1, lcp2);
return;
return;
}
+ private int[] fillXpdrLcpsMaps(int line, int client, String nodeId,
+ Integer xponderNb,
+ String circuitPackName, Ports port,
+ List<CircuitPacks> circuitPackList, Map<String, String> lcpMap, Map<String, Mapping> mappingMap) {
+
+ if (port.getPortQual() == null) {
+ LOG.warn("{} : port {} on {} - PortQual was not found",
+ nodeId, port.getPortName(), circuitPackName);
+ return new int[] {line, client};
+ }
+
+ switch (port.getPortQual()) {
+
+ case XpdrClient:
+ String lcp0 =
+ PortMappingUtils.createXpdrLogicalConnectionPort(xponderNb, client, StringConstants.CLIENT_TOKEN);
+ lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp0);
+ mappingMap.put(lcp0,
+ createXpdrMappingObject(nodeId, port, circuitPackName, lcp0, null, null, null));
+ client++;
+ break;
+
+ case XpdrNetwork:
+ line = fillXpdrNetworkLcpsMaps(line, nodeId,
+ xponderNb,
+ circuitPackName, port,
+ circuitPackList, lcpMap, mappingMap);
+ break;
+
+ default:
+ LOG.error("{} : port {} on {} - unsupported PortQual {}",
+ nodeId, port.getPortName(), circuitPackName, port.getPortQual());
+ }
+ return new int[] {line, client};
+ }
+
+ private int fillXpdrNetworkLcpsMaps(int line, String nodeId,
+ Integer xponderNb,
+ String circuitPackName, Ports port,
+ List<CircuitPacks> circuitPackList, Map<String, String> lcpMap, Map<String, Mapping> mappingMap) {
+
+ switch (port.getPortDirection()) {
+
+ case Bidirectional:
+ String lcp =
+ PortMappingUtils.createXpdrLogicalConnectionPort(xponderNb, line, StringConstants.NETWORK_TOKEN);
+ lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
+ mappingMap.put(lcp,
+ createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null, null));
+ line++;
+ break;
+
+ case Rx:
+ case Tx:
+ StringBuilder circuitPackName2 = new StringBuilder();
+ Ports port2 = getPort2(port, nodeId, circuitPackName, circuitPackName2,
+ circuitPackList, lcpMap);
+
+ if (port2 == null) {
+ //key already present or an error occured and was logged
+ return line;
+ }
+
+ putXpdrLcpsInMaps(line, nodeId, xponderNb,
+ circuitPackName, circuitPackName2.toString(), port, port2,
+ lcpMap, mappingMap);
+
+ line += 2;
+ break;
+
+ default:
+ LOG.error("{} : port {} on {} - unsupported Direction {}",
+ nodeId, port.getPortName(), circuitPackName, port.getPortDirection());
+ }
+
+ return line;
+ }
private boolean createTtpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
// Creating mapping data for degree TTP's
.child(CircuitPacks.class,
new CircuitPacksKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName()))
.child(Ports.class,
- new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString()));
+ new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName()));
LOG.debug("{} : Fetching connection-port {} at circuit pack {}",
nodeId,
connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName(),
connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName());
continue;
}
- String logicalConnectionPoint = new StringBuilder("DEG")
- .append(cpMapEntry.getKey())
- .append("-TTP-TXRX")
- .toString();
+ String logicalConnectionPoint =
+ PortMappingUtils.degreeTtpNodeName(cpMapEntry.getKey().toString(), "TXRX");
LOG.info("{} : Logical Connection Point for {} on {} is {}",
nodeId,
port.getPortName(), connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
InstanceIdentifier<Ports> port1ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(CircuitPacks.class, new CircuitPacksKey(cp1Name))
.child(Ports.class,
- new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString()));
+ new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName()));
LOG.debug("{} : Fetching connection-port {} at circuit pack {}",
nodeId, connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName(), cp1Name);
Optional<Ports> port1Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
InstanceIdentifier<Ports> port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(CircuitPacks.class, new CircuitPacksKey(cp2Name))
.child(Ports.class,
- new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName().toString()));
+ new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName()));
LOG.debug("{} : Fetching connection-port {} at circuit pack {}",
nodeId, connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName(), cp2Name);
Optional<Ports> port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
Timeouts.DEVICE_READ_TIMEOUT_UNIT);
if (!port1Object.isPresent() || !port2Object.isPresent()) {
LOG.error("No port {} on circuit pack {} for node {}",
- connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString(),
+ connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName(),
connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId);
return false;
}
continue;
}
- String logicalConnectionPoint1 = new StringBuilder("DEG")
- .append(cpMapEntry.getKey())
- .append("-TTP-")
- .append(port1.getPortDirection().getName().toUpperCase(Locale.getDefault()))
- .toString();
+ String logicalConnectionPoint1 = PortMappingUtils.degreeTtpNodeName(cpMapEntry.getKey().toString(),
+ port1.getPortDirection().getName().toUpperCase(Locale.getDefault()));
LOG.info("{} : Logical Connection Point for {} {} is {}",
nodeId,
connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
portMapList.add(createMappingObject(nodeId, port1,
connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
logicalConnectionPoint1));
- String logicalConnectionPoint2 = new StringBuilder("DEG")
- .append(cpMapEntry.getKey())
- .append("-TTP-")
- .append(port2.getPortDirection().getName().toUpperCase(Locale.getDefault()))
- .toString();
+ String logicalConnectionPoint2 = PortMappingUtils.degreeTtpNodeName(cpMapEntry.getKey().toString(),
+ port2.getPortDirection().getName().toUpperCase(Locale.getDefault()));
LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
connectionPortMap.get(cpMapEntry.getKey()).get(1).getCircuitPackName(),
port2.getPortName(), logicalConnectionPoint2);
}
NodeInfoBuilder nodeInfoBldr = new NodeInfoBuilder()
- .setOpenroadmVersion(OpenroadmVersion._121);
+ .setOpenroadmVersion(OpenroadmNodeVersion._121);
// TODO check if we can use here .setNodeType(NodeTypes.forValue(..) such as with 221
switch (deviceInfo.getNodeType().getIntValue()) {
case 1:
Code Review / transportpce.git / blobdiff